11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Universal Interface for Intel High Definition Audio Codec 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Generic widget tree parser 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de> 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * This driver is free software; you can redistribute it and/or modify 91da177e4SLinus Torvalds * it under the terms of the GNU General Public License as published by 101da177e4SLinus Torvalds * the Free Software Foundation; either version 2 of the License, or 111da177e4SLinus Torvalds * (at your option) any later version. 121da177e4SLinus Torvalds * 131da177e4SLinus Torvalds * This driver is distributed in the hope that it will be useful, 141da177e4SLinus Torvalds * but WITHOUT ANY WARRANTY; without even the implied warranty of 151da177e4SLinus Torvalds * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 161da177e4SLinus Torvalds * GNU General Public License for more details. 171da177e4SLinus Torvalds * 181da177e4SLinus Torvalds * You should have received a copy of the GNU General Public License 191da177e4SLinus Torvalds * along with this program; if not, write to the Free Software 201da177e4SLinus Torvalds * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 211da177e4SLinus Torvalds */ 221da177e4SLinus Torvalds 231da177e4SLinus Torvalds #include <linux/init.h> 241da177e4SLinus Torvalds #include <linux/slab.h> 25d81a6d71SPaul Gortmaker #include <linux/export.h> 26352f7f91STakashi Iwai #include <linux/sort.h> 271da177e4SLinus Torvalds #include <sound/core.h> 28352f7f91STakashi Iwai #include <sound/jack.h> 291da177e4SLinus Torvalds #include "hda_codec.h" 301da177e4SLinus Torvalds #include "hda_local.h" 31352f7f91STakashi Iwai #include "hda_auto_parser.h" 32352f7f91STakashi Iwai #include "hda_jack.h" 33352f7f91STakashi Iwai #include "hda_generic.h" 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds 36352f7f91STakashi Iwai /* initialize hda_gen_spec struct */ 37352f7f91STakashi Iwai int snd_hda_gen_spec_init(struct hda_gen_spec *spec) 381da177e4SLinus Torvalds { 39352f7f91STakashi Iwai snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32); 40352f7f91STakashi Iwai snd_array_init(&spec->bind_ctls, sizeof(struct hda_bind_ctls *), 8); 41352f7f91STakashi Iwai snd_array_init(&spec->paths, sizeof(struct nid_path), 8); 42352f7f91STakashi Iwai return 0; 43352f7f91STakashi Iwai } 44352f7f91STakashi Iwai EXPORT_SYMBOL_HDA(snd_hda_gen_spec_init); 451da177e4SLinus Torvalds 46352f7f91STakashi Iwai static struct snd_kcontrol_new * 47352f7f91STakashi Iwai add_kctl(struct hda_gen_spec *spec, const char *name, 48352f7f91STakashi Iwai const struct snd_kcontrol_new *temp) 49352f7f91STakashi Iwai { 50352f7f91STakashi Iwai struct snd_kcontrol_new *knew = snd_array_new(&spec->kctls); 51352f7f91STakashi Iwai if (!knew) 52352f7f91STakashi Iwai return NULL; 53352f7f91STakashi Iwai *knew = *temp; 54352f7f91STakashi Iwai if (name) 55352f7f91STakashi Iwai knew->name = kstrdup(name, GFP_KERNEL); 56352f7f91STakashi Iwai else if (knew->name) 57352f7f91STakashi Iwai knew->name = kstrdup(knew->name, GFP_KERNEL); 58352f7f91STakashi Iwai if (!knew->name) 59352f7f91STakashi Iwai return NULL; 60352f7f91STakashi Iwai return knew; 61352f7f91STakashi Iwai } 62352f7f91STakashi Iwai 63352f7f91STakashi Iwai static void free_kctls(struct hda_gen_spec *spec) 64352f7f91STakashi Iwai { 65352f7f91STakashi Iwai if (spec->kctls.list) { 66352f7f91STakashi Iwai struct snd_kcontrol_new *kctl = spec->kctls.list; 67352f7f91STakashi Iwai int i; 68352f7f91STakashi Iwai for (i = 0; i < spec->kctls.used; i++) 69352f7f91STakashi Iwai kfree(kctl[i].name); 70352f7f91STakashi Iwai } 71352f7f91STakashi Iwai snd_array_free(&spec->kctls); 72352f7f91STakashi Iwai } 73352f7f91STakashi Iwai 74352f7f91STakashi Iwai static struct hda_bind_ctls *new_bind_ctl(struct hda_codec *codec, 75352f7f91STakashi Iwai unsigned int nums, 76352f7f91STakashi Iwai struct hda_ctl_ops *ops) 77352f7f91STakashi Iwai { 78352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 79352f7f91STakashi Iwai struct hda_bind_ctls **ctlp, *ctl; 80352f7f91STakashi Iwai ctlp = snd_array_new(&spec->bind_ctls); 81352f7f91STakashi Iwai if (!ctlp) 82352f7f91STakashi Iwai return NULL; 83352f7f91STakashi Iwai ctl = kzalloc(sizeof(*ctl) + sizeof(long) * (nums + 1), GFP_KERNEL); 84352f7f91STakashi Iwai *ctlp = ctl; 85352f7f91STakashi Iwai if (ctl) 86352f7f91STakashi Iwai ctl->ops = ops; 87352f7f91STakashi Iwai return ctl; 88352f7f91STakashi Iwai } 89352f7f91STakashi Iwai 90352f7f91STakashi Iwai static void free_bind_ctls(struct hda_gen_spec *spec) 91352f7f91STakashi Iwai { 92352f7f91STakashi Iwai if (spec->bind_ctls.list) { 93352f7f91STakashi Iwai struct hda_bind_ctls **ctl = spec->bind_ctls.list; 94352f7f91STakashi Iwai int i; 95352f7f91STakashi Iwai for (i = 0; i < spec->bind_ctls.used; i++) 96352f7f91STakashi Iwai kfree(ctl[i]); 97352f7f91STakashi Iwai } 98352f7f91STakashi Iwai snd_array_free(&spec->bind_ctls); 99352f7f91STakashi Iwai } 100352f7f91STakashi Iwai 101352f7f91STakashi Iwai void snd_hda_gen_spec_free(struct hda_gen_spec *spec) 102352f7f91STakashi Iwai { 1031da177e4SLinus Torvalds if (!spec) 1041da177e4SLinus Torvalds return; 105352f7f91STakashi Iwai free_kctls(spec); 106352f7f91STakashi Iwai free_bind_ctls(spec); 107352f7f91STakashi Iwai snd_array_free(&spec->paths); 1081da177e4SLinus Torvalds } 109352f7f91STakashi Iwai EXPORT_SYMBOL_HDA(snd_hda_gen_spec_free); 1101da177e4SLinus Torvalds 1111da177e4SLinus Torvalds /* 112352f7f91STakashi Iwai * parsing paths 1131da177e4SLinus Torvalds */ 1141da177e4SLinus Torvalds 115352f7f91STakashi Iwai /* get the path between the given NIDs; 116352f7f91STakashi Iwai * passing 0 to either @pin or @dac behaves as a wildcard 1171da177e4SLinus Torvalds */ 118352f7f91STakashi Iwai struct nid_path *snd_hda_get_nid_path(struct hda_codec *codec, 119352f7f91STakashi Iwai hda_nid_t from_nid, hda_nid_t to_nid) 1201da177e4SLinus Torvalds { 121352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 122352f7f91STakashi Iwai int i; 1231da177e4SLinus Torvalds 124352f7f91STakashi Iwai for (i = 0; i < spec->paths.used; i++) { 125352f7f91STakashi Iwai struct nid_path *path = snd_array_elem(&spec->paths, i); 126352f7f91STakashi Iwai if (path->depth <= 0) 127352f7f91STakashi Iwai continue; 128352f7f91STakashi Iwai if ((!from_nid || path->path[0] == from_nid) && 129352f7f91STakashi Iwai (!to_nid || path->path[path->depth - 1] == to_nid)) 130352f7f91STakashi Iwai return path; 1311da177e4SLinus Torvalds } 1321da177e4SLinus Torvalds return NULL; 1331da177e4SLinus Torvalds } 134352f7f91STakashi Iwai EXPORT_SYMBOL_HDA(snd_hda_get_nid_path); 1351da177e4SLinus Torvalds 136352f7f91STakashi Iwai /* check whether the given DAC is already found in any existing paths */ 137352f7f91STakashi Iwai static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid) 1381da177e4SLinus Torvalds { 139352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 140352f7f91STakashi Iwai int i; 141352f7f91STakashi Iwai 142352f7f91STakashi Iwai for (i = 0; i < spec->paths.used; i++) { 143352f7f91STakashi Iwai struct nid_path *path = snd_array_elem(&spec->paths, i); 144352f7f91STakashi Iwai if (path->path[0] == nid) 145352f7f91STakashi Iwai return true; 146352f7f91STakashi Iwai } 147352f7f91STakashi Iwai return false; 1481da177e4SLinus Torvalds } 1491da177e4SLinus Torvalds 150352f7f91STakashi Iwai /* check whether the given two widgets can be connected */ 151352f7f91STakashi Iwai static bool is_reachable_path(struct hda_codec *codec, 152352f7f91STakashi Iwai hda_nid_t from_nid, hda_nid_t to_nid) 1531da177e4SLinus Torvalds { 154352f7f91STakashi Iwai if (!from_nid || !to_nid) 155352f7f91STakashi Iwai return false; 156352f7f91STakashi Iwai return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0; 1571da177e4SLinus Torvalds } 1581da177e4SLinus Torvalds 159352f7f91STakashi Iwai /* nid, dir and idx */ 160352f7f91STakashi Iwai #define AMP_VAL_COMPARE_MASK (0xffff | (1U << 18) | (0x0f << 19)) 161352f7f91STakashi Iwai 162352f7f91STakashi Iwai /* check whether the given ctl is already assigned in any path elements */ 163352f7f91STakashi Iwai static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type) 1641da177e4SLinus Torvalds { 165352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 166352f7f91STakashi Iwai int i; 167352f7f91STakashi Iwai 168352f7f91STakashi Iwai val &= AMP_VAL_COMPARE_MASK; 169352f7f91STakashi Iwai for (i = 0; i < spec->paths.used; i++) { 170352f7f91STakashi Iwai struct nid_path *path = snd_array_elem(&spec->paths, i); 171352f7f91STakashi Iwai if ((path->ctls[type] & AMP_VAL_COMPARE_MASK) == val) 172352f7f91STakashi Iwai return true; 173352f7f91STakashi Iwai } 174352f7f91STakashi Iwai return false; 1751da177e4SLinus Torvalds } 1761da177e4SLinus Torvalds 177352f7f91STakashi Iwai /* check whether a control with the given (nid, dir, idx) was assigned */ 178352f7f91STakashi Iwai static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid, 179cb53c626STakashi Iwai int dir, int idx) 180cb53c626STakashi Iwai { 181352f7f91STakashi Iwai unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir); 182352f7f91STakashi Iwai return is_ctl_used(codec, val, NID_PATH_VOL_CTL) || 183352f7f91STakashi Iwai is_ctl_used(codec, val, NID_PATH_MUTE_CTL); 184cb53c626STakashi Iwai } 185352f7f91STakashi Iwai 186352f7f91STakashi Iwai /* called recursively */ 187352f7f91STakashi Iwai static bool __parse_nid_path(struct hda_codec *codec, 188352f7f91STakashi Iwai hda_nid_t from_nid, hda_nid_t to_nid, 189352f7f91STakashi Iwai int with_aa_mix, struct nid_path *path, int depth) 190352f7f91STakashi Iwai { 191352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 192352f7f91STakashi Iwai hda_nid_t conn[16]; 193352f7f91STakashi Iwai int i, nums; 194352f7f91STakashi Iwai 195352f7f91STakashi Iwai if (to_nid == spec->mixer_nid) { 196352f7f91STakashi Iwai if (!with_aa_mix) 197352f7f91STakashi Iwai return false; 198352f7f91STakashi Iwai with_aa_mix = 2; /* mark aa-mix is included */ 199352f7f91STakashi Iwai } 200352f7f91STakashi Iwai 201352f7f91STakashi Iwai nums = snd_hda_get_connections(codec, to_nid, conn, ARRAY_SIZE(conn)); 202352f7f91STakashi Iwai for (i = 0; i < nums; i++) { 203352f7f91STakashi Iwai if (conn[i] != from_nid) { 204352f7f91STakashi Iwai /* special case: when from_nid is 0, 205352f7f91STakashi Iwai * try to find an empty DAC 206352f7f91STakashi Iwai */ 207352f7f91STakashi Iwai if (from_nid || 208352f7f91STakashi Iwai get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT || 209352f7f91STakashi Iwai is_dac_already_used(codec, conn[i])) 210352f7f91STakashi Iwai continue; 211352f7f91STakashi Iwai } 212352f7f91STakashi Iwai /* aa-mix is requested but not included? */ 213352f7f91STakashi Iwai if (!(spec->mixer_nid && with_aa_mix == 1)) 214352f7f91STakashi Iwai goto found; 215352f7f91STakashi Iwai } 216352f7f91STakashi Iwai if (depth >= MAX_NID_PATH_DEPTH) 217352f7f91STakashi Iwai return false; 218352f7f91STakashi Iwai for (i = 0; i < nums; i++) { 219352f7f91STakashi Iwai unsigned int type; 220352f7f91STakashi Iwai type = get_wcaps_type(get_wcaps(codec, conn[i])); 221352f7f91STakashi Iwai if (type == AC_WID_AUD_OUT || type == AC_WID_AUD_IN || 222352f7f91STakashi Iwai type == AC_WID_PIN) 223352f7f91STakashi Iwai continue; 224352f7f91STakashi Iwai if (__parse_nid_path(codec, from_nid, conn[i], 225352f7f91STakashi Iwai with_aa_mix, path, depth + 1)) 226352f7f91STakashi Iwai goto found; 227352f7f91STakashi Iwai } 228352f7f91STakashi Iwai return false; 229352f7f91STakashi Iwai 230352f7f91STakashi Iwai found: 231352f7f91STakashi Iwai path->path[path->depth] = conn[i]; 232352f7f91STakashi Iwai path->idx[path->depth + 1] = i; 233352f7f91STakashi Iwai if (nums > 1 && get_wcaps_type(get_wcaps(codec, to_nid)) != AC_WID_AUD_MIX) 234352f7f91STakashi Iwai path->multi[path->depth + 1] = 1; 235352f7f91STakashi Iwai path->depth++; 236352f7f91STakashi Iwai return true; 237352f7f91STakashi Iwai } 238352f7f91STakashi Iwai 239352f7f91STakashi Iwai /* parse the widget path from the given nid to the target nid; 240352f7f91STakashi Iwai * when @from_nid is 0, try to find an empty DAC; 241352f7f91STakashi Iwai * when @with_aa_mix is 0, paths with spec->mixer_nid are excluded. 242352f7f91STakashi Iwai * when @with_aa_mix is 1, paths without spec->mixer_nid are excluded. 243352f7f91STakashi Iwai * when @with_aa_mix is 2, no special handling about spec->mixer_nid. 244352f7f91STakashi Iwai */ 245352f7f91STakashi Iwai bool snd_hda_parse_nid_path(struct hda_codec *codec, hda_nid_t from_nid, 246352f7f91STakashi Iwai hda_nid_t to_nid, int with_aa_mix, 247352f7f91STakashi Iwai struct nid_path *path) 248352f7f91STakashi Iwai { 249352f7f91STakashi Iwai if (__parse_nid_path(codec, from_nid, to_nid, with_aa_mix, path, 1)) { 250352f7f91STakashi Iwai path->path[path->depth] = to_nid; 251352f7f91STakashi Iwai path->depth++; 252352f7f91STakashi Iwai #if 0 253352f7f91STakashi Iwai snd_printdd("path: depth=%d, %02x/%02x/%02x/%02x/%02x\n", 254352f7f91STakashi Iwai path->depth, path->path[0], path->path[1], 255352f7f91STakashi Iwai path->path[2], path->path[3], path->path[4]); 256352f7f91STakashi Iwai #endif 257352f7f91STakashi Iwai return true; 258352f7f91STakashi Iwai } 259352f7f91STakashi Iwai return false; 260352f7f91STakashi Iwai } 261352f7f91STakashi Iwai EXPORT_SYMBOL_HDA(snd_hda_parse_nid_path); 262352f7f91STakashi Iwai 263352f7f91STakashi Iwai /* 264352f7f91STakashi Iwai * parse the path between the given NIDs and add to the path list. 265352f7f91STakashi Iwai * if no valid path is found, return NULL 266352f7f91STakashi Iwai */ 267352f7f91STakashi Iwai struct nid_path * 268352f7f91STakashi Iwai snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid, 269352f7f91STakashi Iwai hda_nid_t to_nid, int with_aa_mix) 270352f7f91STakashi Iwai { 271352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 272352f7f91STakashi Iwai struct nid_path *path; 273352f7f91STakashi Iwai 274352f7f91STakashi Iwai if (from_nid && to_nid && !is_reachable_path(codec, from_nid, to_nid)) 275352f7f91STakashi Iwai return NULL; 276352f7f91STakashi Iwai 277352f7f91STakashi Iwai path = snd_array_new(&spec->paths); 278352f7f91STakashi Iwai if (!path) 279352f7f91STakashi Iwai return NULL; 280352f7f91STakashi Iwai memset(path, 0, sizeof(*path)); 281352f7f91STakashi Iwai if (snd_hda_parse_nid_path(codec, from_nid, to_nid, with_aa_mix, path)) 282352f7f91STakashi Iwai return path; 283352f7f91STakashi Iwai /* push back */ 284352f7f91STakashi Iwai spec->paths.used--; 285352f7f91STakashi Iwai return NULL; 286352f7f91STakashi Iwai } 287352f7f91STakashi Iwai EXPORT_SYMBOL_HDA(snd_hda_add_new_path); 288352f7f91STakashi Iwai 289352f7f91STakashi Iwai /* look for an empty DAC slot */ 290352f7f91STakashi Iwai static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin, 291352f7f91STakashi Iwai bool is_digital) 292352f7f91STakashi Iwai { 293352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 294352f7f91STakashi Iwai bool cap_digital; 295352f7f91STakashi Iwai int i; 296352f7f91STakashi Iwai 297352f7f91STakashi Iwai for (i = 0; i < spec->num_all_dacs; i++) { 298352f7f91STakashi Iwai hda_nid_t nid = spec->all_dacs[i]; 299352f7f91STakashi Iwai if (!nid || is_dac_already_used(codec, nid)) 300352f7f91STakashi Iwai continue; 301352f7f91STakashi Iwai cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL); 302352f7f91STakashi Iwai if (is_digital != cap_digital) 303352f7f91STakashi Iwai continue; 304352f7f91STakashi Iwai if (is_reachable_path(codec, nid, pin)) 305352f7f91STakashi Iwai return nid; 306352f7f91STakashi Iwai } 307352f7f91STakashi Iwai return 0; 308352f7f91STakashi Iwai } 309352f7f91STakashi Iwai 310352f7f91STakashi Iwai /* replace the channels in the composed amp value with the given number */ 311352f7f91STakashi Iwai static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs) 312352f7f91STakashi Iwai { 313352f7f91STakashi Iwai val &= ~(0x3U << 16); 314352f7f91STakashi Iwai val |= chs << 16; 315352f7f91STakashi Iwai return val; 316352f7f91STakashi Iwai } 317352f7f91STakashi Iwai 318352f7f91STakashi Iwai /* check whether the widget has the given amp capability for the direction */ 319352f7f91STakashi Iwai static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid, 320352f7f91STakashi Iwai int dir, unsigned int bits) 321352f7f91STakashi Iwai { 322352f7f91STakashi Iwai if (!nid) 323352f7f91STakashi Iwai return false; 324352f7f91STakashi Iwai if (get_wcaps(codec, nid) & (1 << (dir + 1))) 325352f7f91STakashi Iwai if (query_amp_caps(codec, nid, dir) & bits) 326352f7f91STakashi Iwai return true; 327352f7f91STakashi Iwai return false; 328352f7f91STakashi Iwai } 329352f7f91STakashi Iwai 330352f7f91STakashi Iwai #define nid_has_mute(codec, nid, dir) \ 331352f7f91STakashi Iwai check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE) 332352f7f91STakashi Iwai #define nid_has_volume(codec, nid, dir) \ 333352f7f91STakashi Iwai check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS) 334352f7f91STakashi Iwai 335352f7f91STakashi Iwai /* look for a widget suitable for assigning a mute switch in the path */ 336352f7f91STakashi Iwai static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec, 337352f7f91STakashi Iwai struct nid_path *path) 338352f7f91STakashi Iwai { 339352f7f91STakashi Iwai int i; 340352f7f91STakashi Iwai 341352f7f91STakashi Iwai for (i = path->depth - 1; i >= 0; i--) { 342352f7f91STakashi Iwai if (nid_has_mute(codec, path->path[i], HDA_OUTPUT)) 343352f7f91STakashi Iwai return path->path[i]; 344352f7f91STakashi Iwai if (i != path->depth - 1 && i != 0 && 345352f7f91STakashi Iwai nid_has_mute(codec, path->path[i], HDA_INPUT)) 346352f7f91STakashi Iwai return path->path[i]; 347352f7f91STakashi Iwai } 348352f7f91STakashi Iwai return 0; 349352f7f91STakashi Iwai } 350352f7f91STakashi Iwai 351352f7f91STakashi Iwai /* look for a widget suitable for assigning a volume ctl in the path */ 352352f7f91STakashi Iwai static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec, 353352f7f91STakashi Iwai struct nid_path *path) 354352f7f91STakashi Iwai { 355352f7f91STakashi Iwai int i; 356352f7f91STakashi Iwai 357352f7f91STakashi Iwai for (i = path->depth - 1; i >= 0; i--) { 358352f7f91STakashi Iwai if (nid_has_volume(codec, path->path[i], HDA_OUTPUT)) 359352f7f91STakashi Iwai return path->path[i]; 360352f7f91STakashi Iwai } 361352f7f91STakashi Iwai return 0; 362352f7f91STakashi Iwai } 363352f7f91STakashi Iwai 364352f7f91STakashi Iwai /* 365352f7f91STakashi Iwai * path activation / deactivation 366352f7f91STakashi Iwai */ 367352f7f91STakashi Iwai 368352f7f91STakashi Iwai /* can have the amp-in capability? */ 369352f7f91STakashi Iwai static bool has_amp_in(struct hda_codec *codec, struct nid_path *path, int idx) 370352f7f91STakashi Iwai { 371352f7f91STakashi Iwai hda_nid_t nid = path->path[idx]; 372352f7f91STakashi Iwai unsigned int caps = get_wcaps(codec, nid); 373352f7f91STakashi Iwai unsigned int type = get_wcaps_type(caps); 374352f7f91STakashi Iwai 375352f7f91STakashi Iwai if (!(caps & AC_WCAP_IN_AMP)) 376352f7f91STakashi Iwai return false; 377352f7f91STakashi Iwai if (type == AC_WID_PIN && idx > 0) /* only for input pins */ 378352f7f91STakashi Iwai return false; 379352f7f91STakashi Iwai return true; 380352f7f91STakashi Iwai } 381352f7f91STakashi Iwai 382352f7f91STakashi Iwai /* can have the amp-out capability? */ 383352f7f91STakashi Iwai static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx) 384352f7f91STakashi Iwai { 385352f7f91STakashi Iwai hda_nid_t nid = path->path[idx]; 386352f7f91STakashi Iwai unsigned int caps = get_wcaps(codec, nid); 387352f7f91STakashi Iwai unsigned int type = get_wcaps_type(caps); 388352f7f91STakashi Iwai 389352f7f91STakashi Iwai if (!(caps & AC_WCAP_OUT_AMP)) 390352f7f91STakashi Iwai return false; 391352f7f91STakashi Iwai if (type == AC_WID_PIN && !idx) /* only for output pins */ 392352f7f91STakashi Iwai return false; 393352f7f91STakashi Iwai return true; 394352f7f91STakashi Iwai } 395352f7f91STakashi Iwai 396352f7f91STakashi Iwai /* check whether the given (nid,dir,idx) is active */ 397352f7f91STakashi Iwai static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid, 398352f7f91STakashi Iwai unsigned int idx, unsigned int dir) 399352f7f91STakashi Iwai { 400352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 401352f7f91STakashi Iwai int i, n; 402352f7f91STakashi Iwai 403352f7f91STakashi Iwai for (n = 0; n < spec->paths.used; n++) { 404352f7f91STakashi Iwai struct nid_path *path = snd_array_elem(&spec->paths, n); 405352f7f91STakashi Iwai if (!path->active) 406352f7f91STakashi Iwai continue; 407352f7f91STakashi Iwai for (i = 0; i < path->depth; i++) { 408352f7f91STakashi Iwai if (path->path[i] == nid) { 409352f7f91STakashi Iwai if (dir == HDA_OUTPUT || path->idx[i] == idx) 410352f7f91STakashi Iwai return true; 411352f7f91STakashi Iwai break; 412352f7f91STakashi Iwai } 413352f7f91STakashi Iwai } 414352f7f91STakashi Iwai } 415352f7f91STakashi Iwai return false; 416352f7f91STakashi Iwai } 417352f7f91STakashi Iwai 418352f7f91STakashi Iwai /* get the default amp value for the target state */ 419352f7f91STakashi Iwai static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid, 420352f7f91STakashi Iwai int dir, bool enable) 421352f7f91STakashi Iwai { 422352f7f91STakashi Iwai unsigned int caps; 423352f7f91STakashi Iwai unsigned int val = 0; 424352f7f91STakashi Iwai 425352f7f91STakashi Iwai caps = query_amp_caps(codec, nid, dir); 426352f7f91STakashi Iwai if (caps & AC_AMPCAP_NUM_STEPS) { 427352f7f91STakashi Iwai /* set to 0dB */ 428352f7f91STakashi Iwai if (enable) 429352f7f91STakashi Iwai val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT; 430352f7f91STakashi Iwai } 431352f7f91STakashi Iwai if (caps & AC_AMPCAP_MUTE) { 432352f7f91STakashi Iwai if (!enable) 433352f7f91STakashi Iwai val |= HDA_AMP_MUTE; 434352f7f91STakashi Iwai } 435352f7f91STakashi Iwai return val; 436352f7f91STakashi Iwai } 437352f7f91STakashi Iwai 438352f7f91STakashi Iwai /* initialize the amp value (only at the first time) */ 439352f7f91STakashi Iwai static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx) 440352f7f91STakashi Iwai { 441352f7f91STakashi Iwai int val = get_amp_val_to_activate(codec, nid, dir, false); 442352f7f91STakashi Iwai snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val); 443352f7f91STakashi Iwai } 444352f7f91STakashi Iwai 445352f7f91STakashi Iwai static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir, 446352f7f91STakashi Iwai int idx, bool enable) 447352f7f91STakashi Iwai { 448352f7f91STakashi Iwai int val; 449352f7f91STakashi Iwai if (is_ctl_associated(codec, nid, dir, idx) || 450352f7f91STakashi Iwai is_active_nid(codec, nid, dir, idx)) 451352f7f91STakashi Iwai return; 452352f7f91STakashi Iwai val = get_amp_val_to_activate(codec, nid, dir, enable); 453352f7f91STakashi Iwai snd_hda_codec_amp_stereo(codec, nid, dir, idx, 0xff, val); 454352f7f91STakashi Iwai } 455352f7f91STakashi Iwai 456352f7f91STakashi Iwai static void activate_amp_out(struct hda_codec *codec, struct nid_path *path, 457352f7f91STakashi Iwai int i, bool enable) 458352f7f91STakashi Iwai { 459352f7f91STakashi Iwai hda_nid_t nid = path->path[i]; 460352f7f91STakashi Iwai init_amp(codec, nid, HDA_OUTPUT, 0); 461352f7f91STakashi Iwai activate_amp(codec, nid, HDA_OUTPUT, 0, enable); 462352f7f91STakashi Iwai } 463352f7f91STakashi Iwai 464352f7f91STakashi Iwai static void activate_amp_in(struct hda_codec *codec, struct nid_path *path, 465352f7f91STakashi Iwai int i, bool enable, bool add_aamix) 466352f7f91STakashi Iwai { 467352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 468352f7f91STakashi Iwai hda_nid_t conn[16]; 469352f7f91STakashi Iwai int n, nums, idx; 470352f7f91STakashi Iwai int type; 471352f7f91STakashi Iwai hda_nid_t nid = path->path[i]; 472352f7f91STakashi Iwai 473352f7f91STakashi Iwai nums = snd_hda_get_connections(codec, nid, conn, ARRAY_SIZE(conn)); 474352f7f91STakashi Iwai type = get_wcaps_type(get_wcaps(codec, nid)); 475352f7f91STakashi Iwai if (type == AC_WID_PIN || 476352f7f91STakashi Iwai (type == AC_WID_AUD_IN && codec->single_adc_amp)) { 477352f7f91STakashi Iwai nums = 1; 478352f7f91STakashi Iwai idx = 0; 479352f7f91STakashi Iwai } else 480352f7f91STakashi Iwai idx = path->idx[i]; 481352f7f91STakashi Iwai 482352f7f91STakashi Iwai for (n = 0; n < nums; n++) 483352f7f91STakashi Iwai init_amp(codec, nid, HDA_INPUT, n); 484352f7f91STakashi Iwai 485352f7f91STakashi Iwai if (is_ctl_associated(codec, nid, HDA_INPUT, idx)) 486352f7f91STakashi Iwai return; 487352f7f91STakashi Iwai 488352f7f91STakashi Iwai /* here is a little bit tricky in comparison with activate_amp_out(); 489352f7f91STakashi Iwai * when aa-mixer is available, we need to enable the path as well 490352f7f91STakashi Iwai */ 491352f7f91STakashi Iwai for (n = 0; n < nums; n++) { 492352f7f91STakashi Iwai if (n != idx && (!add_aamix || conn[n] != spec->mixer_nid)) 493352f7f91STakashi Iwai continue; 494352f7f91STakashi Iwai activate_amp(codec, nid, HDA_INPUT, n, enable); 495352f7f91STakashi Iwai } 496352f7f91STakashi Iwai } 497352f7f91STakashi Iwai 498352f7f91STakashi Iwai /* activate or deactivate the given path 499352f7f91STakashi Iwai * if @add_aamix is set, enable the input from aa-mix NID as well (if any) 500352f7f91STakashi Iwai */ 501352f7f91STakashi Iwai void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path, 502352f7f91STakashi Iwai bool enable, bool add_aamix) 503352f7f91STakashi Iwai { 504352f7f91STakashi Iwai int i; 505352f7f91STakashi Iwai 506352f7f91STakashi Iwai if (!enable) 507352f7f91STakashi Iwai path->active = false; 508352f7f91STakashi Iwai 509352f7f91STakashi Iwai for (i = path->depth - 1; i >= 0; i--) { 510352f7f91STakashi Iwai if (enable && path->multi[i]) 511352f7f91STakashi Iwai snd_hda_codec_write_cache(codec, path->path[i], 0, 512352f7f91STakashi Iwai AC_VERB_SET_CONNECT_SEL, 513352f7f91STakashi Iwai path->idx[i]); 514352f7f91STakashi Iwai if (has_amp_in(codec, path, i)) 515352f7f91STakashi Iwai activate_amp_in(codec, path, i, enable, add_aamix); 516352f7f91STakashi Iwai if (has_amp_out(codec, path, i)) 517352f7f91STakashi Iwai activate_amp_out(codec, path, i, enable); 518352f7f91STakashi Iwai } 519352f7f91STakashi Iwai 520352f7f91STakashi Iwai if (enable) 521352f7f91STakashi Iwai path->active = true; 522352f7f91STakashi Iwai } 523352f7f91STakashi Iwai EXPORT_SYMBOL_HDA(snd_hda_activate_path); 524352f7f91STakashi Iwai 525352f7f91STakashi Iwai 526352f7f91STakashi Iwai /* 527352f7f91STakashi Iwai * Helper functions for creating mixer ctl elements 528352f7f91STakashi Iwai */ 529352f7f91STakashi Iwai 530352f7f91STakashi Iwai enum { 531352f7f91STakashi Iwai HDA_CTL_WIDGET_VOL, 532352f7f91STakashi Iwai HDA_CTL_WIDGET_MUTE, 533352f7f91STakashi Iwai HDA_CTL_BIND_MUTE, 534352f7f91STakashi Iwai HDA_CTL_BIND_VOL, 535352f7f91STakashi Iwai HDA_CTL_BIND_SW, 536352f7f91STakashi Iwai }; 537352f7f91STakashi Iwai static const struct snd_kcontrol_new control_templates[] = { 538352f7f91STakashi Iwai HDA_CODEC_VOLUME(NULL, 0, 0, 0), 539352f7f91STakashi Iwai HDA_CODEC_MUTE(NULL, 0, 0, 0), 540352f7f91STakashi Iwai HDA_BIND_MUTE(NULL, 0, 0, 0), 541352f7f91STakashi Iwai HDA_BIND_VOL(NULL, 0), 542352f7f91STakashi Iwai HDA_BIND_SW(NULL, 0), 543352f7f91STakashi Iwai }; 544352f7f91STakashi Iwai 545352f7f91STakashi Iwai /* add dynamic controls from template */ 546352f7f91STakashi Iwai static int add_control(struct hda_gen_spec *spec, int type, const char *name, 547352f7f91STakashi Iwai int cidx, unsigned long val) 548352f7f91STakashi Iwai { 549352f7f91STakashi Iwai struct snd_kcontrol_new *knew; 550352f7f91STakashi Iwai 551352f7f91STakashi Iwai knew = add_kctl(spec, name, &control_templates[type]); 552352f7f91STakashi Iwai if (!knew) 553352f7f91STakashi Iwai return -ENOMEM; 554352f7f91STakashi Iwai knew->index = cidx; 555352f7f91STakashi Iwai if (get_amp_nid_(val)) 556352f7f91STakashi Iwai knew->subdevice = HDA_SUBDEV_AMP_FLAG; 557352f7f91STakashi Iwai knew->private_value = val; 558352f7f91STakashi Iwai return 0; 559352f7f91STakashi Iwai } 560352f7f91STakashi Iwai 561352f7f91STakashi Iwai static int add_control_with_pfx(struct hda_gen_spec *spec, int type, 562352f7f91STakashi Iwai const char *pfx, const char *dir, 563352f7f91STakashi Iwai const char *sfx, int cidx, unsigned long val) 564352f7f91STakashi Iwai { 565352f7f91STakashi Iwai char name[32]; 566352f7f91STakashi Iwai snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx); 567352f7f91STakashi Iwai return add_control(spec, type, name, cidx, val); 568352f7f91STakashi Iwai } 569352f7f91STakashi Iwai 570352f7f91STakashi Iwai #define add_pb_vol_ctrl(spec, type, pfx, val) \ 571352f7f91STakashi Iwai add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val) 572352f7f91STakashi Iwai #define add_pb_sw_ctrl(spec, type, pfx, val) \ 573352f7f91STakashi Iwai add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val) 574352f7f91STakashi Iwai #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \ 575352f7f91STakashi Iwai add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val) 576352f7f91STakashi Iwai #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \ 577352f7f91STakashi Iwai add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val) 578352f7f91STakashi Iwai 579352f7f91STakashi Iwai static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx, 580352f7f91STakashi Iwai unsigned int chs, struct nid_path *path) 581352f7f91STakashi Iwai { 582352f7f91STakashi Iwai unsigned int val; 583352f7f91STakashi Iwai if (!path) 584352f7f91STakashi Iwai return 0; 585352f7f91STakashi Iwai val = path->ctls[NID_PATH_VOL_CTL]; 586352f7f91STakashi Iwai if (!val) 587352f7f91STakashi Iwai return 0; 588352f7f91STakashi Iwai val = amp_val_replace_channels(val, chs); 589352f7f91STakashi Iwai return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val); 590352f7f91STakashi Iwai } 591352f7f91STakashi Iwai 592352f7f91STakashi Iwai /* return the channel bits suitable for the given path->ctls[] */ 593352f7f91STakashi Iwai static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path, 594352f7f91STakashi Iwai int type) 595352f7f91STakashi Iwai { 596352f7f91STakashi Iwai int chs = 1; /* mono (left only) */ 597352f7f91STakashi Iwai if (path) { 598352f7f91STakashi Iwai hda_nid_t nid = get_amp_nid_(path->ctls[type]); 599352f7f91STakashi Iwai if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO)) 600352f7f91STakashi Iwai chs = 3; /* stereo */ 601352f7f91STakashi Iwai } 602352f7f91STakashi Iwai return chs; 603352f7f91STakashi Iwai } 604352f7f91STakashi Iwai 605352f7f91STakashi Iwai static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx, 606352f7f91STakashi Iwai struct nid_path *path) 607352f7f91STakashi Iwai { 608352f7f91STakashi Iwai int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL); 609352f7f91STakashi Iwai return add_vol_ctl(codec, pfx, cidx, chs, path); 610352f7f91STakashi Iwai } 611352f7f91STakashi Iwai 612352f7f91STakashi Iwai /* create a mute-switch for the given mixer widget; 613352f7f91STakashi Iwai * if it has multiple sources (e.g. DAC and loopback), create a bind-mute 614352f7f91STakashi Iwai */ 615352f7f91STakashi Iwai static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx, 616352f7f91STakashi Iwai unsigned int chs, struct nid_path *path) 617352f7f91STakashi Iwai { 618352f7f91STakashi Iwai unsigned int val; 619352f7f91STakashi Iwai int type = HDA_CTL_WIDGET_MUTE; 620352f7f91STakashi Iwai 621352f7f91STakashi Iwai if (!path) 622352f7f91STakashi Iwai return 0; 623352f7f91STakashi Iwai val = path->ctls[NID_PATH_MUTE_CTL]; 624352f7f91STakashi Iwai if (!val) 625352f7f91STakashi Iwai return 0; 626352f7f91STakashi Iwai val = amp_val_replace_channels(val, chs); 627352f7f91STakashi Iwai if (get_amp_direction_(val) == HDA_INPUT) { 628352f7f91STakashi Iwai hda_nid_t nid = get_amp_nid_(val); 629352f7f91STakashi Iwai int nums = snd_hda_get_num_conns(codec, nid); 630352f7f91STakashi Iwai if (nums > 1) { 631352f7f91STakashi Iwai type = HDA_CTL_BIND_MUTE; 632352f7f91STakashi Iwai val |= nums << 19; 633352f7f91STakashi Iwai } 634352f7f91STakashi Iwai } 635352f7f91STakashi Iwai return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val); 636352f7f91STakashi Iwai } 637352f7f91STakashi Iwai 638352f7f91STakashi Iwai static int add_stereo_sw(struct hda_codec *codec, const char *pfx, 639352f7f91STakashi Iwai int cidx, struct nid_path *path) 640352f7f91STakashi Iwai { 641352f7f91STakashi Iwai int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL); 642352f7f91STakashi Iwai return add_sw_ctl(codec, pfx, cidx, chs, path); 643352f7f91STakashi Iwai } 644352f7f91STakashi Iwai 645352f7f91STakashi Iwai static const char * const channel_name[4] = { 646352f7f91STakashi Iwai "Front", "Surround", "CLFE", "Side" 647352f7f91STakashi Iwai }; 648352f7f91STakashi Iwai 649352f7f91STakashi Iwai /* give some appropriate ctl name prefix for the given line out channel */ 650352f7f91STakashi Iwai static const char *get_line_out_pfx(struct hda_gen_spec *spec, int ch, 651352f7f91STakashi Iwai bool can_be_master, int *index) 652352f7f91STakashi Iwai { 653352f7f91STakashi Iwai struct auto_pin_cfg *cfg = &spec->autocfg; 654352f7f91STakashi Iwai 655352f7f91STakashi Iwai *index = 0; 656352f7f91STakashi Iwai if (cfg->line_outs == 1 && !spec->multi_ios && 657352f7f91STakashi Iwai !cfg->hp_outs && !cfg->speaker_outs && can_be_master) 658352f7f91STakashi Iwai return spec->vmaster_mute.hook ? "PCM" : "Master"; 659352f7f91STakashi Iwai 660352f7f91STakashi Iwai /* if there is really a single DAC used in the whole output paths, 661352f7f91STakashi Iwai * use it master (or "PCM" if a vmaster hook is present) 662352f7f91STakashi Iwai */ 663352f7f91STakashi Iwai if (spec->multiout.num_dacs == 1 && !spec->mixer_nid && 664352f7f91STakashi Iwai !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0]) 665352f7f91STakashi Iwai return spec->vmaster_mute.hook ? "PCM" : "Master"; 666352f7f91STakashi Iwai 667352f7f91STakashi Iwai switch (cfg->line_out_type) { 668352f7f91STakashi Iwai case AUTO_PIN_SPEAKER_OUT: 669352f7f91STakashi Iwai if (cfg->line_outs == 1) 670352f7f91STakashi Iwai return "Speaker"; 671352f7f91STakashi Iwai if (cfg->line_outs == 2) 672352f7f91STakashi Iwai return ch ? "Bass Speaker" : "Speaker"; 673352f7f91STakashi Iwai break; 674352f7f91STakashi Iwai case AUTO_PIN_HP_OUT: 675352f7f91STakashi Iwai /* for multi-io case, only the primary out */ 676352f7f91STakashi Iwai if (ch && spec->multi_ios) 677352f7f91STakashi Iwai break; 678352f7f91STakashi Iwai *index = ch; 679352f7f91STakashi Iwai return "Headphone"; 680352f7f91STakashi Iwai default: 681352f7f91STakashi Iwai if (cfg->line_outs == 1 && !spec->multi_ios) 682352f7f91STakashi Iwai return "PCM"; 683352f7f91STakashi Iwai break; 684352f7f91STakashi Iwai } 685352f7f91STakashi Iwai if (ch >= ARRAY_SIZE(channel_name)) { 686352f7f91STakashi Iwai snd_BUG(); 687352f7f91STakashi Iwai return "PCM"; 688352f7f91STakashi Iwai } 689352f7f91STakashi Iwai 690352f7f91STakashi Iwai return channel_name[ch]; 691352f7f91STakashi Iwai } 692352f7f91STakashi Iwai 693352f7f91STakashi Iwai /* 694352f7f91STakashi Iwai * Parse output paths 695352f7f91STakashi Iwai */ 696352f7f91STakashi Iwai 697352f7f91STakashi Iwai /* badness definition */ 698352f7f91STakashi Iwai enum { 699352f7f91STakashi Iwai /* No primary DAC is found for the main output */ 700352f7f91STakashi Iwai BAD_NO_PRIMARY_DAC = 0x10000, 701352f7f91STakashi Iwai /* No DAC is found for the extra output */ 702352f7f91STakashi Iwai BAD_NO_DAC = 0x4000, 703352f7f91STakashi Iwai /* No possible multi-ios */ 704352f7f91STakashi Iwai BAD_MULTI_IO = 0x103, 705352f7f91STakashi Iwai /* No individual DAC for extra output */ 706352f7f91STakashi Iwai BAD_NO_EXTRA_DAC = 0x102, 707352f7f91STakashi Iwai /* No individual DAC for extra surrounds */ 708352f7f91STakashi Iwai BAD_NO_EXTRA_SURR_DAC = 0x101, 709352f7f91STakashi Iwai /* Primary DAC shared with main surrounds */ 710352f7f91STakashi Iwai BAD_SHARED_SURROUND = 0x100, 711352f7f91STakashi Iwai /* Primary DAC shared with main CLFE */ 712352f7f91STakashi Iwai BAD_SHARED_CLFE = 0x10, 713352f7f91STakashi Iwai /* Primary DAC shared with extra surrounds */ 714352f7f91STakashi Iwai BAD_SHARED_EXTRA_SURROUND = 0x10, 715352f7f91STakashi Iwai /* Volume widget is shared */ 716352f7f91STakashi Iwai BAD_SHARED_VOL = 0x10, 717352f7f91STakashi Iwai }; 718352f7f91STakashi Iwai 719352f7f91STakashi Iwai /* look for widgets in the path between the given NIDs appropriate for 720352f7f91STakashi Iwai * volume and mute controls, and assign the values to ctls[]. 721352f7f91STakashi Iwai * 722352f7f91STakashi Iwai * When no appropriate widget is found in the path, the badness value 723352f7f91STakashi Iwai * is incremented depending on the situation. The function returns the 724352f7f91STakashi Iwai * total badness for both volume and mute controls. 725352f7f91STakashi Iwai */ 726352f7f91STakashi Iwai static int assign_out_path_ctls(struct hda_codec *codec, hda_nid_t pin, 727352f7f91STakashi Iwai hda_nid_t dac) 728352f7f91STakashi Iwai { 729352f7f91STakashi Iwai struct nid_path *path = snd_hda_get_nid_path(codec, dac, pin); 730352f7f91STakashi Iwai hda_nid_t nid; 731352f7f91STakashi Iwai unsigned int val; 732352f7f91STakashi Iwai int badness = 0; 733352f7f91STakashi Iwai 734352f7f91STakashi Iwai if (!path) 735352f7f91STakashi Iwai return BAD_SHARED_VOL * 2; 736352f7f91STakashi Iwai nid = look_for_out_vol_nid(codec, path); 737352f7f91STakashi Iwai if (nid) { 738352f7f91STakashi Iwai val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 739352f7f91STakashi Iwai if (is_ctl_used(codec, val, NID_PATH_VOL_CTL)) 740352f7f91STakashi Iwai badness += BAD_SHARED_VOL; 741352f7f91STakashi Iwai else 742352f7f91STakashi Iwai path->ctls[NID_PATH_VOL_CTL] = val; 743352f7f91STakashi Iwai } else 744352f7f91STakashi Iwai badness += BAD_SHARED_VOL; 745352f7f91STakashi Iwai nid = look_for_out_mute_nid(codec, path); 746352f7f91STakashi Iwai if (nid) { 747352f7f91STakashi Iwai unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid)); 748352f7f91STakashi Iwai if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT || 749352f7f91STakashi Iwai nid_has_mute(codec, nid, HDA_OUTPUT)) 750352f7f91STakashi Iwai val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 751352f7f91STakashi Iwai else 752352f7f91STakashi Iwai val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT); 753352f7f91STakashi Iwai if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL)) 754352f7f91STakashi Iwai badness += BAD_SHARED_VOL; 755352f7f91STakashi Iwai else 756352f7f91STakashi Iwai path->ctls[NID_PATH_MUTE_CTL] = val; 757352f7f91STakashi Iwai } else 758352f7f91STakashi Iwai badness += BAD_SHARED_VOL; 759352f7f91STakashi Iwai return badness; 760352f7f91STakashi Iwai } 761352f7f91STakashi Iwai 762352f7f91STakashi Iwai struct badness_table { 763352f7f91STakashi Iwai int no_primary_dac; /* no primary DAC */ 764352f7f91STakashi Iwai int no_dac; /* no secondary DACs */ 765352f7f91STakashi Iwai int shared_primary; /* primary DAC is shared with main output */ 766352f7f91STakashi Iwai int shared_surr; /* secondary DAC shared with main or primary */ 767352f7f91STakashi Iwai int shared_clfe; /* third DAC shared with main or primary */ 768352f7f91STakashi Iwai int shared_surr_main; /* secondary DAC sahred with main/DAC0 */ 769352f7f91STakashi Iwai }; 770352f7f91STakashi Iwai 771352f7f91STakashi Iwai static struct badness_table main_out_badness = { 772352f7f91STakashi Iwai .no_primary_dac = BAD_NO_PRIMARY_DAC, 773352f7f91STakashi Iwai .no_dac = BAD_NO_DAC, 774352f7f91STakashi Iwai .shared_primary = BAD_NO_PRIMARY_DAC, 775352f7f91STakashi Iwai .shared_surr = BAD_SHARED_SURROUND, 776352f7f91STakashi Iwai .shared_clfe = BAD_SHARED_CLFE, 777352f7f91STakashi Iwai .shared_surr_main = BAD_SHARED_SURROUND, 778352f7f91STakashi Iwai }; 779352f7f91STakashi Iwai 780352f7f91STakashi Iwai static struct badness_table extra_out_badness = { 781352f7f91STakashi Iwai .no_primary_dac = BAD_NO_DAC, 782352f7f91STakashi Iwai .no_dac = BAD_NO_DAC, 783352f7f91STakashi Iwai .shared_primary = BAD_NO_EXTRA_DAC, 784352f7f91STakashi Iwai .shared_surr = BAD_SHARED_EXTRA_SURROUND, 785352f7f91STakashi Iwai .shared_clfe = BAD_SHARED_EXTRA_SURROUND, 786352f7f91STakashi Iwai .shared_surr_main = BAD_NO_EXTRA_SURR_DAC, 787352f7f91STakashi Iwai }; 788352f7f91STakashi Iwai 789352f7f91STakashi Iwai /* try to assign DACs to pins and return the resultant badness */ 790352f7f91STakashi Iwai static int try_assign_dacs(struct hda_codec *codec, int num_outs, 791352f7f91STakashi Iwai const hda_nid_t *pins, hda_nid_t *dacs, 792352f7f91STakashi Iwai const struct badness_table *bad) 793352f7f91STakashi Iwai { 794352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 795352f7f91STakashi Iwai struct auto_pin_cfg *cfg = &spec->autocfg; 796352f7f91STakashi Iwai int i, j; 797352f7f91STakashi Iwai int badness = 0; 798352f7f91STakashi Iwai hda_nid_t dac; 799352f7f91STakashi Iwai 800352f7f91STakashi Iwai if (!num_outs) 801352f7f91STakashi Iwai return 0; 802352f7f91STakashi Iwai 803352f7f91STakashi Iwai for (i = 0; i < num_outs; i++) { 804352f7f91STakashi Iwai hda_nid_t pin = pins[i]; 805352f7f91STakashi Iwai if (!dacs[i]) 806352f7f91STakashi Iwai dacs[i] = look_for_dac(codec, pin, false); 807352f7f91STakashi Iwai if (!dacs[i] && !i) { 808352f7f91STakashi Iwai for (j = 1; j < num_outs; j++) { 809352f7f91STakashi Iwai if (is_reachable_path(codec, dacs[j], pin)) { 810352f7f91STakashi Iwai dacs[0] = dacs[j]; 811352f7f91STakashi Iwai dacs[j] = 0; 812352f7f91STakashi Iwai break; 813352f7f91STakashi Iwai } 814352f7f91STakashi Iwai } 815352f7f91STakashi Iwai } 816352f7f91STakashi Iwai dac = dacs[i]; 817352f7f91STakashi Iwai if (!dac) { 818352f7f91STakashi Iwai if (is_reachable_path(codec, dacs[0], pin)) 819352f7f91STakashi Iwai dac = dacs[0]; 820352f7f91STakashi Iwai else if (cfg->line_outs > i && 821352f7f91STakashi Iwai is_reachable_path(codec, spec->private_dac_nids[i], pin)) 822352f7f91STakashi Iwai dac = spec->private_dac_nids[i]; 823352f7f91STakashi Iwai if (dac) { 824352f7f91STakashi Iwai if (!i) 825352f7f91STakashi Iwai badness += bad->shared_primary; 826352f7f91STakashi Iwai else if (i == 1) 827352f7f91STakashi Iwai badness += bad->shared_surr; 828352f7f91STakashi Iwai else 829352f7f91STakashi Iwai badness += bad->shared_clfe; 830352f7f91STakashi Iwai } else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) { 831352f7f91STakashi Iwai dac = spec->private_dac_nids[0]; 832352f7f91STakashi Iwai badness += bad->shared_surr_main; 833352f7f91STakashi Iwai } else if (!i) 834352f7f91STakashi Iwai badness += bad->no_primary_dac; 835352f7f91STakashi Iwai else 836352f7f91STakashi Iwai badness += bad->no_dac; 837352f7f91STakashi Iwai } 838352f7f91STakashi Iwai if (!snd_hda_add_new_path(codec, dac, pin, 0)) 839352f7f91STakashi Iwai dac = dacs[i] = 0; 840352f7f91STakashi Iwai if (dac) 841352f7f91STakashi Iwai badness += assign_out_path_ctls(codec, pin, dac); 842352f7f91STakashi Iwai } 843352f7f91STakashi Iwai 844352f7f91STakashi Iwai return badness; 845352f7f91STakashi Iwai } 846352f7f91STakashi Iwai 847352f7f91STakashi Iwai /* return NID if the given pin has only a single connection to a certain DAC */ 848352f7f91STakashi Iwai static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin) 849352f7f91STakashi Iwai { 850352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 851352f7f91STakashi Iwai int i; 852352f7f91STakashi Iwai hda_nid_t nid_found = 0; 853352f7f91STakashi Iwai 854352f7f91STakashi Iwai for (i = 0; i < spec->num_all_dacs; i++) { 855352f7f91STakashi Iwai hda_nid_t nid = spec->all_dacs[i]; 856352f7f91STakashi Iwai if (!nid || is_dac_already_used(codec, nid)) 857352f7f91STakashi Iwai continue; 858352f7f91STakashi Iwai if (is_reachable_path(codec, nid, pin)) { 859352f7f91STakashi Iwai if (nid_found) 860352f7f91STakashi Iwai return 0; 861352f7f91STakashi Iwai nid_found = nid; 862352f7f91STakashi Iwai } 863352f7f91STakashi Iwai } 864352f7f91STakashi Iwai return nid_found; 865352f7f91STakashi Iwai } 866352f7f91STakashi Iwai 867352f7f91STakashi Iwai /* check whether the given pin can be a multi-io pin */ 868352f7f91STakashi Iwai static bool can_be_multiio_pin(struct hda_codec *codec, 869352f7f91STakashi Iwai unsigned int location, hda_nid_t nid) 870352f7f91STakashi Iwai { 871352f7f91STakashi Iwai unsigned int defcfg, caps; 872352f7f91STakashi Iwai 873352f7f91STakashi Iwai defcfg = snd_hda_codec_get_pincfg(codec, nid); 874352f7f91STakashi Iwai if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX) 875352f7f91STakashi Iwai return false; 876352f7f91STakashi Iwai if (location && get_defcfg_location(defcfg) != location) 877352f7f91STakashi Iwai return false; 878352f7f91STakashi Iwai caps = snd_hda_query_pin_caps(codec, nid); 879352f7f91STakashi Iwai if (!(caps & AC_PINCAP_OUT)) 880352f7f91STakashi Iwai return false; 881352f7f91STakashi Iwai return true; 882352f7f91STakashi Iwai } 883352f7f91STakashi Iwai 884352f7f91STakashi Iwai /* 885352f7f91STakashi Iwai * multi-io helper 886352f7f91STakashi Iwai * 887352f7f91STakashi Iwai * When hardwired is set, try to fill ony hardwired pins, and returns 888352f7f91STakashi Iwai * zero if any pins are filled, non-zero if nothing found. 889352f7f91STakashi Iwai * When hardwired is off, try to fill possible input pins, and returns 890352f7f91STakashi Iwai * the badness value. 891352f7f91STakashi Iwai */ 892352f7f91STakashi Iwai static int fill_multi_ios(struct hda_codec *codec, 893352f7f91STakashi Iwai hda_nid_t reference_pin, 894352f7f91STakashi Iwai bool hardwired, int offset) 895352f7f91STakashi Iwai { 896352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 897352f7f91STakashi Iwai struct auto_pin_cfg *cfg = &spec->autocfg; 898352f7f91STakashi Iwai int type, i, j, dacs, num_pins, old_pins; 899352f7f91STakashi Iwai unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin); 900352f7f91STakashi Iwai unsigned int location = get_defcfg_location(defcfg); 901352f7f91STakashi Iwai int badness = 0; 902352f7f91STakashi Iwai 903352f7f91STakashi Iwai old_pins = spec->multi_ios; 904352f7f91STakashi Iwai if (old_pins >= 2) 905352f7f91STakashi Iwai goto end_fill; 906352f7f91STakashi Iwai 907352f7f91STakashi Iwai num_pins = 0; 908352f7f91STakashi Iwai for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) { 909352f7f91STakashi Iwai for (i = 0; i < cfg->num_inputs; i++) { 910352f7f91STakashi Iwai if (cfg->inputs[i].type != type) 911352f7f91STakashi Iwai continue; 912352f7f91STakashi Iwai if (can_be_multiio_pin(codec, location, 913352f7f91STakashi Iwai cfg->inputs[i].pin)) 914352f7f91STakashi Iwai num_pins++; 915352f7f91STakashi Iwai } 916352f7f91STakashi Iwai } 917352f7f91STakashi Iwai if (num_pins < 2) 918352f7f91STakashi Iwai goto end_fill; 919352f7f91STakashi Iwai 920352f7f91STakashi Iwai dacs = spec->multiout.num_dacs; 921352f7f91STakashi Iwai for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) { 922352f7f91STakashi Iwai for (i = 0; i < cfg->num_inputs; i++) { 923352f7f91STakashi Iwai hda_nid_t nid = cfg->inputs[i].pin; 924352f7f91STakashi Iwai hda_nid_t dac = 0; 925352f7f91STakashi Iwai 926352f7f91STakashi Iwai if (cfg->inputs[i].type != type) 927352f7f91STakashi Iwai continue; 928352f7f91STakashi Iwai if (!can_be_multiio_pin(codec, location, nid)) 929352f7f91STakashi Iwai continue; 930352f7f91STakashi Iwai for (j = 0; j < spec->multi_ios; j++) { 931352f7f91STakashi Iwai if (nid == spec->multi_io[j].pin) 932352f7f91STakashi Iwai break; 933352f7f91STakashi Iwai } 934352f7f91STakashi Iwai if (j < spec->multi_ios) 935352f7f91STakashi Iwai continue; 936352f7f91STakashi Iwai 937352f7f91STakashi Iwai if (offset && offset + spec->multi_ios < dacs) { 938352f7f91STakashi Iwai dac = spec->private_dac_nids[offset + spec->multi_ios]; 939352f7f91STakashi Iwai if (!is_reachable_path(codec, dac, nid)) 940352f7f91STakashi Iwai dac = 0; 941352f7f91STakashi Iwai } 942352f7f91STakashi Iwai if (hardwired) 943352f7f91STakashi Iwai dac = get_dac_if_single(codec, nid); 944352f7f91STakashi Iwai else if (!dac) 945352f7f91STakashi Iwai dac = look_for_dac(codec, nid, false); 946352f7f91STakashi Iwai if (!dac) { 947352f7f91STakashi Iwai badness++; 948352f7f91STakashi Iwai continue; 949352f7f91STakashi Iwai } 950352f7f91STakashi Iwai if (!snd_hda_add_new_path(codec, dac, nid, 0)) { 951352f7f91STakashi Iwai badness++; 952352f7f91STakashi Iwai continue; 953352f7f91STakashi Iwai } 954352f7f91STakashi Iwai spec->multi_io[spec->multi_ios].pin = nid; 955352f7f91STakashi Iwai spec->multi_io[spec->multi_ios].dac = dac; 956352f7f91STakashi Iwai spec->multi_ios++; 957352f7f91STakashi Iwai if (spec->multi_ios >= 2) 958352f7f91STakashi Iwai break; 959352f7f91STakashi Iwai } 960352f7f91STakashi Iwai } 961352f7f91STakashi Iwai end_fill: 962352f7f91STakashi Iwai if (badness) 963352f7f91STakashi Iwai badness = BAD_MULTI_IO; 964352f7f91STakashi Iwai if (old_pins == spec->multi_ios) { 965352f7f91STakashi Iwai if (hardwired) 966352f7f91STakashi Iwai return 1; /* nothing found */ 967352f7f91STakashi Iwai else 968352f7f91STakashi Iwai return badness; /* no badness if nothing found */ 969352f7f91STakashi Iwai } 970352f7f91STakashi Iwai if (!hardwired && spec->multi_ios < 2) { 971352f7f91STakashi Iwai /* cancel newly assigned paths */ 972352f7f91STakashi Iwai spec->paths.used -= spec->multi_ios - old_pins; 973352f7f91STakashi Iwai spec->multi_ios = old_pins; 974352f7f91STakashi Iwai return badness; 975352f7f91STakashi Iwai } 976352f7f91STakashi Iwai 977352f7f91STakashi Iwai /* assign volume and mute controls */ 978352f7f91STakashi Iwai for (i = old_pins; i < spec->multi_ios; i++) 979352f7f91STakashi Iwai badness += assign_out_path_ctls(codec, spec->multi_io[i].pin, 980352f7f91STakashi Iwai spec->multi_io[i].dac); 981352f7f91STakashi Iwai 982352f7f91STakashi Iwai return badness; 983352f7f91STakashi Iwai } 984352f7f91STakashi Iwai 985352f7f91STakashi Iwai /* map DACs for all pins in the list if they are single connections */ 986352f7f91STakashi Iwai static bool map_singles(struct hda_codec *codec, int outs, 987352f7f91STakashi Iwai const hda_nid_t *pins, hda_nid_t *dacs) 988352f7f91STakashi Iwai { 989352f7f91STakashi Iwai int i; 990352f7f91STakashi Iwai bool found = false; 991352f7f91STakashi Iwai for (i = 0; i < outs; i++) { 992352f7f91STakashi Iwai hda_nid_t dac; 993352f7f91STakashi Iwai if (dacs[i]) 994352f7f91STakashi Iwai continue; 995352f7f91STakashi Iwai dac = get_dac_if_single(codec, pins[i]); 996352f7f91STakashi Iwai if (!dac) 997352f7f91STakashi Iwai continue; 998352f7f91STakashi Iwai if (snd_hda_add_new_path(codec, dac, pins[i], 0)) { 999352f7f91STakashi Iwai dacs[i] = dac; 1000352f7f91STakashi Iwai found = true; 1001352f7f91STakashi Iwai } 1002352f7f91STakashi Iwai } 1003352f7f91STakashi Iwai return found; 1004352f7f91STakashi Iwai } 1005352f7f91STakashi Iwai 1006352f7f91STakashi Iwai /* fill in the dac_nids table from the parsed pin configuration */ 1007352f7f91STakashi Iwai static int fill_and_eval_dacs(struct hda_codec *codec, 1008352f7f91STakashi Iwai bool fill_hardwired, 1009352f7f91STakashi Iwai bool fill_mio_first) 1010352f7f91STakashi Iwai { 1011352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1012352f7f91STakashi Iwai struct auto_pin_cfg *cfg = &spec->autocfg; 1013352f7f91STakashi Iwai int i, err, badness; 1014352f7f91STakashi Iwai 1015352f7f91STakashi Iwai /* set num_dacs once to full for look_for_dac() */ 1016352f7f91STakashi Iwai spec->multiout.num_dacs = cfg->line_outs; 1017352f7f91STakashi Iwai spec->multiout.dac_nids = spec->private_dac_nids; 1018352f7f91STakashi Iwai memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids)); 1019352f7f91STakashi Iwai memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid)); 1020352f7f91STakashi Iwai memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid)); 1021352f7f91STakashi Iwai spec->multi_ios = 0; 1022352f7f91STakashi Iwai snd_array_free(&spec->paths); 1023352f7f91STakashi Iwai badness = 0; 1024352f7f91STakashi Iwai 1025352f7f91STakashi Iwai /* fill hard-wired DACs first */ 1026352f7f91STakashi Iwai if (fill_hardwired) { 1027352f7f91STakashi Iwai bool mapped; 1028352f7f91STakashi Iwai do { 1029352f7f91STakashi Iwai mapped = map_singles(codec, cfg->line_outs, 1030352f7f91STakashi Iwai cfg->line_out_pins, 1031352f7f91STakashi Iwai spec->private_dac_nids); 1032352f7f91STakashi Iwai mapped |= map_singles(codec, cfg->hp_outs, 1033352f7f91STakashi Iwai cfg->hp_pins, 1034352f7f91STakashi Iwai spec->multiout.hp_out_nid); 1035352f7f91STakashi Iwai mapped |= map_singles(codec, cfg->speaker_outs, 1036352f7f91STakashi Iwai cfg->speaker_pins, 1037352f7f91STakashi Iwai spec->multiout.extra_out_nid); 1038352f7f91STakashi Iwai if (fill_mio_first && cfg->line_outs == 1 && 1039352f7f91STakashi Iwai cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 1040352f7f91STakashi Iwai err = fill_multi_ios(codec, cfg->line_out_pins[0], true, 0); 1041352f7f91STakashi Iwai if (!err) 1042352f7f91STakashi Iwai mapped = true; 1043352f7f91STakashi Iwai } 1044352f7f91STakashi Iwai } while (mapped); 1045352f7f91STakashi Iwai } 1046352f7f91STakashi Iwai 1047352f7f91STakashi Iwai badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins, 1048352f7f91STakashi Iwai spec->private_dac_nids, 1049352f7f91STakashi Iwai &main_out_badness); 1050352f7f91STakashi Iwai 1051352f7f91STakashi Iwai /* re-count num_dacs and squash invalid entries */ 1052352f7f91STakashi Iwai spec->multiout.num_dacs = 0; 1053352f7f91STakashi Iwai for (i = 0; i < cfg->line_outs; i++) { 1054352f7f91STakashi Iwai if (spec->private_dac_nids[i]) 1055352f7f91STakashi Iwai spec->multiout.num_dacs++; 1056352f7f91STakashi Iwai else { 1057352f7f91STakashi Iwai memmove(spec->private_dac_nids + i, 1058352f7f91STakashi Iwai spec->private_dac_nids + i + 1, 1059352f7f91STakashi Iwai sizeof(hda_nid_t) * (cfg->line_outs - i - 1)); 1060352f7f91STakashi Iwai spec->private_dac_nids[cfg->line_outs - 1] = 0; 1061352f7f91STakashi Iwai } 1062352f7f91STakashi Iwai } 1063352f7f91STakashi Iwai 1064352f7f91STakashi Iwai if (fill_mio_first && 1065352f7f91STakashi Iwai cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 1066352f7f91STakashi Iwai /* try to fill multi-io first */ 1067352f7f91STakashi Iwai err = fill_multi_ios(codec, cfg->line_out_pins[0], false, 0); 1068352f7f91STakashi Iwai if (err < 0) 1069352f7f91STakashi Iwai return err; 1070352f7f91STakashi Iwai /* we don't count badness at this stage yet */ 1071352f7f91STakashi Iwai } 1072352f7f91STakashi Iwai 1073352f7f91STakashi Iwai if (cfg->line_out_type != AUTO_PIN_HP_OUT) { 1074352f7f91STakashi Iwai err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins, 1075352f7f91STakashi Iwai spec->multiout.hp_out_nid, 1076352f7f91STakashi Iwai &extra_out_badness); 1077352f7f91STakashi Iwai if (err < 0) 1078352f7f91STakashi Iwai return err; 1079352f7f91STakashi Iwai badness += err; 1080352f7f91STakashi Iwai } 1081352f7f91STakashi Iwai if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 1082352f7f91STakashi Iwai err = try_assign_dacs(codec, cfg->speaker_outs, 1083352f7f91STakashi Iwai cfg->speaker_pins, 1084352f7f91STakashi Iwai spec->multiout.extra_out_nid, 1085352f7f91STakashi Iwai &extra_out_badness); 1086352f7f91STakashi Iwai if (err < 0) 1087352f7f91STakashi Iwai return err; 1088352f7f91STakashi Iwai badness += err; 1089352f7f91STakashi Iwai } 1090352f7f91STakashi Iwai if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 1091352f7f91STakashi Iwai err = fill_multi_ios(codec, cfg->line_out_pins[0], false, 0); 1092352f7f91STakashi Iwai if (err < 0) 1093352f7f91STakashi Iwai return err; 1094352f7f91STakashi Iwai badness += err; 1095352f7f91STakashi Iwai } 1096352f7f91STakashi Iwai if (cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) { 1097352f7f91STakashi Iwai /* try multi-ios with HP + inputs */ 1098352f7f91STakashi Iwai int offset = 0; 1099352f7f91STakashi Iwai if (cfg->line_outs >= 3) 1100352f7f91STakashi Iwai offset = 1; 1101352f7f91STakashi Iwai err = fill_multi_ios(codec, cfg->hp_pins[0], false, offset); 1102352f7f91STakashi Iwai if (err < 0) 1103352f7f91STakashi Iwai return err; 1104352f7f91STakashi Iwai badness += err; 1105352f7f91STakashi Iwai } 1106352f7f91STakashi Iwai 1107352f7f91STakashi Iwai if (spec->multi_ios == 2) { 1108352f7f91STakashi Iwai for (i = 0; i < 2; i++) 1109352f7f91STakashi Iwai spec->private_dac_nids[spec->multiout.num_dacs++] = 1110352f7f91STakashi Iwai spec->multi_io[i].dac; 1111352f7f91STakashi Iwai spec->ext_channel_count = 2; 1112352f7f91STakashi Iwai } else if (spec->multi_ios) { 1113352f7f91STakashi Iwai spec->multi_ios = 0; 1114352f7f91STakashi Iwai badness += BAD_MULTI_IO; 1115352f7f91STakashi Iwai } 1116352f7f91STakashi Iwai 1117352f7f91STakashi Iwai return badness; 1118352f7f91STakashi Iwai } 1119352f7f91STakashi Iwai 1120352f7f91STakashi Iwai #define DEBUG_BADNESS 1121352f7f91STakashi Iwai 1122352f7f91STakashi Iwai #ifdef DEBUG_BADNESS 1123352f7f91STakashi Iwai #define debug_badness snd_printdd 1124352f7f91STakashi Iwai #else 1125352f7f91STakashi Iwai #define debug_badness(...) 1126352f7f91STakashi Iwai #endif 1127352f7f91STakashi Iwai 1128352f7f91STakashi Iwai static void debug_show_configs(struct hda_gen_spec *spec, struct auto_pin_cfg *cfg) 1129352f7f91STakashi Iwai { 1130352f7f91STakashi Iwai debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x\n", 1131352f7f91STakashi Iwai cfg->line_out_pins[0], cfg->line_out_pins[1], 1132352f7f91STakashi Iwai cfg->line_out_pins[2], cfg->line_out_pins[2], 1133352f7f91STakashi Iwai spec->multiout.dac_nids[0], 1134352f7f91STakashi Iwai spec->multiout.dac_nids[1], 1135352f7f91STakashi Iwai spec->multiout.dac_nids[2], 1136352f7f91STakashi Iwai spec->multiout.dac_nids[3]); 1137352f7f91STakashi Iwai if (spec->multi_ios > 0) 1138352f7f91STakashi Iwai debug_badness("multi_ios(%d) = %x/%x : %x/%x\n", 1139352f7f91STakashi Iwai spec->multi_ios, 1140352f7f91STakashi Iwai spec->multi_io[0].pin, spec->multi_io[1].pin, 1141352f7f91STakashi Iwai spec->multi_io[0].dac, spec->multi_io[1].dac); 1142352f7f91STakashi Iwai debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n", 1143352f7f91STakashi Iwai cfg->hp_pins[0], cfg->hp_pins[1], 1144352f7f91STakashi Iwai cfg->hp_pins[2], cfg->hp_pins[2], 1145352f7f91STakashi Iwai spec->multiout.hp_out_nid[0], 1146352f7f91STakashi Iwai spec->multiout.hp_out_nid[1], 1147352f7f91STakashi Iwai spec->multiout.hp_out_nid[2], 1148352f7f91STakashi Iwai spec->multiout.hp_out_nid[3]); 1149352f7f91STakashi Iwai debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n", 1150352f7f91STakashi Iwai cfg->speaker_pins[0], cfg->speaker_pins[1], 1151352f7f91STakashi Iwai cfg->speaker_pins[2], cfg->speaker_pins[3], 1152352f7f91STakashi Iwai spec->multiout.extra_out_nid[0], 1153352f7f91STakashi Iwai spec->multiout.extra_out_nid[1], 1154352f7f91STakashi Iwai spec->multiout.extra_out_nid[2], 1155352f7f91STakashi Iwai spec->multiout.extra_out_nid[3]); 1156352f7f91STakashi Iwai } 1157352f7f91STakashi Iwai 1158352f7f91STakashi Iwai /* find all available DACs of the codec */ 1159352f7f91STakashi Iwai static void fill_all_dac_nids(struct hda_codec *codec) 1160352f7f91STakashi Iwai { 1161352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1162352f7f91STakashi Iwai int i; 1163352f7f91STakashi Iwai hda_nid_t nid = codec->start_nid; 1164352f7f91STakashi Iwai 1165352f7f91STakashi Iwai spec->num_all_dacs = 0; 1166352f7f91STakashi Iwai memset(spec->all_dacs, 0, sizeof(spec->all_dacs)); 1167352f7f91STakashi Iwai for (i = 0; i < codec->num_nodes; i++, nid++) { 1168352f7f91STakashi Iwai if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT) 1169352f7f91STakashi Iwai continue; 1170352f7f91STakashi Iwai if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) { 1171352f7f91STakashi Iwai snd_printk(KERN_ERR "hda: Too many DACs!\n"); 1172352f7f91STakashi Iwai break; 1173352f7f91STakashi Iwai } 1174352f7f91STakashi Iwai spec->all_dacs[spec->num_all_dacs++] = nid; 1175352f7f91STakashi Iwai } 1176352f7f91STakashi Iwai } 1177352f7f91STakashi Iwai 1178352f7f91STakashi Iwai static int parse_output_paths(struct hda_codec *codec) 1179352f7f91STakashi Iwai { 1180352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1181352f7f91STakashi Iwai struct auto_pin_cfg *cfg = &spec->autocfg; 1182352f7f91STakashi Iwai struct auto_pin_cfg *best_cfg; 1183352f7f91STakashi Iwai int best_badness = INT_MAX; 1184352f7f91STakashi Iwai int badness; 1185352f7f91STakashi Iwai bool fill_hardwired = true, fill_mio_first = true; 1186352f7f91STakashi Iwai bool best_wired = true, best_mio = true; 1187352f7f91STakashi Iwai bool hp_spk_swapped = false; 1188352f7f91STakashi Iwai 1189352f7f91STakashi Iwai fill_all_dac_nids(codec); 1190352f7f91STakashi Iwai 1191352f7f91STakashi Iwai best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL); 1192352f7f91STakashi Iwai if (!best_cfg) 1193352f7f91STakashi Iwai return -ENOMEM; 1194352f7f91STakashi Iwai *best_cfg = *cfg; 1195352f7f91STakashi Iwai 1196352f7f91STakashi Iwai for (;;) { 1197352f7f91STakashi Iwai badness = fill_and_eval_dacs(codec, fill_hardwired, 1198352f7f91STakashi Iwai fill_mio_first); 1199352f7f91STakashi Iwai if (badness < 0) { 1200352f7f91STakashi Iwai kfree(best_cfg); 1201352f7f91STakashi Iwai return badness; 1202352f7f91STakashi Iwai } 1203352f7f91STakashi Iwai debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n", 1204352f7f91STakashi Iwai cfg->line_out_type, fill_hardwired, fill_mio_first, 1205352f7f91STakashi Iwai badness); 1206352f7f91STakashi Iwai debug_show_configs(spec, cfg); 1207352f7f91STakashi Iwai if (badness < best_badness) { 1208352f7f91STakashi Iwai best_badness = badness; 1209352f7f91STakashi Iwai *best_cfg = *cfg; 1210352f7f91STakashi Iwai best_wired = fill_hardwired; 1211352f7f91STakashi Iwai best_mio = fill_mio_first; 1212352f7f91STakashi Iwai } 1213352f7f91STakashi Iwai if (!badness) 1214352f7f91STakashi Iwai break; 1215352f7f91STakashi Iwai fill_mio_first = !fill_mio_first; 1216352f7f91STakashi Iwai if (!fill_mio_first) 1217352f7f91STakashi Iwai continue; 1218352f7f91STakashi Iwai fill_hardwired = !fill_hardwired; 1219352f7f91STakashi Iwai if (!fill_hardwired) 1220352f7f91STakashi Iwai continue; 1221352f7f91STakashi Iwai if (hp_spk_swapped) 1222352f7f91STakashi Iwai break; 1223352f7f91STakashi Iwai hp_spk_swapped = true; 1224352f7f91STakashi Iwai if (cfg->speaker_outs > 0 && 1225352f7f91STakashi Iwai cfg->line_out_type == AUTO_PIN_HP_OUT) { 1226352f7f91STakashi Iwai cfg->hp_outs = cfg->line_outs; 1227352f7f91STakashi Iwai memcpy(cfg->hp_pins, cfg->line_out_pins, 1228352f7f91STakashi Iwai sizeof(cfg->hp_pins)); 1229352f7f91STakashi Iwai cfg->line_outs = cfg->speaker_outs; 1230352f7f91STakashi Iwai memcpy(cfg->line_out_pins, cfg->speaker_pins, 1231352f7f91STakashi Iwai sizeof(cfg->speaker_pins)); 1232352f7f91STakashi Iwai cfg->speaker_outs = 0; 1233352f7f91STakashi Iwai memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins)); 1234352f7f91STakashi Iwai cfg->line_out_type = AUTO_PIN_SPEAKER_OUT; 1235352f7f91STakashi Iwai fill_hardwired = true; 1236352f7f91STakashi Iwai continue; 1237352f7f91STakashi Iwai } 1238352f7f91STakashi Iwai if (cfg->hp_outs > 0 && 1239352f7f91STakashi Iwai cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) { 1240352f7f91STakashi Iwai cfg->speaker_outs = cfg->line_outs; 1241352f7f91STakashi Iwai memcpy(cfg->speaker_pins, cfg->line_out_pins, 1242352f7f91STakashi Iwai sizeof(cfg->speaker_pins)); 1243352f7f91STakashi Iwai cfg->line_outs = cfg->hp_outs; 1244352f7f91STakashi Iwai memcpy(cfg->line_out_pins, cfg->hp_pins, 1245352f7f91STakashi Iwai sizeof(cfg->hp_pins)); 1246352f7f91STakashi Iwai cfg->hp_outs = 0; 1247352f7f91STakashi Iwai memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins)); 1248352f7f91STakashi Iwai cfg->line_out_type = AUTO_PIN_HP_OUT; 1249352f7f91STakashi Iwai fill_hardwired = true; 1250352f7f91STakashi Iwai continue; 1251352f7f91STakashi Iwai } 1252352f7f91STakashi Iwai break; 1253352f7f91STakashi Iwai } 1254352f7f91STakashi Iwai 1255352f7f91STakashi Iwai if (badness) { 1256352f7f91STakashi Iwai *cfg = *best_cfg; 1257352f7f91STakashi Iwai fill_and_eval_dacs(codec, best_wired, best_mio); 1258352f7f91STakashi Iwai } 1259352f7f91STakashi Iwai debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n", 1260352f7f91STakashi Iwai cfg->line_out_type, best_wired, best_mio); 1261352f7f91STakashi Iwai debug_show_configs(spec, cfg); 1262352f7f91STakashi Iwai 1263352f7f91STakashi Iwai if (cfg->line_out_pins[0]) { 1264352f7f91STakashi Iwai struct nid_path *path; 1265352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, 1266352f7f91STakashi Iwai spec->multiout.dac_nids[0], 1267352f7f91STakashi Iwai cfg->line_out_pins[0]); 1268352f7f91STakashi Iwai if (path) 1269352f7f91STakashi Iwai spec->vmaster_nid = look_for_out_vol_nid(codec, path); 1270352f7f91STakashi Iwai } 1271352f7f91STakashi Iwai 1272352f7f91STakashi Iwai kfree(best_cfg); 1273352f7f91STakashi Iwai return 0; 1274352f7f91STakashi Iwai } 1275352f7f91STakashi Iwai 1276352f7f91STakashi Iwai /* add playback controls from the parsed DAC table */ 1277352f7f91STakashi Iwai static int create_multi_out_ctls(struct hda_codec *codec, 1278352f7f91STakashi Iwai const struct auto_pin_cfg *cfg) 1279352f7f91STakashi Iwai { 1280352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1281352f7f91STakashi Iwai int i, err, noutputs; 1282352f7f91STakashi Iwai 1283352f7f91STakashi Iwai noutputs = cfg->line_outs; 1284352f7f91STakashi Iwai if (spec->multi_ios > 0 && cfg->line_outs < 3) 1285352f7f91STakashi Iwai noutputs += spec->multi_ios; 1286352f7f91STakashi Iwai 1287352f7f91STakashi Iwai for (i = 0; i < noutputs; i++) { 1288352f7f91STakashi Iwai const char *name; 1289352f7f91STakashi Iwai int index; 1290352f7f91STakashi Iwai hda_nid_t dac, pin; 1291352f7f91STakashi Iwai struct nid_path *path; 1292352f7f91STakashi Iwai 1293352f7f91STakashi Iwai dac = spec->multiout.dac_nids[i]; 1294352f7f91STakashi Iwai if (!dac) 1295352f7f91STakashi Iwai continue; 1296352f7f91STakashi Iwai if (i >= cfg->line_outs) { 1297352f7f91STakashi Iwai pin = spec->multi_io[i - 1].pin; 1298352f7f91STakashi Iwai index = 0; 1299352f7f91STakashi Iwai name = channel_name[i]; 1300352f7f91STakashi Iwai } else { 1301352f7f91STakashi Iwai pin = cfg->line_out_pins[i]; 1302352f7f91STakashi Iwai name = get_line_out_pfx(spec, i, true, &index); 1303352f7f91STakashi Iwai } 1304352f7f91STakashi Iwai 1305352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, dac, pin); 1306352f7f91STakashi Iwai if (!path) 1307352f7f91STakashi Iwai continue; 1308352f7f91STakashi Iwai if (!name || !strcmp(name, "CLFE")) { 1309352f7f91STakashi Iwai /* Center/LFE */ 1310352f7f91STakashi Iwai err = add_vol_ctl(codec, "Center", 0, 1, path); 1311352f7f91STakashi Iwai if (err < 0) 1312352f7f91STakashi Iwai return err; 1313352f7f91STakashi Iwai err = add_vol_ctl(codec, "LFE", 0, 2, path); 1314352f7f91STakashi Iwai if (err < 0) 1315352f7f91STakashi Iwai return err; 1316352f7f91STakashi Iwai err = add_sw_ctl(codec, "Center", 0, 1, path); 1317352f7f91STakashi Iwai if (err < 0) 1318352f7f91STakashi Iwai return err; 1319352f7f91STakashi Iwai err = add_sw_ctl(codec, "LFE", 0, 2, path); 1320352f7f91STakashi Iwai if (err < 0) 1321352f7f91STakashi Iwai return err; 1322352f7f91STakashi Iwai } else { 1323352f7f91STakashi Iwai err = add_stereo_vol(codec, name, index, path); 1324352f7f91STakashi Iwai if (err < 0) 1325352f7f91STakashi Iwai return err; 1326352f7f91STakashi Iwai err = add_stereo_sw(codec, name, index, path); 1327352f7f91STakashi Iwai if (err < 0) 1328352f7f91STakashi Iwai return err; 1329352f7f91STakashi Iwai } 1330352f7f91STakashi Iwai } 1331352f7f91STakashi Iwai return 0; 1332352f7f91STakashi Iwai } 1333352f7f91STakashi Iwai 1334352f7f91STakashi Iwai static int create_extra_out(struct hda_codec *codec, hda_nid_t pin, 1335352f7f91STakashi Iwai hda_nid_t dac, const char *pfx, int cidx) 1336352f7f91STakashi Iwai { 1337352f7f91STakashi Iwai struct nid_path *path; 1338352f7f91STakashi Iwai int err; 1339352f7f91STakashi Iwai 1340352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, dac, pin); 1341352f7f91STakashi Iwai if (!path) 1342352f7f91STakashi Iwai return 0; 1343352f7f91STakashi Iwai /* bind volume control will be created in the case of dac = 0 */ 1344352f7f91STakashi Iwai if (dac) { 1345352f7f91STakashi Iwai err = add_stereo_vol(codec, pfx, cidx, path); 1346352f7f91STakashi Iwai if (err < 0) 1347352f7f91STakashi Iwai return err; 1348352f7f91STakashi Iwai } 1349352f7f91STakashi Iwai err = add_stereo_sw(codec, pfx, cidx, path); 1350352f7f91STakashi Iwai if (err < 0) 1351352f7f91STakashi Iwai return err; 1352352f7f91STakashi Iwai return 0; 1353352f7f91STakashi Iwai } 1354352f7f91STakashi Iwai 1355352f7f91STakashi Iwai /* add playback controls for speaker and HP outputs */ 1356352f7f91STakashi Iwai static int create_extra_outs(struct hda_codec *codec, int num_pins, 1357352f7f91STakashi Iwai const hda_nid_t *pins, const hda_nid_t *dacs, 1358352f7f91STakashi Iwai const char *pfx) 1359352f7f91STakashi Iwai { 1360352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1361352f7f91STakashi Iwai struct hda_bind_ctls *ctl; 1362352f7f91STakashi Iwai char name[32]; 1363352f7f91STakashi Iwai int i, n, err; 1364352f7f91STakashi Iwai 1365352f7f91STakashi Iwai if (!num_pins || !pins[0]) 1366352f7f91STakashi Iwai return 0; 1367352f7f91STakashi Iwai 1368352f7f91STakashi Iwai if (num_pins == 1) { 1369352f7f91STakashi Iwai hda_nid_t dac = *dacs; 1370352f7f91STakashi Iwai if (!dac) 1371352f7f91STakashi Iwai dac = spec->multiout.dac_nids[0]; 1372352f7f91STakashi Iwai return create_extra_out(codec, *pins, dac, pfx, 0); 1373352f7f91STakashi Iwai } 1374352f7f91STakashi Iwai 1375352f7f91STakashi Iwai for (i = 0; i < num_pins; i++) { 1376352f7f91STakashi Iwai hda_nid_t dac; 1377352f7f91STakashi Iwai if (dacs[num_pins - 1]) 1378352f7f91STakashi Iwai dac = dacs[i]; /* with individual volumes */ 1379352f7f91STakashi Iwai else 1380352f7f91STakashi Iwai dac = 0; 1381352f7f91STakashi Iwai if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker")) { 1382352f7f91STakashi Iwai err = create_extra_out(codec, pins[i], dac, 1383352f7f91STakashi Iwai "Bass Speaker", 0); 1384352f7f91STakashi Iwai } else if (num_pins >= 3) { 1385352f7f91STakashi Iwai snprintf(name, sizeof(name), "%s %s", 1386352f7f91STakashi Iwai pfx, channel_name[i]); 1387352f7f91STakashi Iwai err = create_extra_out(codec, pins[i], dac, name, 0); 1388352f7f91STakashi Iwai } else { 1389352f7f91STakashi Iwai err = create_extra_out(codec, pins[i], dac, pfx, i); 1390352f7f91STakashi Iwai } 1391352f7f91STakashi Iwai if (err < 0) 1392352f7f91STakashi Iwai return err; 1393352f7f91STakashi Iwai } 1394352f7f91STakashi Iwai if (dacs[num_pins - 1]) 1395352f7f91STakashi Iwai return 0; 1396352f7f91STakashi Iwai 1397352f7f91STakashi Iwai /* Let's create a bind-controls for volumes */ 1398352f7f91STakashi Iwai ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_vol); 1399352f7f91STakashi Iwai if (!ctl) 1400352f7f91STakashi Iwai return -ENOMEM; 1401352f7f91STakashi Iwai n = 0; 1402352f7f91STakashi Iwai for (i = 0; i < num_pins; i++) { 1403352f7f91STakashi Iwai hda_nid_t vol; 1404352f7f91STakashi Iwai struct nid_path *path; 1405352f7f91STakashi Iwai if (!pins[i] || !dacs[i]) 1406352f7f91STakashi Iwai continue; 1407352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, dacs[i], pins[i]); 1408352f7f91STakashi Iwai if (!path) 1409352f7f91STakashi Iwai continue; 1410352f7f91STakashi Iwai vol = look_for_out_vol_nid(codec, path); 1411352f7f91STakashi Iwai if (vol) 1412352f7f91STakashi Iwai ctl->values[n++] = 1413352f7f91STakashi Iwai HDA_COMPOSE_AMP_VAL(vol, 3, 0, HDA_OUTPUT); 1414352f7f91STakashi Iwai } 1415352f7f91STakashi Iwai if (n) { 1416352f7f91STakashi Iwai snprintf(name, sizeof(name), "%s Playback Volume", pfx); 1417352f7f91STakashi Iwai err = add_control(spec, HDA_CTL_BIND_VOL, name, 0, (long)ctl); 1418352f7f91STakashi Iwai if (err < 0) 1419352f7f91STakashi Iwai return err; 1420352f7f91STakashi Iwai } 1421352f7f91STakashi Iwai return 0; 1422352f7f91STakashi Iwai } 1423352f7f91STakashi Iwai 1424352f7f91STakashi Iwai static int create_hp_out_ctls(struct hda_codec *codec) 1425352f7f91STakashi Iwai { 1426352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1427352f7f91STakashi Iwai return create_extra_outs(codec, spec->autocfg.hp_outs, 1428352f7f91STakashi Iwai spec->autocfg.hp_pins, 1429352f7f91STakashi Iwai spec->multiout.hp_out_nid, 1430352f7f91STakashi Iwai "Headphone"); 1431352f7f91STakashi Iwai } 1432352f7f91STakashi Iwai 1433352f7f91STakashi Iwai static int create_speaker_out_ctls(struct hda_codec *codec) 1434352f7f91STakashi Iwai { 1435352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1436352f7f91STakashi Iwai return create_extra_outs(codec, spec->autocfg.speaker_outs, 1437352f7f91STakashi Iwai spec->autocfg.speaker_pins, 1438352f7f91STakashi Iwai spec->multiout.extra_out_nid, 1439352f7f91STakashi Iwai "Speaker"); 1440352f7f91STakashi Iwai } 1441352f7f91STakashi Iwai 1442352f7f91STakashi Iwai /* 1443352f7f91STakashi Iwai * channel mode enum control 1444352f7f91STakashi Iwai */ 1445352f7f91STakashi Iwai 1446352f7f91STakashi Iwai static int ch_mode_info(struct snd_kcontrol *kcontrol, 1447352f7f91STakashi Iwai struct snd_ctl_elem_info *uinfo) 1448352f7f91STakashi Iwai { 1449352f7f91STakashi Iwai struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1450352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1451352f7f91STakashi Iwai 1452352f7f91STakashi Iwai uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1453352f7f91STakashi Iwai uinfo->count = 1; 1454352f7f91STakashi Iwai uinfo->value.enumerated.items = spec->multi_ios + 1; 1455352f7f91STakashi Iwai if (uinfo->value.enumerated.item > spec->multi_ios) 1456352f7f91STakashi Iwai uinfo->value.enumerated.item = spec->multi_ios; 1457352f7f91STakashi Iwai sprintf(uinfo->value.enumerated.name, "%dch", 1458352f7f91STakashi Iwai (uinfo->value.enumerated.item + 1) * 2); 1459352f7f91STakashi Iwai return 0; 1460352f7f91STakashi Iwai } 1461352f7f91STakashi Iwai 1462352f7f91STakashi Iwai static int ch_mode_get(struct snd_kcontrol *kcontrol, 1463352f7f91STakashi Iwai struct snd_ctl_elem_value *ucontrol) 1464352f7f91STakashi Iwai { 1465352f7f91STakashi Iwai struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1466352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1467352f7f91STakashi Iwai ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2; 1468352f7f91STakashi Iwai return 0; 1469352f7f91STakashi Iwai } 1470352f7f91STakashi Iwai 1471352f7f91STakashi Iwai static int set_multi_io(struct hda_codec *codec, int idx, bool output) 1472352f7f91STakashi Iwai { 1473352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1474352f7f91STakashi Iwai hda_nid_t nid = spec->multi_io[idx].pin; 1475352f7f91STakashi Iwai struct nid_path *path; 1476352f7f91STakashi Iwai 1477352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, spec->multi_io[idx].dac, nid); 1478352f7f91STakashi Iwai if (!path) 1479352f7f91STakashi Iwai return -EINVAL; 1480352f7f91STakashi Iwai 1481352f7f91STakashi Iwai if (path->active == output) 1482352f7f91STakashi Iwai return 0; 1483352f7f91STakashi Iwai 1484352f7f91STakashi Iwai if (output) { 1485352f7f91STakashi Iwai snd_hda_set_pin_ctl_cache(codec, nid, PIN_OUT); 1486352f7f91STakashi Iwai snd_hda_activate_path(codec, path, true, true); 1487352f7f91STakashi Iwai } else { 1488352f7f91STakashi Iwai snd_hda_activate_path(codec, path, false, true); 1489352f7f91STakashi Iwai snd_hda_set_pin_ctl_cache(codec, nid, 1490352f7f91STakashi Iwai spec->multi_io[idx].ctl_in); 1491352f7f91STakashi Iwai } 1492352f7f91STakashi Iwai return 0; 1493352f7f91STakashi Iwai } 1494352f7f91STakashi Iwai 1495352f7f91STakashi Iwai static int ch_mode_put(struct snd_kcontrol *kcontrol, 1496352f7f91STakashi Iwai struct snd_ctl_elem_value *ucontrol) 1497352f7f91STakashi Iwai { 1498352f7f91STakashi Iwai struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1499352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1500352f7f91STakashi Iwai int i, ch; 1501352f7f91STakashi Iwai 1502352f7f91STakashi Iwai ch = ucontrol->value.enumerated.item[0]; 1503352f7f91STakashi Iwai if (ch < 0 || ch > spec->multi_ios) 1504352f7f91STakashi Iwai return -EINVAL; 1505352f7f91STakashi Iwai if (ch == (spec->ext_channel_count - 1) / 2) 1506352f7f91STakashi Iwai return 0; 1507352f7f91STakashi Iwai spec->ext_channel_count = (ch + 1) * 2; 1508352f7f91STakashi Iwai for (i = 0; i < spec->multi_ios; i++) 1509352f7f91STakashi Iwai set_multi_io(codec, i, i < ch); 1510352f7f91STakashi Iwai spec->multiout.max_channels = max(spec->ext_channel_count, 1511352f7f91STakashi Iwai spec->const_channel_count); 1512352f7f91STakashi Iwai if (spec->need_dac_fix) 1513352f7f91STakashi Iwai spec->multiout.num_dacs = spec->multiout.max_channels / 2; 1514352f7f91STakashi Iwai return 1; 1515352f7f91STakashi Iwai } 1516352f7f91STakashi Iwai 1517352f7f91STakashi Iwai static const struct snd_kcontrol_new channel_mode_enum = { 1518352f7f91STakashi Iwai .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1519352f7f91STakashi Iwai .name = "Channel Mode", 1520352f7f91STakashi Iwai .info = ch_mode_info, 1521352f7f91STakashi Iwai .get = ch_mode_get, 1522352f7f91STakashi Iwai .put = ch_mode_put, 1523352f7f91STakashi Iwai }; 1524352f7f91STakashi Iwai 1525352f7f91STakashi Iwai static int create_multi_channel_mode(struct hda_codec *codec) 1526352f7f91STakashi Iwai { 1527352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1528352f7f91STakashi Iwai 1529352f7f91STakashi Iwai if (spec->multi_ios > 0) { 1530352f7f91STakashi Iwai if (!add_kctl(spec, NULL, &channel_mode_enum)) 1531352f7f91STakashi Iwai return -ENOMEM; 1532352f7f91STakashi Iwai } 1533352f7f91STakashi Iwai return 0; 1534352f7f91STakashi Iwai } 1535352f7f91STakashi Iwai 1536352f7f91STakashi Iwai /* 1537352f7f91STakashi Iwai * shared headphone/mic handling 1538352f7f91STakashi Iwai */ 1539352f7f91STakashi Iwai 1540352f7f91STakashi Iwai static void call_update_outputs(struct hda_codec *codec); 1541352f7f91STakashi Iwai 1542352f7f91STakashi Iwai /* for shared I/O, change the pin-control accordingly */ 1543352f7f91STakashi Iwai static void update_shared_mic_hp(struct hda_codec *codec, bool set_as_mic) 1544352f7f91STakashi Iwai { 1545352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1546352f7f91STakashi Iwai unsigned int val; 1547352f7f91STakashi Iwai hda_nid_t pin = spec->autocfg.inputs[1].pin; 1548352f7f91STakashi Iwai /* NOTE: this assumes that there are only two inputs, the 1549352f7f91STakashi Iwai * first is the real internal mic and the second is HP/mic jack. 1550352f7f91STakashi Iwai */ 1551352f7f91STakashi Iwai 1552352f7f91STakashi Iwai val = snd_hda_get_default_vref(codec, pin); 1553352f7f91STakashi Iwai 1554352f7f91STakashi Iwai /* This pin does not have vref caps - let's enable vref on pin 0x18 1555352f7f91STakashi Iwai instead, as suggested by Realtek */ 1556352f7f91STakashi Iwai if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) { 1557352f7f91STakashi Iwai const hda_nid_t vref_pin = spec->shared_mic_vref_pin; 1558352f7f91STakashi Iwai unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin); 1559352f7f91STakashi Iwai if (vref_val != AC_PINCTL_VREF_HIZ) 1560352f7f91STakashi Iwai snd_hda_set_pin_ctl(codec, vref_pin, PIN_IN | (set_as_mic ? vref_val : 0)); 1561352f7f91STakashi Iwai } 1562352f7f91STakashi Iwai 1563352f7f91STakashi Iwai val = set_as_mic ? val | PIN_IN : PIN_HP; 1564352f7f91STakashi Iwai snd_hda_set_pin_ctl(codec, pin, val); 1565352f7f91STakashi Iwai 1566352f7f91STakashi Iwai spec->automute_speaker = !set_as_mic; 1567352f7f91STakashi Iwai call_update_outputs(codec); 1568352f7f91STakashi Iwai } 1569352f7f91STakashi Iwai 1570352f7f91STakashi Iwai /* create a shared input with the headphone out */ 1571352f7f91STakashi Iwai static int create_shared_input(struct hda_codec *codec) 1572352f7f91STakashi Iwai { 1573352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1574352f7f91STakashi Iwai struct auto_pin_cfg *cfg = &spec->autocfg; 1575352f7f91STakashi Iwai unsigned int defcfg; 1576352f7f91STakashi Iwai hda_nid_t nid; 1577352f7f91STakashi Iwai 1578352f7f91STakashi Iwai /* only one internal input pin? */ 1579352f7f91STakashi Iwai if (cfg->num_inputs != 1) 1580352f7f91STakashi Iwai return 0; 1581352f7f91STakashi Iwai defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin); 1582352f7f91STakashi Iwai if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT) 1583352f7f91STakashi Iwai return 0; 1584352f7f91STakashi Iwai 1585352f7f91STakashi Iwai if (cfg->hp_outs == 1 && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) 1586352f7f91STakashi Iwai nid = cfg->hp_pins[0]; /* OK, we have a single HP-out */ 1587352f7f91STakashi Iwai else if (cfg->line_outs == 1 && cfg->line_out_type == AUTO_PIN_HP_OUT) 1588352f7f91STakashi Iwai nid = cfg->line_out_pins[0]; /* OK, we have a single line-out */ 1589352f7f91STakashi Iwai else 1590352f7f91STakashi Iwai return 0; /* both not available */ 1591352f7f91STakashi Iwai 1592352f7f91STakashi Iwai if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN)) 1593352f7f91STakashi Iwai return 0; /* no input */ 1594352f7f91STakashi Iwai 1595352f7f91STakashi Iwai cfg->inputs[1].pin = nid; 1596352f7f91STakashi Iwai cfg->inputs[1].type = AUTO_PIN_MIC; 1597352f7f91STakashi Iwai cfg->num_inputs = 2; 1598352f7f91STakashi Iwai spec->shared_mic_hp = 1; 1599352f7f91STakashi Iwai snd_printdd("hda-codec: Enable shared I/O jack on NID 0x%x\n", nid); 1600352f7f91STakashi Iwai return 0; 1601352f7f91STakashi Iwai } 1602352f7f91STakashi Iwai 1603352f7f91STakashi Iwai 1604352f7f91STakashi Iwai /* 1605352f7f91STakashi Iwai * Parse input paths 1606352f7f91STakashi Iwai */ 1607352f7f91STakashi Iwai 1608352f7f91STakashi Iwai #ifdef CONFIG_PM 1609352f7f91STakashi Iwai /* add the powersave loopback-list entry */ 1610352f7f91STakashi Iwai static void add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx) 1611352f7f91STakashi Iwai { 1612352f7f91STakashi Iwai struct hda_amp_list *list; 1613352f7f91STakashi Iwai 1614352f7f91STakashi Iwai if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1) 1615352f7f91STakashi Iwai return; 1616352f7f91STakashi Iwai list = spec->loopback_list + spec->num_loopbacks; 1617352f7f91STakashi Iwai list->nid = mix; 1618352f7f91STakashi Iwai list->dir = HDA_INPUT; 1619352f7f91STakashi Iwai list->idx = idx; 1620352f7f91STakashi Iwai spec->num_loopbacks++; 1621cb53c626STakashi Iwai spec->loopback.amplist = spec->loopback_list; 1622cb53c626STakashi Iwai } 1623cb53c626STakashi Iwai #else 1624352f7f91STakashi Iwai #define add_loopback_list(spec, mix, idx) /* NOP */ 1625cb53c626STakashi Iwai #endif 1626cb53c626STakashi Iwai 1627352f7f91STakashi Iwai /* create input playback/capture controls for the given pin */ 1628352f7f91STakashi Iwai static int new_analog_input(struct hda_codec *codec, hda_nid_t pin, 1629352f7f91STakashi Iwai const char *ctlname, int ctlidx, 1630352f7f91STakashi Iwai hda_nid_t mix_nid) 16311da177e4SLinus Torvalds { 1632352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1633352f7f91STakashi Iwai struct nid_path *path; 1634352f7f91STakashi Iwai unsigned int val; 1635352f7f91STakashi Iwai int err, idx; 16361da177e4SLinus Torvalds 1637352f7f91STakashi Iwai if (!nid_has_volume(codec, mix_nid, HDA_INPUT) && 1638352f7f91STakashi Iwai !nid_has_mute(codec, mix_nid, HDA_INPUT)) 1639352f7f91STakashi Iwai return 0; /* no need for analog loopback */ 1640352f7f91STakashi Iwai 1641352f7f91STakashi Iwai path = snd_hda_add_new_path(codec, pin, mix_nid, 2); 1642352f7f91STakashi Iwai if (!path) 1643352f7f91STakashi Iwai return -EINVAL; 1644352f7f91STakashi Iwai 1645352f7f91STakashi Iwai idx = path->idx[path->depth - 1]; 1646352f7f91STakashi Iwai if (nid_has_volume(codec, mix_nid, HDA_INPUT)) { 1647352f7f91STakashi Iwai val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT); 1648352f7f91STakashi Iwai err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, val); 1649d13bd412STakashi Iwai if (err < 0) 16501da177e4SLinus Torvalds return err; 1651352f7f91STakashi Iwai path->ctls[NID_PATH_VOL_CTL] = val; 16521da177e4SLinus Torvalds } 16531da177e4SLinus Torvalds 1654352f7f91STakashi Iwai if (nid_has_mute(codec, mix_nid, HDA_INPUT)) { 1655352f7f91STakashi Iwai val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT); 1656352f7f91STakashi Iwai err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, val); 1657d13bd412STakashi Iwai if (err < 0) 16581da177e4SLinus Torvalds return err; 1659352f7f91STakashi Iwai path->ctls[NID_PATH_MUTE_CTL] = val; 16601da177e4SLinus Torvalds } 16611da177e4SLinus Torvalds 1662352f7f91STakashi Iwai path->active = true; 1663352f7f91STakashi Iwai add_loopback_list(spec, mix_nid, idx); 1664352f7f91STakashi Iwai return 0; 16651da177e4SLinus Torvalds } 16661da177e4SLinus Torvalds 1667352f7f91STakashi Iwai static int is_input_pin(struct hda_codec *codec, hda_nid_t nid) 16681da177e4SLinus Torvalds { 1669352f7f91STakashi Iwai unsigned int pincap = snd_hda_query_pin_caps(codec, nid); 1670352f7f91STakashi Iwai return (pincap & AC_PINCAP_IN) != 0; 1671352f7f91STakashi Iwai } 1672352f7f91STakashi Iwai 1673352f7f91STakashi Iwai /* Parse the codec tree and retrieve ADCs */ 1674352f7f91STakashi Iwai static int fill_adc_nids(struct hda_codec *codec) 1675352f7f91STakashi Iwai { 1676352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1677352f7f91STakashi Iwai hda_nid_t nid; 1678352f7f91STakashi Iwai hda_nid_t *adc_nids = spec->adc_nids; 1679352f7f91STakashi Iwai int max_nums = ARRAY_SIZE(spec->adc_nids); 1680352f7f91STakashi Iwai int i, nums = 0; 1681352f7f91STakashi Iwai 1682352f7f91STakashi Iwai nid = codec->start_nid; 1683352f7f91STakashi Iwai for (i = 0; i < codec->num_nodes; i++, nid++) { 1684352f7f91STakashi Iwai unsigned int caps = get_wcaps(codec, nid); 1685352f7f91STakashi Iwai int type = get_wcaps_type(caps); 1686352f7f91STakashi Iwai 1687352f7f91STakashi Iwai if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL)) 1688352f7f91STakashi Iwai continue; 1689352f7f91STakashi Iwai adc_nids[nums] = nid; 1690352f7f91STakashi Iwai if (++nums >= max_nums) 1691352f7f91STakashi Iwai break; 1692352f7f91STakashi Iwai } 1693352f7f91STakashi Iwai spec->num_adc_nids = nums; 1694352f7f91STakashi Iwai return nums; 1695352f7f91STakashi Iwai } 1696352f7f91STakashi Iwai 1697352f7f91STakashi Iwai /* filter out invalid adc_nids that don't give all active input pins; 1698352f7f91STakashi Iwai * if needed, check whether dynamic ADC-switching is available 1699352f7f91STakashi Iwai */ 1700352f7f91STakashi Iwai static int check_dyn_adc_switch(struct hda_codec *codec) 1701352f7f91STakashi Iwai { 1702352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1703352f7f91STakashi Iwai struct hda_input_mux *imux = &spec->input_mux; 1704352f7f91STakashi Iwai hda_nid_t adc_nids[ARRAY_SIZE(spec->adc_nids)]; 1705352f7f91STakashi Iwai int i, n, nums; 1706352f7f91STakashi Iwai hda_nid_t pin, adc; 1707352f7f91STakashi Iwai 1708352f7f91STakashi Iwai again: 1709352f7f91STakashi Iwai nums = 0; 1710352f7f91STakashi Iwai for (n = 0; n < spec->num_adc_nids; n++) { 1711352f7f91STakashi Iwai adc = spec->adc_nids[n]; 1712352f7f91STakashi Iwai for (i = 0; i < imux->num_items; i++) { 1713352f7f91STakashi Iwai pin = spec->imux_pins[i]; 1714352f7f91STakashi Iwai if (!is_reachable_path(codec, pin, adc)) 1715352f7f91STakashi Iwai break; 1716352f7f91STakashi Iwai } 1717352f7f91STakashi Iwai if (i >= imux->num_items) 1718352f7f91STakashi Iwai adc_nids[nums++] = adc; 1719352f7f91STakashi Iwai } 1720352f7f91STakashi Iwai 1721352f7f91STakashi Iwai if (!nums) { 1722352f7f91STakashi Iwai if (spec->shared_mic_hp) { 1723352f7f91STakashi Iwai spec->shared_mic_hp = 0; 1724352f7f91STakashi Iwai imux->num_items = 1; 1725352f7f91STakashi Iwai goto again; 1726352f7f91STakashi Iwai } 1727352f7f91STakashi Iwai 1728352f7f91STakashi Iwai /* check whether ADC-switch is possible */ 1729352f7f91STakashi Iwai for (i = 0; i < imux->num_items; i++) { 1730352f7f91STakashi Iwai pin = spec->imux_pins[i]; 1731352f7f91STakashi Iwai for (n = 0; n < spec->num_adc_nids; n++) { 1732352f7f91STakashi Iwai adc = spec->adc_nids[n]; 1733352f7f91STakashi Iwai if (is_reachable_path(codec, pin, adc)) { 1734352f7f91STakashi Iwai spec->dyn_adc_idx[i] = n; 1735352f7f91STakashi Iwai break; 1736352f7f91STakashi Iwai } 1737352f7f91STakashi Iwai } 1738352f7f91STakashi Iwai } 1739352f7f91STakashi Iwai 1740352f7f91STakashi Iwai snd_printdd("hda-codec: enabling ADC switching\n"); 1741352f7f91STakashi Iwai spec->dyn_adc_switch = 1; 1742352f7f91STakashi Iwai } else if (nums != spec->num_adc_nids) { 1743352f7f91STakashi Iwai memcpy(spec->adc_nids, adc_nids, nums * sizeof(hda_nid_t)); 1744352f7f91STakashi Iwai spec->num_adc_nids = nums; 1745352f7f91STakashi Iwai } 1746352f7f91STakashi Iwai 1747352f7f91STakashi Iwai if (imux->num_items == 1 || spec->shared_mic_hp) { 1748352f7f91STakashi Iwai snd_printdd("hda-codec: reducing to a single ADC\n"); 1749352f7f91STakashi Iwai spec->num_adc_nids = 1; /* reduce to a single ADC */ 1750352f7f91STakashi Iwai } 1751352f7f91STakashi Iwai 1752352f7f91STakashi Iwai /* single index for individual volumes ctls */ 1753352f7f91STakashi Iwai if (!spec->dyn_adc_switch && spec->multi_cap_vol) 1754352f7f91STakashi Iwai spec->num_adc_nids = 1; 1755352f7f91STakashi Iwai 17561da177e4SLinus Torvalds return 0; 17571da177e4SLinus Torvalds } 17581da177e4SLinus Torvalds 17591da177e4SLinus Torvalds /* 1760352f7f91STakashi Iwai * create playback/capture controls for input pins 17611da177e4SLinus Torvalds */ 1762352f7f91STakashi Iwai static int create_input_ctls(struct hda_codec *codec) 1763a7da6ce5STakashi Iwai { 1764352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1765352f7f91STakashi Iwai const struct auto_pin_cfg *cfg = &spec->autocfg; 1766352f7f91STakashi Iwai hda_nid_t mixer = spec->mixer_nid; 1767352f7f91STakashi Iwai struct hda_input_mux *imux = &spec->input_mux; 1768352f7f91STakashi Iwai int num_adcs; 1769352f7f91STakashi Iwai int i, c, err, type_idx = 0; 1770352f7f91STakashi Iwai const char *prev_label = NULL; 1771a7da6ce5STakashi Iwai 1772352f7f91STakashi Iwai num_adcs = fill_adc_nids(codec); 1773352f7f91STakashi Iwai if (num_adcs < 0) 1774352f7f91STakashi Iwai return 0; 1775352f7f91STakashi Iwai 1776352f7f91STakashi Iwai for (i = 0; i < cfg->num_inputs; i++) { 1777352f7f91STakashi Iwai hda_nid_t pin; 1778352f7f91STakashi Iwai const char *label; 1779352f7f91STakashi Iwai bool imux_added; 1780352f7f91STakashi Iwai 1781352f7f91STakashi Iwai pin = cfg->inputs[i].pin; 1782352f7f91STakashi Iwai if (!is_input_pin(codec, pin)) 1783352f7f91STakashi Iwai continue; 1784352f7f91STakashi Iwai 1785352f7f91STakashi Iwai label = hda_get_autocfg_input_label(codec, cfg, i); 1786352f7f91STakashi Iwai if (spec->shared_mic_hp && !strcmp(label, "Misc")) 1787352f7f91STakashi Iwai label = "Headphone Mic"; 1788352f7f91STakashi Iwai if (prev_label && !strcmp(label, prev_label)) 1789352f7f91STakashi Iwai type_idx++; 1790352f7f91STakashi Iwai else 1791352f7f91STakashi Iwai type_idx = 0; 1792352f7f91STakashi Iwai prev_label = label; 1793352f7f91STakashi Iwai 1794352f7f91STakashi Iwai if (mixer) { 1795352f7f91STakashi Iwai if (is_reachable_path(codec, pin, mixer)) { 1796352f7f91STakashi Iwai err = new_analog_input(codec, pin, 1797352f7f91STakashi Iwai label, type_idx, mixer); 1798a7da6ce5STakashi Iwai if (err < 0) 1799a7da6ce5STakashi Iwai return err; 1800a7da6ce5STakashi Iwai } 1801352f7f91STakashi Iwai } 1802352f7f91STakashi Iwai 1803352f7f91STakashi Iwai imux_added = false; 1804352f7f91STakashi Iwai for (c = 0; c < num_adcs; c++) { 1805352f7f91STakashi Iwai struct nid_path *path; 1806352f7f91STakashi Iwai hda_nid_t adc = spec->adc_nids[c]; 1807352f7f91STakashi Iwai 1808352f7f91STakashi Iwai if (!is_reachable_path(codec, pin, adc)) 1809352f7f91STakashi Iwai continue; 1810352f7f91STakashi Iwai path = snd_array_new(&spec->paths); 1811352f7f91STakashi Iwai if (!path) 1812352f7f91STakashi Iwai return -ENOMEM; 1813352f7f91STakashi Iwai memset(path, 0, sizeof(*path)); 1814352f7f91STakashi Iwai if (!snd_hda_parse_nid_path(codec, pin, adc, 2, path)) { 1815352f7f91STakashi Iwai snd_printd(KERN_ERR 1816352f7f91STakashi Iwai "invalid input path 0x%x -> 0x%x\n", 1817352f7f91STakashi Iwai pin, adc); 1818352f7f91STakashi Iwai spec->paths.used--; 1819352f7f91STakashi Iwai continue; 1820352f7f91STakashi Iwai } 1821352f7f91STakashi Iwai 1822352f7f91STakashi Iwai if (!imux_added) { 1823352f7f91STakashi Iwai spec->imux_pins[imux->num_items] = pin; 1824352f7f91STakashi Iwai snd_hda_add_imux_item(imux, label, 1825352f7f91STakashi Iwai imux->num_items, NULL); 1826352f7f91STakashi Iwai imux_added = true; 1827352f7f91STakashi Iwai } 1828352f7f91STakashi Iwai } 1829352f7f91STakashi Iwai } 1830352f7f91STakashi Iwai 1831a7da6ce5STakashi Iwai return 0; 1832a7da6ce5STakashi Iwai } 1833a7da6ce5STakashi Iwai 18341da177e4SLinus Torvalds 1835352f7f91STakashi Iwai /* 1836352f7f91STakashi Iwai * input source mux 1837352f7f91STakashi Iwai */ 1838352f7f91STakashi Iwai 1839352f7f91STakashi Iwai /* get the ADC NID corresponding to the given index */ 1840352f7f91STakashi Iwai static hda_nid_t get_adc_nid(struct hda_codec *codec, int adc_idx, int imux_idx) 1841352f7f91STakashi Iwai { 1842352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1843352f7f91STakashi Iwai if (spec->dyn_adc_switch) 1844352f7f91STakashi Iwai adc_idx = spec->dyn_adc_idx[imux_idx]; 1845352f7f91STakashi Iwai return spec->adc_nids[adc_idx]; 184697ec558aSTakashi Iwai } 1847352f7f91STakashi Iwai 1848352f7f91STakashi Iwai static int mux_select(struct hda_codec *codec, unsigned int adc_idx, 1849352f7f91STakashi Iwai unsigned int idx); 1850352f7f91STakashi Iwai 1851352f7f91STakashi Iwai static int mux_enum_info(struct snd_kcontrol *kcontrol, 1852352f7f91STakashi Iwai struct snd_ctl_elem_info *uinfo) 1853352f7f91STakashi Iwai { 1854352f7f91STakashi Iwai struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1855352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1856352f7f91STakashi Iwai return snd_hda_input_mux_info(&spec->input_mux, uinfo); 1857352f7f91STakashi Iwai } 1858352f7f91STakashi Iwai 1859352f7f91STakashi Iwai static int mux_enum_get(struct snd_kcontrol *kcontrol, 1860352f7f91STakashi Iwai struct snd_ctl_elem_value *ucontrol) 1861352f7f91STakashi Iwai { 1862352f7f91STakashi Iwai struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1863352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1864352f7f91STakashi Iwai unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 1865352f7f91STakashi Iwai 1866352f7f91STakashi Iwai ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 18671da177e4SLinus Torvalds return 0; 18681da177e4SLinus Torvalds } 18691da177e4SLinus Torvalds 1870352f7f91STakashi Iwai static int mux_enum_put(struct snd_kcontrol *kcontrol, 1871352f7f91STakashi Iwai struct snd_ctl_elem_value *ucontrol) 18721da177e4SLinus Torvalds { 1873352f7f91STakashi Iwai struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1874352f7f91STakashi Iwai unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 1875352f7f91STakashi Iwai return mux_select(codec, adc_idx, 1876352f7f91STakashi Iwai ucontrol->value.enumerated.item[0]); 1877352f7f91STakashi Iwai } 1878352f7f91STakashi Iwai 1879352f7f91STakashi Iwai /* 1880352f7f91STakashi Iwai * capture volume and capture switch ctls 1881352f7f91STakashi Iwai */ 1882352f7f91STakashi Iwai 1883352f7f91STakashi Iwai static const struct snd_kcontrol_new cap_src_temp = { 18841da177e4SLinus Torvalds .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1885352f7f91STakashi Iwai .name = "Input Source", 1886352f7f91STakashi Iwai .info = mux_enum_info, 1887352f7f91STakashi Iwai .get = mux_enum_get, 1888352f7f91STakashi Iwai .put = mux_enum_put, 18891da177e4SLinus Torvalds }; 1890071c73adSTakashi Iwai 1891352f7f91STakashi Iwai typedef int (*put_call_t)(struct snd_kcontrol *kcontrol, 1892352f7f91STakashi Iwai struct snd_ctl_elem_value *ucontrol); 1893071c73adSTakashi Iwai 1894352f7f91STakashi Iwai static int cap_put_caller(struct snd_kcontrol *kcontrol, 1895352f7f91STakashi Iwai struct snd_ctl_elem_value *ucontrol, 1896352f7f91STakashi Iwai put_call_t func, int type) 1897352f7f91STakashi Iwai { 1898352f7f91STakashi Iwai struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1899352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 1900352f7f91STakashi Iwai const struct hda_input_mux *imux; 1901352f7f91STakashi Iwai struct nid_path *path; 1902352f7f91STakashi Iwai int i, adc_idx, err = 0; 1903071c73adSTakashi Iwai 1904352f7f91STakashi Iwai imux = &spec->input_mux; 1905352f7f91STakashi Iwai adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 1906352f7f91STakashi Iwai mutex_lock(&codec->control_mutex); 1907352f7f91STakashi Iwai codec->cached_write = 1; 1908352f7f91STakashi Iwai for (i = 0; i < imux->num_items; i++) { 1909352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, spec->imux_pins[i], 1910352f7f91STakashi Iwai get_adc_nid(codec, adc_idx, i)); 1911352f7f91STakashi Iwai if (!path->ctls[type]) 1912352f7f91STakashi Iwai continue; 1913352f7f91STakashi Iwai kcontrol->private_value = path->ctls[type]; 1914352f7f91STakashi Iwai err = func(kcontrol, ucontrol); 1915352f7f91STakashi Iwai if (err < 0) 1916352f7f91STakashi Iwai goto error; 1917352f7f91STakashi Iwai } 1918352f7f91STakashi Iwai error: 1919352f7f91STakashi Iwai codec->cached_write = 0; 1920352f7f91STakashi Iwai mutex_unlock(&codec->control_mutex); 1921352f7f91STakashi Iwai if (err >= 0 && spec->cap_sync_hook) 1922352f7f91STakashi Iwai spec->cap_sync_hook(codec); 1923352f7f91STakashi Iwai return err; 1924352f7f91STakashi Iwai } 1925352f7f91STakashi Iwai 1926352f7f91STakashi Iwai /* capture volume ctl callbacks */ 1927352f7f91STakashi Iwai #define cap_vol_info snd_hda_mixer_amp_volume_info 1928352f7f91STakashi Iwai #define cap_vol_get snd_hda_mixer_amp_volume_get 1929352f7f91STakashi Iwai #define cap_vol_tlv snd_hda_mixer_amp_tlv 1930352f7f91STakashi Iwai 1931352f7f91STakashi Iwai static int cap_vol_put(struct snd_kcontrol *kcontrol, 1932352f7f91STakashi Iwai struct snd_ctl_elem_value *ucontrol) 1933352f7f91STakashi Iwai { 1934352f7f91STakashi Iwai return cap_put_caller(kcontrol, ucontrol, 1935352f7f91STakashi Iwai snd_hda_mixer_amp_volume_put, 1936352f7f91STakashi Iwai NID_PATH_VOL_CTL); 1937352f7f91STakashi Iwai } 1938352f7f91STakashi Iwai 1939352f7f91STakashi Iwai static const struct snd_kcontrol_new cap_vol_temp = { 1940352f7f91STakashi Iwai .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1941352f7f91STakashi Iwai .name = "Capture Volume", 1942352f7f91STakashi Iwai .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 1943352f7f91STakashi Iwai SNDRV_CTL_ELEM_ACCESS_TLV_READ | 1944352f7f91STakashi Iwai SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), 1945352f7f91STakashi Iwai .info = cap_vol_info, 1946352f7f91STakashi Iwai .get = cap_vol_get, 1947352f7f91STakashi Iwai .put = cap_vol_put, 1948352f7f91STakashi Iwai .tlv = { .c = cap_vol_tlv }, 1949352f7f91STakashi Iwai }; 1950352f7f91STakashi Iwai 1951352f7f91STakashi Iwai /* capture switch ctl callbacks */ 1952352f7f91STakashi Iwai #define cap_sw_info snd_ctl_boolean_stereo_info 1953352f7f91STakashi Iwai #define cap_sw_get snd_hda_mixer_amp_switch_get 1954352f7f91STakashi Iwai 1955352f7f91STakashi Iwai static int cap_sw_put(struct snd_kcontrol *kcontrol, 1956352f7f91STakashi Iwai struct snd_ctl_elem_value *ucontrol) 1957352f7f91STakashi Iwai { 1958352f7f91STakashi Iwai return cap_put_caller(kcontrol, ucontrol, 1959352f7f91STakashi Iwai snd_hda_mixer_amp_switch_put, 1960352f7f91STakashi Iwai NID_PATH_MUTE_CTL); 1961352f7f91STakashi Iwai } 1962352f7f91STakashi Iwai 1963352f7f91STakashi Iwai static const struct snd_kcontrol_new cap_sw_temp = { 1964352f7f91STakashi Iwai .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1965352f7f91STakashi Iwai .name = "Capture Switch", 1966352f7f91STakashi Iwai .info = cap_sw_info, 1967352f7f91STakashi Iwai .get = cap_sw_get, 1968352f7f91STakashi Iwai .put = cap_sw_put, 1969352f7f91STakashi Iwai }; 1970352f7f91STakashi Iwai 1971352f7f91STakashi Iwai static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path) 1972352f7f91STakashi Iwai { 1973352f7f91STakashi Iwai hda_nid_t nid; 1974352f7f91STakashi Iwai int i, depth; 1975352f7f91STakashi Iwai 1976352f7f91STakashi Iwai path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0; 1977352f7f91STakashi Iwai for (depth = 0; depth < 3; depth++) { 1978352f7f91STakashi Iwai if (depth >= path->depth) 1979352f7f91STakashi Iwai return -EINVAL; 1980352f7f91STakashi Iwai i = path->depth - depth - 1; 1981352f7f91STakashi Iwai nid = path->path[i]; 1982352f7f91STakashi Iwai if (!path->ctls[NID_PATH_VOL_CTL]) { 1983352f7f91STakashi Iwai if (nid_has_volume(codec, nid, HDA_OUTPUT)) 1984352f7f91STakashi Iwai path->ctls[NID_PATH_VOL_CTL] = 1985352f7f91STakashi Iwai HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 1986352f7f91STakashi Iwai else if (nid_has_volume(codec, nid, HDA_INPUT)) { 1987352f7f91STakashi Iwai int idx = path->idx[i]; 1988352f7f91STakashi Iwai if (!depth && codec->single_adc_amp) 1989352f7f91STakashi Iwai idx = 0; 1990352f7f91STakashi Iwai path->ctls[NID_PATH_VOL_CTL] = 1991352f7f91STakashi Iwai HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT); 1992352f7f91STakashi Iwai } 1993352f7f91STakashi Iwai } 1994352f7f91STakashi Iwai if (!path->ctls[NID_PATH_MUTE_CTL]) { 1995352f7f91STakashi Iwai if (nid_has_mute(codec, nid, HDA_OUTPUT)) 1996352f7f91STakashi Iwai path->ctls[NID_PATH_MUTE_CTL] = 1997352f7f91STakashi Iwai HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 1998352f7f91STakashi Iwai else if (nid_has_mute(codec, nid, HDA_INPUT)) { 1999352f7f91STakashi Iwai int idx = path->idx[i]; 2000352f7f91STakashi Iwai if (!depth && codec->single_adc_amp) 2001352f7f91STakashi Iwai idx = 0; 2002352f7f91STakashi Iwai path->ctls[NID_PATH_MUTE_CTL] = 2003352f7f91STakashi Iwai HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT); 2004352f7f91STakashi Iwai } 2005352f7f91STakashi Iwai } 2006352f7f91STakashi Iwai } 2007352f7f91STakashi Iwai return 0; 2008352f7f91STakashi Iwai } 2009352f7f91STakashi Iwai 2010352f7f91STakashi Iwai static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid) 2011352f7f91STakashi Iwai { 2012352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2013352f7f91STakashi Iwai struct auto_pin_cfg *cfg = &spec->autocfg; 2014352f7f91STakashi Iwai unsigned int val; 2015352f7f91STakashi Iwai int i; 2016352f7f91STakashi Iwai 2017352f7f91STakashi Iwai if (!spec->inv_dmic_split) 2018352f7f91STakashi Iwai return false; 2019352f7f91STakashi Iwai for (i = 0; i < cfg->num_inputs; i++) { 2020352f7f91STakashi Iwai if (cfg->inputs[i].pin != nid) 2021352f7f91STakashi Iwai continue; 2022352f7f91STakashi Iwai if (cfg->inputs[i].type != AUTO_PIN_MIC) 2023352f7f91STakashi Iwai return false; 2024352f7f91STakashi Iwai val = snd_hda_codec_get_pincfg(codec, nid); 2025352f7f91STakashi Iwai return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT; 2026352f7f91STakashi Iwai } 2027352f7f91STakashi Iwai return false; 2028352f7f91STakashi Iwai } 2029352f7f91STakashi Iwai 2030352f7f91STakashi Iwai static int add_single_cap_ctl(struct hda_codec *codec, const char *label, 2031352f7f91STakashi Iwai int idx, bool is_switch, unsigned int ctl, 2032352f7f91STakashi Iwai bool inv_dmic) 2033352f7f91STakashi Iwai { 2034352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2035352f7f91STakashi Iwai char tmpname[44]; 2036352f7f91STakashi Iwai int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL; 2037352f7f91STakashi Iwai const char *sfx = is_switch ? "Switch" : "Volume"; 2038352f7f91STakashi Iwai unsigned int chs = inv_dmic ? 1 : 3; 2039352f7f91STakashi Iwai int err; 2040352f7f91STakashi Iwai 2041352f7f91STakashi Iwai if (!ctl) 2042352f7f91STakashi Iwai return 0; 2043352f7f91STakashi Iwai 2044352f7f91STakashi Iwai if (label) 2045352f7f91STakashi Iwai snprintf(tmpname, sizeof(tmpname), 2046352f7f91STakashi Iwai "%s Capture %s", label, sfx); 2047352f7f91STakashi Iwai else 2048352f7f91STakashi Iwai snprintf(tmpname, sizeof(tmpname), 2049352f7f91STakashi Iwai "Capture %s", sfx); 2050352f7f91STakashi Iwai err = add_control(spec, type, tmpname, idx, 2051352f7f91STakashi Iwai amp_val_replace_channels(ctl, chs)); 2052352f7f91STakashi Iwai if (err < 0 || !inv_dmic) 2053352f7f91STakashi Iwai return err; 2054352f7f91STakashi Iwai 2055352f7f91STakashi Iwai /* Make independent right kcontrol */ 2056352f7f91STakashi Iwai if (label) 2057352f7f91STakashi Iwai snprintf(tmpname, sizeof(tmpname), 2058352f7f91STakashi Iwai "Inverted %s Capture %s", label, sfx); 2059352f7f91STakashi Iwai else 2060352f7f91STakashi Iwai snprintf(tmpname, sizeof(tmpname), 2061352f7f91STakashi Iwai "Inverted Capture %s", sfx); 2062352f7f91STakashi Iwai return add_control(spec, type, tmpname, idx, 2063352f7f91STakashi Iwai amp_val_replace_channels(ctl, 2)); 2064352f7f91STakashi Iwai } 2065352f7f91STakashi Iwai 2066352f7f91STakashi Iwai /* create single (and simple) capture volume and switch controls */ 2067352f7f91STakashi Iwai static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx, 2068352f7f91STakashi Iwai unsigned int vol_ctl, unsigned int sw_ctl, 2069352f7f91STakashi Iwai bool inv_dmic) 2070352f7f91STakashi Iwai { 2071352f7f91STakashi Iwai int err; 2072352f7f91STakashi Iwai err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic); 2073352f7f91STakashi Iwai if (err < 0) 2074352f7f91STakashi Iwai return err; 2075352f7f91STakashi Iwai err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic); 2076071c73adSTakashi Iwai if (err < 0) 2077071c73adSTakashi Iwai return err; 2078071c73adSTakashi Iwai return 0; 20791da177e4SLinus Torvalds } 2080071c73adSTakashi Iwai 2081352f7f91STakashi Iwai /* create bound capture volume and switch controls */ 2082352f7f91STakashi Iwai static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx, 2083352f7f91STakashi Iwai unsigned int vol_ctl, unsigned int sw_ctl) 2084352f7f91STakashi Iwai { 2085352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2086352f7f91STakashi Iwai struct snd_kcontrol_new *knew; 2087352f7f91STakashi Iwai 2088352f7f91STakashi Iwai if (vol_ctl) { 2089352f7f91STakashi Iwai knew = add_kctl(spec, NULL, &cap_vol_temp); 2090352f7f91STakashi Iwai if (!knew) 2091352f7f91STakashi Iwai return -ENOMEM; 2092352f7f91STakashi Iwai knew->index = idx; 2093352f7f91STakashi Iwai knew->private_value = vol_ctl; 2094352f7f91STakashi Iwai knew->subdevice = HDA_SUBDEV_AMP_FLAG; 2095352f7f91STakashi Iwai } 2096352f7f91STakashi Iwai if (sw_ctl) { 2097352f7f91STakashi Iwai knew = add_kctl(spec, NULL, &cap_sw_temp); 2098352f7f91STakashi Iwai if (!knew) 2099352f7f91STakashi Iwai return -ENOMEM; 2100352f7f91STakashi Iwai knew->index = idx; 2101352f7f91STakashi Iwai knew->private_value = sw_ctl; 2102352f7f91STakashi Iwai knew->subdevice = HDA_SUBDEV_AMP_FLAG; 2103352f7f91STakashi Iwai } 2104352f7f91STakashi Iwai return 0; 2105352f7f91STakashi Iwai } 2106352f7f91STakashi Iwai 2107352f7f91STakashi Iwai /* return the vol ctl when used first in the imux list */ 2108352f7f91STakashi Iwai static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type) 2109352f7f91STakashi Iwai { 2110352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2111352f7f91STakashi Iwai struct nid_path *path; 2112352f7f91STakashi Iwai unsigned int ctl; 2113352f7f91STakashi Iwai int i; 2114352f7f91STakashi Iwai 2115352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, spec->imux_pins[idx], 2116352f7f91STakashi Iwai get_adc_nid(codec, 0, idx)); 2117352f7f91STakashi Iwai if (!path) 2118352f7f91STakashi Iwai return 0; 2119352f7f91STakashi Iwai ctl = path->ctls[type]; 2120352f7f91STakashi Iwai if (!ctl) 2121352f7f91STakashi Iwai return 0; 2122352f7f91STakashi Iwai for (i = 0; i < idx - 1; i++) { 2123352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, spec->imux_pins[i], 2124352f7f91STakashi Iwai get_adc_nid(codec, 0, i)); 2125352f7f91STakashi Iwai if (path && path->ctls[type] == ctl) 2126352f7f91STakashi Iwai return 0; 2127352f7f91STakashi Iwai } 2128352f7f91STakashi Iwai return ctl; 2129352f7f91STakashi Iwai } 2130352f7f91STakashi Iwai 2131352f7f91STakashi Iwai /* create individual capture volume and switch controls per input */ 2132352f7f91STakashi Iwai static int create_multi_cap_vol_ctl(struct hda_codec *codec) 2133352f7f91STakashi Iwai { 2134352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2135352f7f91STakashi Iwai struct hda_input_mux *imux = &spec->input_mux; 2136352f7f91STakashi Iwai int i, err, type, type_idx = 0; 2137352f7f91STakashi Iwai const char *prev_label = NULL; 2138352f7f91STakashi Iwai 2139352f7f91STakashi Iwai for (i = 0; i < imux->num_items; i++) { 2140352f7f91STakashi Iwai const char *label; 2141352f7f91STakashi Iwai bool inv_dmic; 2142352f7f91STakashi Iwai label = hda_get_autocfg_input_label(codec, &spec->autocfg, i); 2143352f7f91STakashi Iwai if (prev_label && !strcmp(label, prev_label)) 2144352f7f91STakashi Iwai type_idx++; 2145352f7f91STakashi Iwai else 2146352f7f91STakashi Iwai type_idx = 0; 2147352f7f91STakashi Iwai prev_label = label; 2148352f7f91STakashi Iwai inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]); 2149352f7f91STakashi Iwai 2150352f7f91STakashi Iwai for (type = 0; type < 2; type++) { 2151352f7f91STakashi Iwai err = add_single_cap_ctl(codec, label, type_idx, type, 2152352f7f91STakashi Iwai get_first_cap_ctl(codec, i, type), 2153352f7f91STakashi Iwai inv_dmic); 2154d13bd412STakashi Iwai if (err < 0) 2155071c73adSTakashi Iwai return err; 2156352f7f91STakashi Iwai } 2157352f7f91STakashi Iwai } 2158071c73adSTakashi Iwai return 0; 2159352f7f91STakashi Iwai } 2160071c73adSTakashi Iwai 2161352f7f91STakashi Iwai static int create_capture_mixers(struct hda_codec *codec) 2162352f7f91STakashi Iwai { 2163352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2164352f7f91STakashi Iwai struct hda_input_mux *imux = &spec->input_mux; 2165352f7f91STakashi Iwai int i, n, nums, err; 2166352f7f91STakashi Iwai 2167352f7f91STakashi Iwai if (spec->dyn_adc_switch) 2168352f7f91STakashi Iwai nums = 1; 2169352f7f91STakashi Iwai else 2170352f7f91STakashi Iwai nums = spec->num_adc_nids; 2171352f7f91STakashi Iwai 2172352f7f91STakashi Iwai if (!spec->auto_mic && imux->num_items > 1) { 2173352f7f91STakashi Iwai struct snd_kcontrol_new *knew; 2174352f7f91STakashi Iwai knew = add_kctl(spec, NULL, &cap_src_temp); 2175352f7f91STakashi Iwai if (!knew) 2176352f7f91STakashi Iwai return -ENOMEM; 2177352f7f91STakashi Iwai knew->count = nums; 2178352f7f91STakashi Iwai } 2179352f7f91STakashi Iwai 2180352f7f91STakashi Iwai for (n = 0; n < nums; n++) { 2181352f7f91STakashi Iwai bool multi = false; 2182352f7f91STakashi Iwai bool inv_dmic = false; 2183352f7f91STakashi Iwai int vol, sw; 2184352f7f91STakashi Iwai 2185352f7f91STakashi Iwai vol = sw = 0; 2186352f7f91STakashi Iwai for (i = 0; i < imux->num_items; i++) { 2187352f7f91STakashi Iwai struct nid_path *path; 2188352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, spec->imux_pins[i], 2189352f7f91STakashi Iwai get_adc_nid(codec, n, i)); 2190352f7f91STakashi Iwai if (!path) 2191352f7f91STakashi Iwai continue; 2192352f7f91STakashi Iwai parse_capvol_in_path(codec, path); 2193352f7f91STakashi Iwai if (!vol) 2194352f7f91STakashi Iwai vol = path->ctls[NID_PATH_VOL_CTL]; 2195352f7f91STakashi Iwai else if (vol != path->ctls[NID_PATH_VOL_CTL]) 2196352f7f91STakashi Iwai multi = true; 2197352f7f91STakashi Iwai if (!sw) 2198352f7f91STakashi Iwai sw = path->ctls[NID_PATH_MUTE_CTL]; 2199352f7f91STakashi Iwai else if (sw != path->ctls[NID_PATH_MUTE_CTL]) 2200352f7f91STakashi Iwai multi = true; 2201352f7f91STakashi Iwai if (is_inv_dmic_pin(codec, spec->imux_pins[i])) 2202352f7f91STakashi Iwai inv_dmic = true; 2203352f7f91STakashi Iwai } 2204352f7f91STakashi Iwai 2205352f7f91STakashi Iwai if (!multi) 2206352f7f91STakashi Iwai err = create_single_cap_vol_ctl(codec, n, vol, sw, 2207352f7f91STakashi Iwai inv_dmic); 2208352f7f91STakashi Iwai else if (!spec->multi_cap_vol) 2209352f7f91STakashi Iwai err = create_bind_cap_vol_ctl(codec, n, vol, sw); 2210352f7f91STakashi Iwai else 2211352f7f91STakashi Iwai err = create_multi_cap_vol_ctl(codec); 2212d13bd412STakashi Iwai if (err < 0) 2213071c73adSTakashi Iwai return err; 2214071c73adSTakashi Iwai } 2215071c73adSTakashi Iwai 22161da177e4SLinus Torvalds return 0; 22171da177e4SLinus Torvalds } 22181da177e4SLinus Torvalds 2219352f7f91STakashi Iwai /* 2220352f7f91STakashi Iwai * add mic boosts if needed 2221352f7f91STakashi Iwai */ 2222352f7f91STakashi Iwai static int parse_mic_boost(struct hda_codec *codec) 2223352f7f91STakashi Iwai { 2224352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2225352f7f91STakashi Iwai struct auto_pin_cfg *cfg = &spec->autocfg; 2226352f7f91STakashi Iwai int i, err; 2227352f7f91STakashi Iwai int type_idx = 0; 2228352f7f91STakashi Iwai hda_nid_t nid; 2229352f7f91STakashi Iwai const char *prev_label = NULL; 2230352f7f91STakashi Iwai 2231352f7f91STakashi Iwai for (i = 0; i < cfg->num_inputs; i++) { 2232352f7f91STakashi Iwai if (cfg->inputs[i].type > AUTO_PIN_MIC) 2233352f7f91STakashi Iwai break; 2234352f7f91STakashi Iwai nid = cfg->inputs[i].pin; 2235352f7f91STakashi Iwai if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) { 2236352f7f91STakashi Iwai const char *label; 2237352f7f91STakashi Iwai char boost_label[32]; 2238352f7f91STakashi Iwai struct nid_path *path; 2239352f7f91STakashi Iwai unsigned int val; 2240352f7f91STakashi Iwai 2241352f7f91STakashi Iwai label = hda_get_autocfg_input_label(codec, cfg, i); 2242352f7f91STakashi Iwai if (spec->shared_mic_hp && !strcmp(label, "Misc")) 2243352f7f91STakashi Iwai label = "Headphone Mic"; 2244352f7f91STakashi Iwai if (prev_label && !strcmp(label, prev_label)) 2245352f7f91STakashi Iwai type_idx++; 2246352f7f91STakashi Iwai else 2247352f7f91STakashi Iwai type_idx = 0; 2248352f7f91STakashi Iwai prev_label = label; 2249352f7f91STakashi Iwai 2250352f7f91STakashi Iwai snprintf(boost_label, sizeof(boost_label), 2251352f7f91STakashi Iwai "%s Boost Volume", label); 2252352f7f91STakashi Iwai val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT); 2253352f7f91STakashi Iwai err = add_control(spec, HDA_CTL_WIDGET_VOL, 2254352f7f91STakashi Iwai boost_label, type_idx, val); 2255352f7f91STakashi Iwai if (err < 0) 2256352f7f91STakashi Iwai return err; 2257352f7f91STakashi Iwai 2258352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, nid, 0); 2259352f7f91STakashi Iwai if (path) 2260352f7f91STakashi Iwai path->ctls[NID_PATH_BOOST_CTL] = val; 2261352f7f91STakashi Iwai } 2262352f7f91STakashi Iwai } 2263352f7f91STakashi Iwai return 0; 2264352f7f91STakashi Iwai } 2265352f7f91STakashi Iwai 2266352f7f91STakashi Iwai /* 2267352f7f91STakashi Iwai * parse digital I/Os and set up NIDs in BIOS auto-parse mode 2268352f7f91STakashi Iwai */ 2269352f7f91STakashi Iwai static void parse_digital(struct hda_codec *codec) 2270352f7f91STakashi Iwai { 2271352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2272352f7f91STakashi Iwai int i, nums; 2273352f7f91STakashi Iwai hda_nid_t dig_nid; 2274352f7f91STakashi Iwai 2275352f7f91STakashi Iwai /* support multiple SPDIFs; the secondary is set up as a slave */ 2276352f7f91STakashi Iwai nums = 0; 2277352f7f91STakashi Iwai for (i = 0; i < spec->autocfg.dig_outs; i++) { 2278352f7f91STakashi Iwai hda_nid_t pin = spec->autocfg.dig_out_pins[i]; 2279352f7f91STakashi Iwai dig_nid = look_for_dac(codec, pin, true); 2280352f7f91STakashi Iwai if (!dig_nid) 2281352f7f91STakashi Iwai continue; 2282352f7f91STakashi Iwai if (!snd_hda_add_new_path(codec, dig_nid, pin, 2)) 2283352f7f91STakashi Iwai continue; 2284352f7f91STakashi Iwai if (!nums) { 2285352f7f91STakashi Iwai spec->multiout.dig_out_nid = dig_nid; 2286352f7f91STakashi Iwai spec->dig_out_type = spec->autocfg.dig_out_type[0]; 2287352f7f91STakashi Iwai } else { 2288352f7f91STakashi Iwai spec->multiout.slave_dig_outs = spec->slave_dig_outs; 2289352f7f91STakashi Iwai if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1) 2290352f7f91STakashi Iwai break; 2291352f7f91STakashi Iwai spec->slave_dig_outs[nums - 1] = dig_nid; 2292352f7f91STakashi Iwai } 2293352f7f91STakashi Iwai nums++; 2294352f7f91STakashi Iwai } 2295352f7f91STakashi Iwai 2296352f7f91STakashi Iwai if (spec->autocfg.dig_in_pin) { 2297352f7f91STakashi Iwai dig_nid = codec->start_nid; 2298352f7f91STakashi Iwai for (i = 0; i < codec->num_nodes; i++, dig_nid++) { 2299352f7f91STakashi Iwai struct nid_path *path; 2300352f7f91STakashi Iwai unsigned int wcaps = get_wcaps(codec, dig_nid); 2301352f7f91STakashi Iwai if (get_wcaps_type(wcaps) != AC_WID_AUD_IN) 2302352f7f91STakashi Iwai continue; 2303352f7f91STakashi Iwai if (!(wcaps & AC_WCAP_DIGITAL)) 2304352f7f91STakashi Iwai continue; 2305352f7f91STakashi Iwai path = snd_hda_add_new_path(codec, 2306352f7f91STakashi Iwai spec->autocfg.dig_in_pin, 2307352f7f91STakashi Iwai dig_nid, 2); 2308352f7f91STakashi Iwai if (path) { 2309352f7f91STakashi Iwai path->active = true; 2310352f7f91STakashi Iwai spec->dig_in_nid = dig_nid; 2311352f7f91STakashi Iwai break; 2312352f7f91STakashi Iwai } 2313352f7f91STakashi Iwai } 2314352f7f91STakashi Iwai } 2315352f7f91STakashi Iwai } 2316352f7f91STakashi Iwai 23171da177e4SLinus Torvalds 23181da177e4SLinus Torvalds /* 2319352f7f91STakashi Iwai * input MUX handling 23201da177e4SLinus Torvalds */ 23211da177e4SLinus Torvalds 2322352f7f91STakashi Iwai static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur); 2323352f7f91STakashi Iwai 2324352f7f91STakashi Iwai /* select the given imux item; either unmute exclusively or select the route */ 2325352f7f91STakashi Iwai static int mux_select(struct hda_codec *codec, unsigned int adc_idx, 2326352f7f91STakashi Iwai unsigned int idx) 2327352f7f91STakashi Iwai { 2328352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2329352f7f91STakashi Iwai const struct hda_input_mux *imux; 2330352f7f91STakashi Iwai struct nid_path *path; 2331352f7f91STakashi Iwai 2332352f7f91STakashi Iwai imux = &spec->input_mux; 2333352f7f91STakashi Iwai if (!imux->num_items) 23341da177e4SLinus Torvalds return 0; 23351da177e4SLinus Torvalds 2336352f7f91STakashi Iwai if (idx >= imux->num_items) 2337352f7f91STakashi Iwai idx = imux->num_items - 1; 2338352f7f91STakashi Iwai if (spec->cur_mux[adc_idx] == idx) 2339352f7f91STakashi Iwai return 0; 2340352f7f91STakashi Iwai 2341352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, 2342352f7f91STakashi Iwai spec->imux_pins[spec->cur_mux[adc_idx]], 2343352f7f91STakashi Iwai spec->adc_nids[adc_idx]); 2344352f7f91STakashi Iwai if (!path) 2345352f7f91STakashi Iwai return 0; 2346352f7f91STakashi Iwai if (path->active) 2347352f7f91STakashi Iwai snd_hda_activate_path(codec, path, false, false); 2348352f7f91STakashi Iwai 2349352f7f91STakashi Iwai spec->cur_mux[adc_idx] = idx; 2350352f7f91STakashi Iwai 2351352f7f91STakashi Iwai if (spec->shared_mic_hp) 2352352f7f91STakashi Iwai update_shared_mic_hp(codec, spec->cur_mux[adc_idx]); 2353352f7f91STakashi Iwai 2354352f7f91STakashi Iwai if (spec->dyn_adc_switch) 2355352f7f91STakashi Iwai dyn_adc_pcm_resetup(codec, idx); 2356352f7f91STakashi Iwai 2357352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, spec->imux_pins[idx], 2358352f7f91STakashi Iwai get_adc_nid(codec, adc_idx, idx)); 2359352f7f91STakashi Iwai if (!path) 2360352f7f91STakashi Iwai return 0; 2361352f7f91STakashi Iwai if (path->active) 2362352f7f91STakashi Iwai return 0; 2363352f7f91STakashi Iwai snd_hda_activate_path(codec, path, true, false); 2364352f7f91STakashi Iwai if (spec->cap_sync_hook) 2365352f7f91STakashi Iwai spec->cap_sync_hook(codec); 23661da177e4SLinus Torvalds return 1; 23671da177e4SLinus Torvalds } 23681da177e4SLinus Torvalds 23691da177e4SLinus Torvalds 23701da177e4SLinus Torvalds /* 2371352f7f91STakashi Iwai * Jack detections for HP auto-mute and mic-switch 23721da177e4SLinus Torvalds */ 2373352f7f91STakashi Iwai 2374352f7f91STakashi Iwai /* check each pin in the given array; returns true if any of them is plugged */ 2375352f7f91STakashi Iwai static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins) 23761da177e4SLinus Torvalds { 2377352f7f91STakashi Iwai int i, present = 0; 23781da177e4SLinus Torvalds 2379352f7f91STakashi Iwai for (i = 0; i < num_pins; i++) { 2380352f7f91STakashi Iwai hda_nid_t nid = pins[i]; 2381352f7f91STakashi Iwai if (!nid) 2382352f7f91STakashi Iwai break; 2383352f7f91STakashi Iwai present |= snd_hda_jack_detect(codec, nid); 23841da177e4SLinus Torvalds } 2385352f7f91STakashi Iwai return present; 23861da177e4SLinus Torvalds } 23871da177e4SLinus Torvalds 2388352f7f91STakashi Iwai /* standard HP/line-out auto-mute helper */ 2389352f7f91STakashi Iwai static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins, 2390352f7f91STakashi Iwai bool mute, bool hp_out) 23911da177e4SLinus Torvalds { 2392352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2393352f7f91STakashi Iwai unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT); 2394352f7f91STakashi Iwai int i; 23951da177e4SLinus Torvalds 2396352f7f91STakashi Iwai for (i = 0; i < num_pins; i++) { 2397352f7f91STakashi Iwai hda_nid_t nid = pins[i]; 2398352f7f91STakashi Iwai unsigned int val; 2399352f7f91STakashi Iwai if (!nid) 2400352f7f91STakashi Iwai break; 2401352f7f91STakashi Iwai /* don't reset VREF value in case it's controlling 2402352f7f91STakashi Iwai * the amp (see alc861_fixup_asus_amp_vref_0f()) 2403352f7f91STakashi Iwai */ 2404352f7f91STakashi Iwai if (spec->keep_vref_in_automute) { 2405352f7f91STakashi Iwai val = snd_hda_codec_read(codec, nid, 0, 2406352f7f91STakashi Iwai AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 2407352f7f91STakashi Iwai val &= ~PIN_HP; 2408352f7f91STakashi Iwai } else 2409352f7f91STakashi Iwai val = 0; 2410352f7f91STakashi Iwai val |= pin_bits; 2411352f7f91STakashi Iwai snd_hda_set_pin_ctl(codec, nid, val); 2412352f7f91STakashi Iwai } 2413352f7f91STakashi Iwai } 24141da177e4SLinus Torvalds 2415352f7f91STakashi Iwai /* Toggle outputs muting */ 2416352f7f91STakashi Iwai static void update_outputs(struct hda_codec *codec) 2417352f7f91STakashi Iwai { 2418352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2419352f7f91STakashi Iwai int on; 2420352f7f91STakashi Iwai 2421352f7f91STakashi Iwai /* Control HP pins/amps depending on master_mute state; 2422352f7f91STakashi Iwai * in general, HP pins/amps control should be enabled in all cases, 2423352f7f91STakashi Iwai * but currently set only for master_mute, just to be safe 2424352f7f91STakashi Iwai */ 2425352f7f91STakashi Iwai if (!spec->shared_mic_hp) /* don't change HP-pin when shared with mic */ 2426352f7f91STakashi Iwai do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins), 2427352f7f91STakashi Iwai spec->autocfg.hp_pins, spec->master_mute, true); 2428352f7f91STakashi Iwai 2429352f7f91STakashi Iwai if (!spec->automute_speaker) 2430352f7f91STakashi Iwai on = 0; 2431352f7f91STakashi Iwai else 2432352f7f91STakashi Iwai on = spec->hp_jack_present | spec->line_jack_present; 2433352f7f91STakashi Iwai on |= spec->master_mute; 2434352f7f91STakashi Iwai do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins), 2435352f7f91STakashi Iwai spec->autocfg.speaker_pins, on, false); 2436352f7f91STakashi Iwai 2437352f7f91STakashi Iwai /* toggle line-out mutes if needed, too */ 2438352f7f91STakashi Iwai /* if LO is a copy of either HP or Speaker, don't need to handle it */ 2439352f7f91STakashi Iwai if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] || 2440352f7f91STakashi Iwai spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0]) 2441352f7f91STakashi Iwai return; 2442352f7f91STakashi Iwai if (!spec->automute_lo) 2443352f7f91STakashi Iwai on = 0; 2444352f7f91STakashi Iwai else 2445352f7f91STakashi Iwai on = spec->hp_jack_present; 2446352f7f91STakashi Iwai on |= spec->master_mute; 2447352f7f91STakashi Iwai do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins), 2448352f7f91STakashi Iwai spec->autocfg.line_out_pins, on, false); 2449352f7f91STakashi Iwai } 2450352f7f91STakashi Iwai 2451352f7f91STakashi Iwai static void call_update_outputs(struct hda_codec *codec) 2452352f7f91STakashi Iwai { 2453352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2454352f7f91STakashi Iwai if (spec->automute_hook) 2455352f7f91STakashi Iwai spec->automute_hook(codec); 2456352f7f91STakashi Iwai else 2457352f7f91STakashi Iwai update_outputs(codec); 2458352f7f91STakashi Iwai } 2459352f7f91STakashi Iwai 2460352f7f91STakashi Iwai /* standard HP-automute helper */ 2461352f7f91STakashi Iwai static void hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack) 2462352f7f91STakashi Iwai { 2463352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2464352f7f91STakashi Iwai 2465352f7f91STakashi Iwai spec->hp_jack_present = 2466352f7f91STakashi Iwai detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins), 2467352f7f91STakashi Iwai spec->autocfg.hp_pins); 2468352f7f91STakashi Iwai if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo)) 2469352f7f91STakashi Iwai return; 2470352f7f91STakashi Iwai call_update_outputs(codec); 2471352f7f91STakashi Iwai } 2472352f7f91STakashi Iwai 2473352f7f91STakashi Iwai /* standard line-out-automute helper */ 2474352f7f91STakashi Iwai static void line_automute(struct hda_codec *codec, struct hda_jack_tbl *jack) 2475352f7f91STakashi Iwai { 2476352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2477352f7f91STakashi Iwai 2478352f7f91STakashi Iwai if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) 2479352f7f91STakashi Iwai return; 2480352f7f91STakashi Iwai /* check LO jack only when it's different from HP */ 2481352f7f91STakashi Iwai if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0]) 2482352f7f91STakashi Iwai return; 2483352f7f91STakashi Iwai 2484352f7f91STakashi Iwai spec->line_jack_present = 2485352f7f91STakashi Iwai detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins), 2486352f7f91STakashi Iwai spec->autocfg.line_out_pins); 2487352f7f91STakashi Iwai if (!spec->automute_speaker || !spec->detect_lo) 2488352f7f91STakashi Iwai return; 2489352f7f91STakashi Iwai call_update_outputs(codec); 2490352f7f91STakashi Iwai } 2491352f7f91STakashi Iwai 2492352f7f91STakashi Iwai /* standard mic auto-switch helper */ 2493352f7f91STakashi Iwai static void mic_autoswitch(struct hda_codec *codec, struct hda_jack_tbl *jack) 2494352f7f91STakashi Iwai { 2495352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2496352f7f91STakashi Iwai int i; 2497352f7f91STakashi Iwai 2498352f7f91STakashi Iwai if (!spec->auto_mic) 2499352f7f91STakashi Iwai return; 2500352f7f91STakashi Iwai 2501352f7f91STakashi Iwai for (i = spec->am_num_entries - 1; i > 0; i--) { 2502352f7f91STakashi Iwai if (snd_hda_jack_detect(codec, spec->am_entry[i].pin)) { 2503352f7f91STakashi Iwai mux_select(codec, 0, spec->am_entry[i].idx); 2504352f7f91STakashi Iwai return; 2505352f7f91STakashi Iwai } 2506352f7f91STakashi Iwai } 2507352f7f91STakashi Iwai mux_select(codec, 0, spec->am_entry[0].idx); 25081da177e4SLinus Torvalds } 25091da177e4SLinus Torvalds 25101da177e4SLinus Torvalds /* 2511352f7f91STakashi Iwai * Auto-Mute mode mixer enum support 25121da177e4SLinus Torvalds */ 2513352f7f91STakashi Iwai static int automute_mode_info(struct snd_kcontrol *kcontrol, 2514352f7f91STakashi Iwai struct snd_ctl_elem_info *uinfo) 2515352f7f91STakashi Iwai { 2516352f7f91STakashi Iwai struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2517352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2518352f7f91STakashi Iwai static const char * const texts3[] = { 2519352f7f91STakashi Iwai "Disabled", "Speaker Only", "Line Out+Speaker" 25201da177e4SLinus Torvalds }; 25211da177e4SLinus Torvalds 2522352f7f91STakashi Iwai if (spec->automute_speaker_possible && spec->automute_lo_possible) 2523352f7f91STakashi Iwai return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3); 2524352f7f91STakashi Iwai return snd_hda_enum_bool_helper_info(kcontrol, uinfo); 2525352f7f91STakashi Iwai } 2526352f7f91STakashi Iwai 2527352f7f91STakashi Iwai static int automute_mode_get(struct snd_kcontrol *kcontrol, 2528352f7f91STakashi Iwai struct snd_ctl_elem_value *ucontrol) 2529352f7f91STakashi Iwai { 2530352f7f91STakashi Iwai struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2531352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2532352f7f91STakashi Iwai unsigned int val = 0; 2533352f7f91STakashi Iwai if (spec->automute_speaker) 2534352f7f91STakashi Iwai val++; 2535352f7f91STakashi Iwai if (spec->automute_lo) 2536352f7f91STakashi Iwai val++; 2537352f7f91STakashi Iwai 2538352f7f91STakashi Iwai ucontrol->value.enumerated.item[0] = val; 2539352f7f91STakashi Iwai return 0; 2540352f7f91STakashi Iwai } 2541352f7f91STakashi Iwai 2542352f7f91STakashi Iwai static int automute_mode_put(struct snd_kcontrol *kcontrol, 2543352f7f91STakashi Iwai struct snd_ctl_elem_value *ucontrol) 2544352f7f91STakashi Iwai { 2545352f7f91STakashi Iwai struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2546352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2547352f7f91STakashi Iwai 2548352f7f91STakashi Iwai switch (ucontrol->value.enumerated.item[0]) { 2549352f7f91STakashi Iwai case 0: 2550352f7f91STakashi Iwai if (!spec->automute_speaker && !spec->automute_lo) 2551352f7f91STakashi Iwai return 0; 2552352f7f91STakashi Iwai spec->automute_speaker = 0; 2553352f7f91STakashi Iwai spec->automute_lo = 0; 2554352f7f91STakashi Iwai break; 2555352f7f91STakashi Iwai case 1: 2556352f7f91STakashi Iwai if (spec->automute_speaker_possible) { 2557352f7f91STakashi Iwai if (!spec->automute_lo && spec->automute_speaker) 2558352f7f91STakashi Iwai return 0; 2559352f7f91STakashi Iwai spec->automute_speaker = 1; 2560352f7f91STakashi Iwai spec->automute_lo = 0; 2561352f7f91STakashi Iwai } else if (spec->automute_lo_possible) { 2562352f7f91STakashi Iwai if (spec->automute_lo) 2563352f7f91STakashi Iwai return 0; 2564352f7f91STakashi Iwai spec->automute_lo = 1; 2565352f7f91STakashi Iwai } else 2566352f7f91STakashi Iwai return -EINVAL; 2567352f7f91STakashi Iwai break; 2568352f7f91STakashi Iwai case 2: 2569352f7f91STakashi Iwai if (!spec->automute_lo_possible || !spec->automute_speaker_possible) 2570352f7f91STakashi Iwai return -EINVAL; 2571352f7f91STakashi Iwai if (spec->automute_speaker && spec->automute_lo) 2572352f7f91STakashi Iwai return 0; 2573352f7f91STakashi Iwai spec->automute_speaker = 1; 2574352f7f91STakashi Iwai spec->automute_lo = 1; 2575352f7f91STakashi Iwai break; 2576352f7f91STakashi Iwai default: 2577352f7f91STakashi Iwai return -EINVAL; 2578352f7f91STakashi Iwai } 2579352f7f91STakashi Iwai call_update_outputs(codec); 2580352f7f91STakashi Iwai return 1; 2581352f7f91STakashi Iwai } 2582352f7f91STakashi Iwai 2583352f7f91STakashi Iwai static const struct snd_kcontrol_new automute_mode_enum = { 2584352f7f91STakashi Iwai .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2585352f7f91STakashi Iwai .name = "Auto-Mute Mode", 2586352f7f91STakashi Iwai .info = automute_mode_info, 2587352f7f91STakashi Iwai .get = automute_mode_get, 2588352f7f91STakashi Iwai .put = automute_mode_put, 2589352f7f91STakashi Iwai }; 2590352f7f91STakashi Iwai 2591352f7f91STakashi Iwai static int add_automute_mode_enum(struct hda_codec *codec) 2592352f7f91STakashi Iwai { 2593352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2594352f7f91STakashi Iwai 2595352f7f91STakashi Iwai if (!add_kctl(spec, NULL, &automute_mode_enum)) 2596352f7f91STakashi Iwai return -ENOMEM; 2597352f7f91STakashi Iwai return 0; 2598352f7f91STakashi Iwai } 2599352f7f91STakashi Iwai 2600352f7f91STakashi Iwai /* 2601352f7f91STakashi Iwai * Check the availability of HP/line-out auto-mute; 2602352f7f91STakashi Iwai * Set up appropriately if really supported 2603352f7f91STakashi Iwai */ 2604352f7f91STakashi Iwai static int check_auto_mute_availability(struct hda_codec *codec) 2605352f7f91STakashi Iwai { 2606352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2607352f7f91STakashi Iwai struct auto_pin_cfg *cfg = &spec->autocfg; 2608352f7f91STakashi Iwai int present = 0; 2609352f7f91STakashi Iwai int i, err; 2610352f7f91STakashi Iwai 2611352f7f91STakashi Iwai if (cfg->hp_pins[0]) 2612352f7f91STakashi Iwai present++; 2613352f7f91STakashi Iwai if (cfg->line_out_pins[0]) 2614352f7f91STakashi Iwai present++; 2615352f7f91STakashi Iwai if (cfg->speaker_pins[0]) 2616352f7f91STakashi Iwai present++; 2617352f7f91STakashi Iwai if (present < 2) /* need two different output types */ 2618352f7f91STakashi Iwai return 0; 2619352f7f91STakashi Iwai 2620352f7f91STakashi Iwai if (!cfg->speaker_pins[0] && 2621352f7f91STakashi Iwai cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) { 2622352f7f91STakashi Iwai memcpy(cfg->speaker_pins, cfg->line_out_pins, 2623352f7f91STakashi Iwai sizeof(cfg->speaker_pins)); 2624352f7f91STakashi Iwai cfg->speaker_outs = cfg->line_outs; 2625352f7f91STakashi Iwai } 2626352f7f91STakashi Iwai 2627352f7f91STakashi Iwai if (!cfg->hp_pins[0] && 2628352f7f91STakashi Iwai cfg->line_out_type == AUTO_PIN_HP_OUT) { 2629352f7f91STakashi Iwai memcpy(cfg->hp_pins, cfg->line_out_pins, 2630352f7f91STakashi Iwai sizeof(cfg->hp_pins)); 2631352f7f91STakashi Iwai cfg->hp_outs = cfg->line_outs; 2632352f7f91STakashi Iwai } 2633352f7f91STakashi Iwai 2634352f7f91STakashi Iwai for (i = 0; i < cfg->hp_outs; i++) { 2635352f7f91STakashi Iwai hda_nid_t nid = cfg->hp_pins[i]; 2636352f7f91STakashi Iwai if (!is_jack_detectable(codec, nid)) 2637352f7f91STakashi Iwai continue; 2638352f7f91STakashi Iwai snd_printdd("hda-codec: Enable HP auto-muting on NID 0x%x\n", 2639352f7f91STakashi Iwai nid); 2640352f7f91STakashi Iwai snd_hda_jack_detect_enable_callback(codec, nid, HDA_GEN_HP_EVENT, 2641352f7f91STakashi Iwai hp_automute); 2642352f7f91STakashi Iwai spec->detect_hp = 1; 2643352f7f91STakashi Iwai } 2644352f7f91STakashi Iwai 2645352f7f91STakashi Iwai if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) { 2646352f7f91STakashi Iwai if (cfg->speaker_outs) 2647352f7f91STakashi Iwai for (i = 0; i < cfg->line_outs; i++) { 2648352f7f91STakashi Iwai hda_nid_t nid = cfg->line_out_pins[i]; 2649352f7f91STakashi Iwai if (!is_jack_detectable(codec, nid)) 2650352f7f91STakashi Iwai continue; 2651352f7f91STakashi Iwai snd_printdd("hda-codec: Enable Line-Out auto-muting on NID 0x%x\n", nid); 2652352f7f91STakashi Iwai snd_hda_jack_detect_enable_callback(codec, nid, 2653352f7f91STakashi Iwai HDA_GEN_FRONT_EVENT, 2654352f7f91STakashi Iwai line_automute); 2655352f7f91STakashi Iwai spec->detect_lo = 1; 2656352f7f91STakashi Iwai } 2657352f7f91STakashi Iwai spec->automute_lo_possible = spec->detect_hp; 2658352f7f91STakashi Iwai } 2659352f7f91STakashi Iwai 2660352f7f91STakashi Iwai spec->automute_speaker_possible = cfg->speaker_outs && 2661352f7f91STakashi Iwai (spec->detect_hp || spec->detect_lo); 2662352f7f91STakashi Iwai 2663352f7f91STakashi Iwai spec->automute_lo = spec->automute_lo_possible; 2664352f7f91STakashi Iwai spec->automute_speaker = spec->automute_speaker_possible; 2665352f7f91STakashi Iwai 2666352f7f91STakashi Iwai if (spec->automute_speaker_possible || spec->automute_lo_possible) { 2667352f7f91STakashi Iwai /* create a control for automute mode */ 2668352f7f91STakashi Iwai err = add_automute_mode_enum(codec); 2669352f7f91STakashi Iwai if (err < 0) 2670352f7f91STakashi Iwai return err; 2671352f7f91STakashi Iwai } 2672352f7f91STakashi Iwai return 0; 2673352f7f91STakashi Iwai } 2674352f7f91STakashi Iwai 2675352f7f91STakashi Iwai /* return the position of NID in the list, or -1 if not found */ 2676352f7f91STakashi Iwai static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 2677352f7f91STakashi Iwai { 2678352f7f91STakashi Iwai int i; 2679352f7f91STakashi Iwai for (i = 0; i < nums; i++) 2680352f7f91STakashi Iwai if (list[i] == nid) 2681352f7f91STakashi Iwai return i; 2682352f7f91STakashi Iwai return -1; 2683352f7f91STakashi Iwai } 2684352f7f91STakashi Iwai 2685352f7f91STakashi Iwai /* check whether all auto-mic pins are valid; setup indices if OK */ 2686352f7f91STakashi Iwai static bool auto_mic_check_imux(struct hda_codec *codec) 2687352f7f91STakashi Iwai { 2688352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2689352f7f91STakashi Iwai const struct hda_input_mux *imux; 2690352f7f91STakashi Iwai int i; 2691352f7f91STakashi Iwai 2692352f7f91STakashi Iwai imux = &spec->input_mux; 2693352f7f91STakashi Iwai for (i = 0; i < spec->am_num_entries; i++) { 2694352f7f91STakashi Iwai spec->am_entry[i].idx = 2695352f7f91STakashi Iwai find_idx_in_nid_list(spec->am_entry[i].pin, 2696352f7f91STakashi Iwai spec->imux_pins, imux->num_items); 2697352f7f91STakashi Iwai if (spec->am_entry[i].idx < 0) 2698352f7f91STakashi Iwai return false; /* no corresponding imux */ 2699352f7f91STakashi Iwai } 2700352f7f91STakashi Iwai 2701352f7f91STakashi Iwai /* we don't need the jack detection for the first pin */ 2702352f7f91STakashi Iwai for (i = 1; i < spec->am_num_entries; i++) 2703352f7f91STakashi Iwai snd_hda_jack_detect_enable_callback(codec, 2704352f7f91STakashi Iwai spec->am_entry[i].pin, 2705352f7f91STakashi Iwai HDA_GEN_MIC_EVENT, 2706352f7f91STakashi Iwai mic_autoswitch); 2707352f7f91STakashi Iwai return true; 2708352f7f91STakashi Iwai } 2709352f7f91STakashi Iwai 2710352f7f91STakashi Iwai static int compare_attr(const void *ap, const void *bp) 2711352f7f91STakashi Iwai { 2712352f7f91STakashi Iwai const struct automic_entry *a = ap; 2713352f7f91STakashi Iwai const struct automic_entry *b = bp; 2714352f7f91STakashi Iwai return (int)(a->attr - b->attr); 2715352f7f91STakashi Iwai } 2716352f7f91STakashi Iwai 2717352f7f91STakashi Iwai /* 2718352f7f91STakashi Iwai * Check the availability of auto-mic switch; 2719352f7f91STakashi Iwai * Set up if really supported 2720352f7f91STakashi Iwai */ 2721352f7f91STakashi Iwai static int check_auto_mic_availability(struct hda_codec *codec) 2722352f7f91STakashi Iwai { 2723352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2724352f7f91STakashi Iwai struct auto_pin_cfg *cfg = &spec->autocfg; 2725352f7f91STakashi Iwai unsigned int types; 2726352f7f91STakashi Iwai int i, num_pins; 2727352f7f91STakashi Iwai 2728352f7f91STakashi Iwai types = 0; 2729352f7f91STakashi Iwai num_pins = 0; 2730352f7f91STakashi Iwai for (i = 0; i < cfg->num_inputs; i++) { 2731352f7f91STakashi Iwai hda_nid_t nid = cfg->inputs[i].pin; 2732352f7f91STakashi Iwai unsigned int attr; 2733352f7f91STakashi Iwai attr = snd_hda_codec_get_pincfg(codec, nid); 2734352f7f91STakashi Iwai attr = snd_hda_get_input_pin_attr(attr); 2735352f7f91STakashi Iwai if (types & (1 << attr)) 2736352f7f91STakashi Iwai return 0; /* already occupied */ 2737352f7f91STakashi Iwai switch (attr) { 2738352f7f91STakashi Iwai case INPUT_PIN_ATTR_INT: 2739352f7f91STakashi Iwai if (cfg->inputs[i].type != AUTO_PIN_MIC) 2740352f7f91STakashi Iwai return 0; /* invalid type */ 2741352f7f91STakashi Iwai break; 2742352f7f91STakashi Iwai case INPUT_PIN_ATTR_UNUSED: 2743352f7f91STakashi Iwai return 0; /* invalid entry */ 2744352f7f91STakashi Iwai default: 2745352f7f91STakashi Iwai if (cfg->inputs[i].type > AUTO_PIN_LINE_IN) 2746352f7f91STakashi Iwai return 0; /* invalid type */ 2747352f7f91STakashi Iwai if (!spec->line_in_auto_switch && 2748352f7f91STakashi Iwai cfg->inputs[i].type != AUTO_PIN_MIC) 2749352f7f91STakashi Iwai return 0; /* only mic is allowed */ 2750352f7f91STakashi Iwai if (!is_jack_detectable(codec, nid)) 2751352f7f91STakashi Iwai return 0; /* no unsol support */ 2752352f7f91STakashi Iwai break; 2753352f7f91STakashi Iwai } 2754352f7f91STakashi Iwai if (num_pins >= MAX_AUTO_MIC_PINS) 2755352f7f91STakashi Iwai return 0; 2756352f7f91STakashi Iwai types |= (1 << attr); 2757352f7f91STakashi Iwai spec->am_entry[num_pins].pin = nid; 2758352f7f91STakashi Iwai spec->am_entry[num_pins].attr = attr; 2759352f7f91STakashi Iwai num_pins++; 2760352f7f91STakashi Iwai } 2761352f7f91STakashi Iwai 2762352f7f91STakashi Iwai if (num_pins < 2) 2763352f7f91STakashi Iwai return 0; 2764352f7f91STakashi Iwai 2765352f7f91STakashi Iwai spec->am_num_entries = num_pins; 2766352f7f91STakashi Iwai /* sort the am_entry in the order of attr so that the pin with a 2767352f7f91STakashi Iwai * higher attr will be selected when the jack is plugged. 2768352f7f91STakashi Iwai */ 2769352f7f91STakashi Iwai sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]), 2770352f7f91STakashi Iwai compare_attr, NULL); 2771352f7f91STakashi Iwai 2772352f7f91STakashi Iwai if (!auto_mic_check_imux(codec)) 2773352f7f91STakashi Iwai return 0; 2774352f7f91STakashi Iwai 2775352f7f91STakashi Iwai spec->auto_mic = 1; 2776352f7f91STakashi Iwai spec->num_adc_nids = 1; 2777352f7f91STakashi Iwai spec->cur_mux[0] = spec->am_entry[0].idx; 2778352f7f91STakashi Iwai snd_printdd("hda-codec: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n", 2779352f7f91STakashi Iwai spec->am_entry[0].pin, 2780352f7f91STakashi Iwai spec->am_entry[1].pin, 2781352f7f91STakashi Iwai spec->am_entry[2].pin); 2782352f7f91STakashi Iwai 2783352f7f91STakashi Iwai return 0; 2784352f7f91STakashi Iwai } 2785352f7f91STakashi Iwai 2786352f7f91STakashi Iwai 2787352f7f91STakashi Iwai /* parse the BIOS configuration and set up the hda_gen_spec */ 2788352f7f91STakashi Iwai /* return 1 if successful, 0 if the proper config is not found, 2789352f7f91STakashi Iwai * or a negative error code 2790352f7f91STakashi Iwai */ 2791352f7f91STakashi Iwai int snd_hda_gen_parse_auto_config(struct hda_codec *codec, 2792352f7f91STakashi Iwai const hda_nid_t *ignore_nids) 2793352f7f91STakashi Iwai { 2794352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2795352f7f91STakashi Iwai struct auto_pin_cfg *cfg = &spec->autocfg; 2796352f7f91STakashi Iwai int err; 2797352f7f91STakashi Iwai 2798352f7f91STakashi Iwai err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids, 2799352f7f91STakashi Iwai spec->parse_flags); 2800352f7f91STakashi Iwai if (err < 0) 2801352f7f91STakashi Iwai return err; 2802352f7f91STakashi Iwai if (!cfg->line_outs) { 2803352f7f91STakashi Iwai if (cfg->dig_outs || cfg->dig_in_pin) { 2804352f7f91STakashi Iwai spec->multiout.max_channels = 2; 2805352f7f91STakashi Iwai spec->no_analog = 1; 2806352f7f91STakashi Iwai goto dig_only; 2807352f7f91STakashi Iwai } 2808352f7f91STakashi Iwai return 0; /* can't find valid BIOS pin config */ 2809352f7f91STakashi Iwai } 2810352f7f91STakashi Iwai 2811352f7f91STakashi Iwai if (!spec->no_primary_hp && 2812352f7f91STakashi Iwai cfg->line_out_type == AUTO_PIN_SPEAKER_OUT && 2813352f7f91STakashi Iwai cfg->line_outs <= cfg->hp_outs) { 2814352f7f91STakashi Iwai /* use HP as primary out */ 2815352f7f91STakashi Iwai cfg->speaker_outs = cfg->line_outs; 2816352f7f91STakashi Iwai memcpy(cfg->speaker_pins, cfg->line_out_pins, 2817352f7f91STakashi Iwai sizeof(cfg->speaker_pins)); 2818352f7f91STakashi Iwai cfg->line_outs = cfg->hp_outs; 2819352f7f91STakashi Iwai memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins)); 2820352f7f91STakashi Iwai cfg->hp_outs = 0; 2821352f7f91STakashi Iwai memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins)); 2822352f7f91STakashi Iwai cfg->line_out_type = AUTO_PIN_HP_OUT; 2823352f7f91STakashi Iwai } 2824352f7f91STakashi Iwai 2825352f7f91STakashi Iwai err = parse_output_paths(codec); 2826352f7f91STakashi Iwai if (err < 0) 2827352f7f91STakashi Iwai return err; 2828352f7f91STakashi Iwai err = create_multi_channel_mode(codec); 2829352f7f91STakashi Iwai if (err < 0) 2830352f7f91STakashi Iwai return err; 2831352f7f91STakashi Iwai err = create_multi_out_ctls(codec, cfg); 2832352f7f91STakashi Iwai if (err < 0) 2833352f7f91STakashi Iwai return err; 2834352f7f91STakashi Iwai err = create_hp_out_ctls(codec); 2835352f7f91STakashi Iwai if (err < 0) 2836352f7f91STakashi Iwai return err; 2837352f7f91STakashi Iwai err = create_speaker_out_ctls(codec); 2838352f7f91STakashi Iwai if (err < 0) 2839352f7f91STakashi Iwai return err; 2840352f7f91STakashi Iwai err = create_shared_input(codec); 2841352f7f91STakashi Iwai if (err < 0) 2842352f7f91STakashi Iwai return err; 2843352f7f91STakashi Iwai err = create_input_ctls(codec); 2844352f7f91STakashi Iwai if (err < 0) 2845352f7f91STakashi Iwai return err; 2846352f7f91STakashi Iwai 2847352f7f91STakashi Iwai /* check the multiple speaker pins */ 2848352f7f91STakashi Iwai if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) 2849352f7f91STakashi Iwai spec->const_channel_count = cfg->line_outs * 2; 2850352f7f91STakashi Iwai else 2851352f7f91STakashi Iwai spec->const_channel_count = cfg->speaker_outs * 2; 2852352f7f91STakashi Iwai 2853352f7f91STakashi Iwai if (spec->multi_ios > 0) 2854352f7f91STakashi Iwai spec->multiout.max_channels = max(spec->ext_channel_count, 2855352f7f91STakashi Iwai spec->const_channel_count); 2856352f7f91STakashi Iwai else 2857352f7f91STakashi Iwai spec->multiout.max_channels = spec->multiout.num_dacs * 2; 2858352f7f91STakashi Iwai 2859352f7f91STakashi Iwai err = check_auto_mute_availability(codec); 2860352f7f91STakashi Iwai if (err < 0) 2861352f7f91STakashi Iwai return err; 2862352f7f91STakashi Iwai 2863352f7f91STakashi Iwai err = check_dyn_adc_switch(codec); 2864352f7f91STakashi Iwai if (err < 0) 2865352f7f91STakashi Iwai return err; 2866352f7f91STakashi Iwai 2867352f7f91STakashi Iwai if (!spec->shared_mic_hp) { 2868352f7f91STakashi Iwai err = check_auto_mic_availability(codec); 2869352f7f91STakashi Iwai if (err < 0) 2870352f7f91STakashi Iwai return err; 2871352f7f91STakashi Iwai } 2872352f7f91STakashi Iwai 2873352f7f91STakashi Iwai err = create_capture_mixers(codec); 2874352f7f91STakashi Iwai if (err < 0) 2875352f7f91STakashi Iwai return err; 2876352f7f91STakashi Iwai 2877352f7f91STakashi Iwai err = parse_mic_boost(codec); 2878352f7f91STakashi Iwai if (err < 0) 2879352f7f91STakashi Iwai return err; 2880352f7f91STakashi Iwai 2881352f7f91STakashi Iwai dig_only: 2882352f7f91STakashi Iwai parse_digital(codec); 2883352f7f91STakashi Iwai 2884352f7f91STakashi Iwai return 1; 2885352f7f91STakashi Iwai } 2886352f7f91STakashi Iwai EXPORT_SYMBOL_HDA(snd_hda_gen_parse_auto_config); 2887352f7f91STakashi Iwai 2888352f7f91STakashi Iwai 2889352f7f91STakashi Iwai /* 2890352f7f91STakashi Iwai * Build control elements 2891352f7f91STakashi Iwai */ 2892352f7f91STakashi Iwai 2893352f7f91STakashi Iwai /* slave controls for virtual master */ 2894352f7f91STakashi Iwai static const char * const slave_pfxs[] = { 2895352f7f91STakashi Iwai "Front", "Surround", "Center", "LFE", "Side", 2896352f7f91STakashi Iwai "Headphone", "Speaker", "Mono", "Line Out", 2897352f7f91STakashi Iwai "CLFE", "Bass Speaker", "PCM", 2898352f7f91STakashi Iwai NULL, 2899352f7f91STakashi Iwai }; 2900352f7f91STakashi Iwai 2901352f7f91STakashi Iwai int snd_hda_gen_build_controls(struct hda_codec *codec) 2902352f7f91STakashi Iwai { 2903352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2904352f7f91STakashi Iwai int err; 2905352f7f91STakashi Iwai 2906352f7f91STakashi Iwai err = snd_hda_add_new_ctls(codec, spec->kctls.list); 2907352f7f91STakashi Iwai if (err < 0) 2908352f7f91STakashi Iwai return err; 2909352f7f91STakashi Iwai 2910352f7f91STakashi Iwai if (spec->multiout.dig_out_nid) { 2911352f7f91STakashi Iwai err = snd_hda_create_dig_out_ctls(codec, 2912352f7f91STakashi Iwai spec->multiout.dig_out_nid, 2913352f7f91STakashi Iwai spec->multiout.dig_out_nid, 2914352f7f91STakashi Iwai spec->pcm_rec[1].pcm_type); 2915352f7f91STakashi Iwai if (err < 0) 2916352f7f91STakashi Iwai return err; 2917352f7f91STakashi Iwai if (!spec->no_analog) { 2918352f7f91STakashi Iwai err = snd_hda_create_spdif_share_sw(codec, 2919352f7f91STakashi Iwai &spec->multiout); 2920352f7f91STakashi Iwai if (err < 0) 2921352f7f91STakashi Iwai return err; 2922352f7f91STakashi Iwai spec->multiout.share_spdif = 1; 2923352f7f91STakashi Iwai } 2924352f7f91STakashi Iwai } 2925352f7f91STakashi Iwai if (spec->dig_in_nid) { 2926352f7f91STakashi Iwai err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 2927352f7f91STakashi Iwai if (err < 0) 2928352f7f91STakashi Iwai return err; 2929352f7f91STakashi Iwai } 2930352f7f91STakashi Iwai 2931352f7f91STakashi Iwai /* if we have no master control, let's create it */ 2932352f7f91STakashi Iwai if (!spec->no_analog && 2933352f7f91STakashi Iwai !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 2934352f7f91STakashi Iwai unsigned int vmaster_tlv[4]; 2935352f7f91STakashi Iwai snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid, 2936352f7f91STakashi Iwai HDA_OUTPUT, vmaster_tlv); 2937352f7f91STakashi Iwai err = snd_hda_add_vmaster(codec, "Master Playback Volume", 2938352f7f91STakashi Iwai vmaster_tlv, slave_pfxs, 2939352f7f91STakashi Iwai "Playback Volume"); 2940352f7f91STakashi Iwai if (err < 0) 2941352f7f91STakashi Iwai return err; 2942352f7f91STakashi Iwai } 2943352f7f91STakashi Iwai if (!spec->no_analog && 2944352f7f91STakashi Iwai !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 2945352f7f91STakashi Iwai err = __snd_hda_add_vmaster(codec, "Master Playback Switch", 2946352f7f91STakashi Iwai NULL, slave_pfxs, 2947352f7f91STakashi Iwai "Playback Switch", 2948352f7f91STakashi Iwai true, &spec->vmaster_mute.sw_kctl); 2949352f7f91STakashi Iwai if (err < 0) 2950352f7f91STakashi Iwai return err; 2951352f7f91STakashi Iwai if (spec->vmaster_mute.hook) 2952352f7f91STakashi Iwai snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute, true); 2953352f7f91STakashi Iwai } 2954352f7f91STakashi Iwai 2955352f7f91STakashi Iwai free_kctls(spec); /* no longer needed */ 2956352f7f91STakashi Iwai 2957352f7f91STakashi Iwai if (spec->shared_mic_hp) { 2958352f7f91STakashi Iwai int err; 2959352f7f91STakashi Iwai int nid = spec->autocfg.inputs[1].pin; 2960352f7f91STakashi Iwai err = snd_hda_jack_add_kctl(codec, nid, "Headphone Mic", 0); 2961352f7f91STakashi Iwai if (err < 0) 2962352f7f91STakashi Iwai return err; 2963352f7f91STakashi Iwai err = snd_hda_jack_detect_enable(codec, nid, 0); 2964352f7f91STakashi Iwai if (err < 0) 2965352f7f91STakashi Iwai return err; 2966352f7f91STakashi Iwai } 2967352f7f91STakashi Iwai 2968352f7f91STakashi Iwai err = snd_hda_jack_add_kctls(codec, &spec->autocfg); 2969352f7f91STakashi Iwai if (err < 0) 2970352f7f91STakashi Iwai return err; 2971352f7f91STakashi Iwai 2972352f7f91STakashi Iwai return 0; 2973352f7f91STakashi Iwai } 2974352f7f91STakashi Iwai EXPORT_SYMBOL_HDA(snd_hda_gen_build_controls); 2975352f7f91STakashi Iwai 2976352f7f91STakashi Iwai 2977352f7f91STakashi Iwai /* 2978352f7f91STakashi Iwai * PCM definitions 2979352f7f91STakashi Iwai */ 2980352f7f91STakashi Iwai 2981352f7f91STakashi Iwai /* 2982352f7f91STakashi Iwai * Analog playback callbacks 2983352f7f91STakashi Iwai */ 2984352f7f91STakashi Iwai static int playback_pcm_open(struct hda_pcm_stream *hinfo, 2985352f7f91STakashi Iwai struct hda_codec *codec, 2986352f7f91STakashi Iwai struct snd_pcm_substream *substream) 2987352f7f91STakashi Iwai { 2988352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 2989352f7f91STakashi Iwai return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 2990352f7f91STakashi Iwai hinfo); 2991352f7f91STakashi Iwai } 2992352f7f91STakashi Iwai 2993352f7f91STakashi Iwai static int playback_pcm_prepare(struct hda_pcm_stream *hinfo, 299497ec558aSTakashi Iwai struct hda_codec *codec, 299597ec558aSTakashi Iwai unsigned int stream_tag, 299697ec558aSTakashi Iwai unsigned int format, 299797ec558aSTakashi Iwai struct snd_pcm_substream *substream) 299897ec558aSTakashi Iwai { 2999352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3000352f7f91STakashi Iwai return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, 3001352f7f91STakashi Iwai stream_tag, format, substream); 3002352f7f91STakashi Iwai } 300397ec558aSTakashi Iwai 3004352f7f91STakashi Iwai static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 3005352f7f91STakashi Iwai struct hda_codec *codec, 3006352f7f91STakashi Iwai struct snd_pcm_substream *substream) 3007352f7f91STakashi Iwai { 3008352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3009352f7f91STakashi Iwai return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 3010352f7f91STakashi Iwai } 3011352f7f91STakashi Iwai 3012352f7f91STakashi Iwai /* 3013352f7f91STakashi Iwai * Digital out 3014352f7f91STakashi Iwai */ 3015352f7f91STakashi Iwai static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 3016352f7f91STakashi Iwai struct hda_codec *codec, 3017352f7f91STakashi Iwai struct snd_pcm_substream *substream) 3018352f7f91STakashi Iwai { 3019352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3020352f7f91STakashi Iwai return snd_hda_multi_out_dig_open(codec, &spec->multiout); 3021352f7f91STakashi Iwai } 3022352f7f91STakashi Iwai 3023352f7f91STakashi Iwai static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 3024352f7f91STakashi Iwai struct hda_codec *codec, 3025352f7f91STakashi Iwai unsigned int stream_tag, 3026352f7f91STakashi Iwai unsigned int format, 3027352f7f91STakashi Iwai struct snd_pcm_substream *substream) 3028352f7f91STakashi Iwai { 3029352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3030352f7f91STakashi Iwai return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 3031352f7f91STakashi Iwai stream_tag, format, substream); 3032352f7f91STakashi Iwai } 3033352f7f91STakashi Iwai 3034352f7f91STakashi Iwai static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 3035352f7f91STakashi Iwai struct hda_codec *codec, 3036352f7f91STakashi Iwai struct snd_pcm_substream *substream) 3037352f7f91STakashi Iwai { 3038352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3039352f7f91STakashi Iwai return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout); 3040352f7f91STakashi Iwai } 3041352f7f91STakashi Iwai 3042352f7f91STakashi Iwai static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 3043352f7f91STakashi Iwai struct hda_codec *codec, 3044352f7f91STakashi Iwai struct snd_pcm_substream *substream) 3045352f7f91STakashi Iwai { 3046352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3047352f7f91STakashi Iwai return snd_hda_multi_out_dig_close(codec, &spec->multiout); 3048352f7f91STakashi Iwai } 3049352f7f91STakashi Iwai 3050352f7f91STakashi Iwai /* 3051352f7f91STakashi Iwai * Analog capture 3052352f7f91STakashi Iwai */ 3053352f7f91STakashi Iwai static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 3054352f7f91STakashi Iwai struct hda_codec *codec, 3055352f7f91STakashi Iwai unsigned int stream_tag, 3056352f7f91STakashi Iwai unsigned int format, 3057352f7f91STakashi Iwai struct snd_pcm_substream *substream) 3058352f7f91STakashi Iwai { 3059352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3060352f7f91STakashi Iwai 3061352f7f91STakashi Iwai snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1], 306297ec558aSTakashi Iwai stream_tag, 0, format); 306397ec558aSTakashi Iwai return 0; 306497ec558aSTakashi Iwai } 306597ec558aSTakashi Iwai 3066352f7f91STakashi Iwai static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 306797ec558aSTakashi Iwai struct hda_codec *codec, 306897ec558aSTakashi Iwai struct snd_pcm_substream *substream) 306997ec558aSTakashi Iwai { 3070352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 307197ec558aSTakashi Iwai 3072352f7f91STakashi Iwai snd_hda_codec_cleanup_stream(codec, 3073352f7f91STakashi Iwai spec->adc_nids[substream->number + 1]); 307497ec558aSTakashi Iwai return 0; 307597ec558aSTakashi Iwai } 307697ec558aSTakashi Iwai 3077352f7f91STakashi Iwai /* 3078352f7f91STakashi Iwai */ 3079352f7f91STakashi Iwai static const struct hda_pcm_stream pcm_analog_playback = { 3080352f7f91STakashi Iwai .substreams = 1, 3081352f7f91STakashi Iwai .channels_min = 2, 3082352f7f91STakashi Iwai .channels_max = 8, 3083352f7f91STakashi Iwai /* NID is set in build_pcms */ 3084352f7f91STakashi Iwai .ops = { 3085352f7f91STakashi Iwai .open = playback_pcm_open, 3086352f7f91STakashi Iwai .prepare = playback_pcm_prepare, 3087352f7f91STakashi Iwai .cleanup = playback_pcm_cleanup 3088352f7f91STakashi Iwai }, 3089352f7f91STakashi Iwai }; 3090352f7f91STakashi Iwai 3091352f7f91STakashi Iwai static const struct hda_pcm_stream pcm_analog_capture = { 3092352f7f91STakashi Iwai .substreams = 1, 3093352f7f91STakashi Iwai .channels_min = 2, 3094352f7f91STakashi Iwai .channels_max = 2, 3095352f7f91STakashi Iwai /* NID is set in build_pcms */ 3096352f7f91STakashi Iwai }; 3097352f7f91STakashi Iwai 3098352f7f91STakashi Iwai static const struct hda_pcm_stream pcm_analog_alt_playback = { 3099352f7f91STakashi Iwai .substreams = 1, 3100352f7f91STakashi Iwai .channels_min = 2, 3101352f7f91STakashi Iwai .channels_max = 2, 3102352f7f91STakashi Iwai /* NID is set in build_pcms */ 3103352f7f91STakashi Iwai }; 3104352f7f91STakashi Iwai 3105352f7f91STakashi Iwai static const struct hda_pcm_stream pcm_analog_alt_capture = { 3106352f7f91STakashi Iwai .substreams = 2, /* can be overridden */ 3107352f7f91STakashi Iwai .channels_min = 2, 3108352f7f91STakashi Iwai .channels_max = 2, 3109352f7f91STakashi Iwai /* NID is set in build_pcms */ 3110352f7f91STakashi Iwai .ops = { 3111352f7f91STakashi Iwai .prepare = alt_capture_pcm_prepare, 3112352f7f91STakashi Iwai .cleanup = alt_capture_pcm_cleanup 3113352f7f91STakashi Iwai }, 3114352f7f91STakashi Iwai }; 3115352f7f91STakashi Iwai 3116352f7f91STakashi Iwai static const struct hda_pcm_stream pcm_digital_playback = { 3117352f7f91STakashi Iwai .substreams = 1, 3118352f7f91STakashi Iwai .channels_min = 2, 3119352f7f91STakashi Iwai .channels_max = 2, 3120352f7f91STakashi Iwai /* NID is set in build_pcms */ 3121352f7f91STakashi Iwai .ops = { 3122352f7f91STakashi Iwai .open = dig_playback_pcm_open, 3123352f7f91STakashi Iwai .close = dig_playback_pcm_close, 3124352f7f91STakashi Iwai .prepare = dig_playback_pcm_prepare, 3125352f7f91STakashi Iwai .cleanup = dig_playback_pcm_cleanup 3126352f7f91STakashi Iwai }, 3127352f7f91STakashi Iwai }; 3128352f7f91STakashi Iwai 3129352f7f91STakashi Iwai static const struct hda_pcm_stream pcm_digital_capture = { 3130352f7f91STakashi Iwai .substreams = 1, 3131352f7f91STakashi Iwai .channels_min = 2, 3132352f7f91STakashi Iwai .channels_max = 2, 3133352f7f91STakashi Iwai /* NID is set in build_pcms */ 3134352f7f91STakashi Iwai }; 3135352f7f91STakashi Iwai 3136352f7f91STakashi Iwai /* Used by build_pcms to flag that a PCM has no playback stream */ 3137352f7f91STakashi Iwai static const struct hda_pcm_stream pcm_null_stream = { 3138352f7f91STakashi Iwai .substreams = 0, 3139352f7f91STakashi Iwai .channels_min = 0, 3140352f7f91STakashi Iwai .channels_max = 0, 3141352f7f91STakashi Iwai }; 3142352f7f91STakashi Iwai 3143352f7f91STakashi Iwai /* 3144352f7f91STakashi Iwai * dynamic changing ADC PCM streams 3145352f7f91STakashi Iwai */ 3146352f7f91STakashi Iwai static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur) 31471da177e4SLinus Torvalds { 3148352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3149352f7f91STakashi Iwai hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]]; 31501da177e4SLinus Torvalds 3151352f7f91STakashi Iwai if (spec->cur_adc && spec->cur_adc != new_adc) { 3152352f7f91STakashi Iwai /* stream is running, let's swap the current ADC */ 3153352f7f91STakashi Iwai __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1); 3154352f7f91STakashi Iwai spec->cur_adc = new_adc; 3155352f7f91STakashi Iwai snd_hda_codec_setup_stream(codec, new_adc, 3156352f7f91STakashi Iwai spec->cur_adc_stream_tag, 0, 3157352f7f91STakashi Iwai spec->cur_adc_format); 3158352f7f91STakashi Iwai return true; 3159352f7f91STakashi Iwai } 3160352f7f91STakashi Iwai return false; 3161352f7f91STakashi Iwai } 3162352f7f91STakashi Iwai 3163352f7f91STakashi Iwai /* analog capture with dynamic dual-adc changes */ 3164352f7f91STakashi Iwai static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 3165352f7f91STakashi Iwai struct hda_codec *codec, 3166352f7f91STakashi Iwai unsigned int stream_tag, 3167352f7f91STakashi Iwai unsigned int format, 3168352f7f91STakashi Iwai struct snd_pcm_substream *substream) 3169352f7f91STakashi Iwai { 3170352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3171352f7f91STakashi Iwai spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]]; 3172352f7f91STakashi Iwai spec->cur_adc_stream_tag = stream_tag; 3173352f7f91STakashi Iwai spec->cur_adc_format = format; 3174352f7f91STakashi Iwai snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format); 31751da177e4SLinus Torvalds return 0; 31761da177e4SLinus Torvalds } 31771da177e4SLinus Torvalds 3178352f7f91STakashi Iwai static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 3179352f7f91STakashi Iwai struct hda_codec *codec, 3180352f7f91STakashi Iwai struct snd_pcm_substream *substream) 3181352f7f91STakashi Iwai { 3182352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3183352f7f91STakashi Iwai snd_hda_codec_cleanup_stream(codec, spec->cur_adc); 3184352f7f91STakashi Iwai spec->cur_adc = 0; 3185352f7f91STakashi Iwai return 0; 3186352f7f91STakashi Iwai } 3187352f7f91STakashi Iwai 3188352f7f91STakashi Iwai static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = { 3189352f7f91STakashi Iwai .substreams = 1, 3190352f7f91STakashi Iwai .channels_min = 2, 3191352f7f91STakashi Iwai .channels_max = 2, 3192352f7f91STakashi Iwai .nid = 0, /* fill later */ 3193352f7f91STakashi Iwai .ops = { 3194352f7f91STakashi Iwai .prepare = dyn_adc_capture_pcm_prepare, 3195352f7f91STakashi Iwai .cleanup = dyn_adc_capture_pcm_cleanup 3196352f7f91STakashi Iwai }, 3197352f7f91STakashi Iwai }; 3198352f7f91STakashi Iwai 3199352f7f91STakashi Iwai /* build PCM streams based on the parsed results */ 3200352f7f91STakashi Iwai int snd_hda_gen_build_pcms(struct hda_codec *codec) 3201352f7f91STakashi Iwai { 3202352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3203352f7f91STakashi Iwai struct hda_pcm *info = spec->pcm_rec; 3204352f7f91STakashi Iwai const struct hda_pcm_stream *p; 3205352f7f91STakashi Iwai bool have_multi_adcs; 3206352f7f91STakashi Iwai int i; 3207352f7f91STakashi Iwai 32081da177e4SLinus Torvalds codec->num_pcms = 1; 32091da177e4SLinus Torvalds codec->pcm_info = info; 32101da177e4SLinus Torvalds 3211352f7f91STakashi Iwai if (spec->no_analog) 3212352f7f91STakashi Iwai goto skip_analog; 3213352f7f91STakashi Iwai 3214352f7f91STakashi Iwai snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog), 3215352f7f91STakashi Iwai "%s Analog", codec->chip_name); 3216352f7f91STakashi Iwai info->name = spec->stream_name_analog; 3217352f7f91STakashi Iwai 3218352f7f91STakashi Iwai if (spec->multiout.num_dacs > 0) { 3219352f7f91STakashi Iwai p = spec->stream_analog_playback; 3220352f7f91STakashi Iwai if (!p) 3221352f7f91STakashi Iwai p = &pcm_analog_playback; 3222352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p; 3223352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; 3224352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 3225352f7f91STakashi Iwai spec->multiout.max_channels; 3226352f7f91STakashi Iwai if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT && 3227352f7f91STakashi Iwai spec->autocfg.line_outs == 2) 3228352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap = 3229352f7f91STakashi Iwai snd_pcm_2_1_chmaps; 3230352f7f91STakashi Iwai } 3231352f7f91STakashi Iwai if (spec->num_adc_nids) { 3232352f7f91STakashi Iwai p = spec->stream_analog_capture; 3233352f7f91STakashi Iwai if (!p) { 3234352f7f91STakashi Iwai if (spec->dyn_adc_switch) 3235352f7f91STakashi Iwai p = &dyn_adc_pcm_analog_capture; 3236352f7f91STakashi Iwai else 3237352f7f91STakashi Iwai p = &pcm_analog_capture; 3238352f7f91STakashi Iwai } 3239352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p; 3240352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 3241352f7f91STakashi Iwai } 3242352f7f91STakashi Iwai 3243352f7f91STakashi Iwai if (spec->channel_mode) { 3244352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0; 3245352f7f91STakashi Iwai for (i = 0; i < spec->num_channel_mode; i++) { 3246352f7f91STakashi Iwai if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) { 3247352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels; 324897ec558aSTakashi Iwai } 32491da177e4SLinus Torvalds } 3250352f7f91STakashi Iwai } 3251352f7f91STakashi Iwai 3252352f7f91STakashi Iwai skip_analog: 3253352f7f91STakashi Iwai /* SPDIF for stream index #1 */ 3254352f7f91STakashi Iwai if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 3255352f7f91STakashi Iwai snprintf(spec->stream_name_digital, 3256352f7f91STakashi Iwai sizeof(spec->stream_name_digital), 3257352f7f91STakashi Iwai "%s Digital", codec->chip_name); 3258352f7f91STakashi Iwai codec->num_pcms = 2; 3259352f7f91STakashi Iwai codec->slave_dig_outs = spec->multiout.slave_dig_outs; 3260352f7f91STakashi Iwai info = spec->pcm_rec + 1; 3261352f7f91STakashi Iwai info->name = spec->stream_name_digital; 3262352f7f91STakashi Iwai if (spec->dig_out_type) 3263352f7f91STakashi Iwai info->pcm_type = spec->dig_out_type; 3264352f7f91STakashi Iwai else 3265352f7f91STakashi Iwai info->pcm_type = HDA_PCM_TYPE_SPDIF; 3266352f7f91STakashi Iwai if (spec->multiout.dig_out_nid) { 3267352f7f91STakashi Iwai p = spec->stream_digital_playback; 3268352f7f91STakashi Iwai if (!p) 3269352f7f91STakashi Iwai p = &pcm_digital_playback; 3270352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p; 3271352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 3272352f7f91STakashi Iwai } 3273352f7f91STakashi Iwai if (spec->dig_in_nid) { 3274352f7f91STakashi Iwai p = spec->stream_digital_capture; 3275352f7f91STakashi Iwai if (!p) 3276352f7f91STakashi Iwai p = &pcm_digital_capture; 3277352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p; 3278352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; 3279352f7f91STakashi Iwai } 3280352f7f91STakashi Iwai } 3281352f7f91STakashi Iwai 3282352f7f91STakashi Iwai if (spec->no_analog) 3283352f7f91STakashi Iwai return 0; 3284352f7f91STakashi Iwai 3285352f7f91STakashi Iwai /* If the use of more than one ADC is requested for the current 3286352f7f91STakashi Iwai * model, configure a second analog capture-only PCM. 3287352f7f91STakashi Iwai */ 3288352f7f91STakashi Iwai have_multi_adcs = (spec->num_adc_nids > 1) && 3289352f7f91STakashi Iwai !spec->dyn_adc_switch && !spec->auto_mic; 3290352f7f91STakashi Iwai /* Additional Analaog capture for index #2 */ 3291352f7f91STakashi Iwai if (spec->alt_dac_nid || have_multi_adcs) { 3292352f7f91STakashi Iwai codec->num_pcms = 3; 3293352f7f91STakashi Iwai info = spec->pcm_rec + 2; 3294352f7f91STakashi Iwai info->name = spec->stream_name_analog; 3295352f7f91STakashi Iwai if (spec->alt_dac_nid) { 3296352f7f91STakashi Iwai p = spec->stream_analog_alt_playback; 3297352f7f91STakashi Iwai if (!p) 3298352f7f91STakashi Iwai p = &pcm_analog_alt_playback; 3299352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p; 3300352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 3301352f7f91STakashi Iwai spec->alt_dac_nid; 3302352f7f91STakashi Iwai } else { 3303352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 3304352f7f91STakashi Iwai pcm_null_stream; 3305352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0; 3306352f7f91STakashi Iwai } 3307352f7f91STakashi Iwai if (have_multi_adcs) { 3308352f7f91STakashi Iwai p = spec->stream_analog_alt_capture; 3309352f7f91STakashi Iwai if (!p) 3310352f7f91STakashi Iwai p = &pcm_analog_alt_capture; 3311352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p; 3312352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 3313352f7f91STakashi Iwai spec->adc_nids[1]; 3314352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 3315352f7f91STakashi Iwai spec->num_adc_nids - 1; 3316352f7f91STakashi Iwai } else { 3317352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_CAPTURE] = 3318352f7f91STakashi Iwai pcm_null_stream; 3319352f7f91STakashi Iwai info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0; 3320352f7f91STakashi Iwai } 33211da177e4SLinus Torvalds } 33221da177e4SLinus Torvalds 33231da177e4SLinus Torvalds return 0; 33241da177e4SLinus Torvalds } 3325352f7f91STakashi Iwai EXPORT_SYMBOL_HDA(snd_hda_gen_build_pcms); 3326352f7f91STakashi Iwai 3327352f7f91STakashi Iwai 3328352f7f91STakashi Iwai /* 3329352f7f91STakashi Iwai * Standard auto-parser initializations 3330352f7f91STakashi Iwai */ 3331352f7f91STakashi Iwai 3332352f7f91STakashi Iwai /* configure the path from the given dac to the pin as the proper output */ 3333352f7f91STakashi Iwai static void set_output_and_unmute(struct hda_codec *codec, hda_nid_t pin, 3334352f7f91STakashi Iwai int pin_type, hda_nid_t dac) 3335352f7f91STakashi Iwai { 3336352f7f91STakashi Iwai struct nid_path *path; 3337352f7f91STakashi Iwai 3338352f7f91STakashi Iwai snd_hda_set_pin_ctl_cache(codec, pin, pin_type); 3339352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, dac, pin); 3340352f7f91STakashi Iwai if (!path) 3341352f7f91STakashi Iwai return; 3342352f7f91STakashi Iwai if (path->active) 3343352f7f91STakashi Iwai return; 3344352f7f91STakashi Iwai snd_hda_activate_path(codec, path, true, true); 3345352f7f91STakashi Iwai } 3346352f7f91STakashi Iwai 3347352f7f91STakashi Iwai /* initialize primary output paths */ 3348352f7f91STakashi Iwai static void init_multi_out(struct hda_codec *codec) 3349352f7f91STakashi Iwai { 3350352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3351352f7f91STakashi Iwai int pin_type; 3352352f7f91STakashi Iwai int i; 3353352f7f91STakashi Iwai 3354352f7f91STakashi Iwai if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT) 3355352f7f91STakashi Iwai pin_type = PIN_HP; 3356352f7f91STakashi Iwai else 3357352f7f91STakashi Iwai pin_type = PIN_OUT; 3358352f7f91STakashi Iwai 3359352f7f91STakashi Iwai for (i = 0; i <= HDA_SIDE; i++) { 3360352f7f91STakashi Iwai hda_nid_t nid = spec->autocfg.line_out_pins[i]; 3361352f7f91STakashi Iwai if (nid) 3362352f7f91STakashi Iwai set_output_and_unmute(codec, nid, pin_type, 3363352f7f91STakashi Iwai spec->multiout.dac_nids[i]); 3364352f7f91STakashi Iwai 3365352f7f91STakashi Iwai } 3366352f7f91STakashi Iwai } 3367352f7f91STakashi Iwai 3368352f7f91STakashi Iwai /* initialize hp and speaker paths */ 3369352f7f91STakashi Iwai static void init_extra_out(struct hda_codec *codec) 3370352f7f91STakashi Iwai { 3371352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3372352f7f91STakashi Iwai int i; 3373352f7f91STakashi Iwai hda_nid_t pin, dac; 3374352f7f91STakashi Iwai 3375352f7f91STakashi Iwai for (i = 0; i < spec->autocfg.hp_outs; i++) { 3376352f7f91STakashi Iwai if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT) 3377352f7f91STakashi Iwai break; 3378352f7f91STakashi Iwai pin = spec->autocfg.hp_pins[i]; 3379352f7f91STakashi Iwai if (!pin) 3380352f7f91STakashi Iwai break; 3381352f7f91STakashi Iwai dac = spec->multiout.hp_out_nid[i]; 3382352f7f91STakashi Iwai if (!dac) { 3383352f7f91STakashi Iwai if (i > 0 && spec->multiout.hp_out_nid[0]) 3384352f7f91STakashi Iwai dac = spec->multiout.hp_out_nid[0]; 3385352f7f91STakashi Iwai else 3386352f7f91STakashi Iwai dac = spec->multiout.dac_nids[0]; 3387352f7f91STakashi Iwai } 3388352f7f91STakashi Iwai set_output_and_unmute(codec, pin, PIN_HP, dac); 3389352f7f91STakashi Iwai } 3390352f7f91STakashi Iwai for (i = 0; i < spec->autocfg.speaker_outs; i++) { 3391352f7f91STakashi Iwai if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) 3392352f7f91STakashi Iwai break; 3393352f7f91STakashi Iwai pin = spec->autocfg.speaker_pins[i]; 3394352f7f91STakashi Iwai if (!pin) 3395352f7f91STakashi Iwai break; 3396352f7f91STakashi Iwai dac = spec->multiout.extra_out_nid[i]; 3397352f7f91STakashi Iwai if (!dac) { 3398352f7f91STakashi Iwai if (i > 0 && spec->multiout.extra_out_nid[0]) 3399352f7f91STakashi Iwai dac = spec->multiout.extra_out_nid[0]; 3400352f7f91STakashi Iwai else 3401352f7f91STakashi Iwai dac = spec->multiout.dac_nids[0]; 3402352f7f91STakashi Iwai } 3403352f7f91STakashi Iwai set_output_and_unmute(codec, pin, PIN_OUT, dac); 3404352f7f91STakashi Iwai } 3405352f7f91STakashi Iwai } 3406352f7f91STakashi Iwai 3407352f7f91STakashi Iwai /* initialize multi-io paths */ 3408352f7f91STakashi Iwai static void init_multi_io(struct hda_codec *codec) 3409352f7f91STakashi Iwai { 3410352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3411352f7f91STakashi Iwai int i; 3412352f7f91STakashi Iwai 3413352f7f91STakashi Iwai for (i = 0; i < spec->multi_ios; i++) { 3414352f7f91STakashi Iwai hda_nid_t pin = spec->multi_io[i].pin; 3415352f7f91STakashi Iwai struct nid_path *path; 3416352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, spec->multi_io[i].dac, pin); 3417352f7f91STakashi Iwai if (!path) 3418352f7f91STakashi Iwai continue; 3419352f7f91STakashi Iwai if (!spec->multi_io[i].ctl_in) 3420352f7f91STakashi Iwai spec->multi_io[i].ctl_in = 3421352f7f91STakashi Iwai snd_hda_codec_update_cache(codec, pin, 0, 3422352f7f91STakashi Iwai AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 3423352f7f91STakashi Iwai snd_hda_activate_path(codec, path, path->active, true); 3424352f7f91STakashi Iwai } 3425352f7f91STakashi Iwai } 3426352f7f91STakashi Iwai 3427352f7f91STakashi Iwai /* set up the input pin config, depending on the given auto-pin type */ 3428352f7f91STakashi Iwai static void set_input_pin(struct hda_codec *codec, hda_nid_t nid, 3429352f7f91STakashi Iwai int auto_pin_type) 3430352f7f91STakashi Iwai { 3431352f7f91STakashi Iwai unsigned int val = PIN_IN; 3432352f7f91STakashi Iwai if (auto_pin_type == AUTO_PIN_MIC) 3433352f7f91STakashi Iwai val |= snd_hda_get_default_vref(codec, nid); 3434352f7f91STakashi Iwai snd_hda_set_pin_ctl(codec, nid, val); 3435352f7f91STakashi Iwai } 3436352f7f91STakashi Iwai 3437352f7f91STakashi Iwai /* set up input pins and loopback paths */ 3438352f7f91STakashi Iwai static void init_analog_input(struct hda_codec *codec) 3439352f7f91STakashi Iwai { 3440352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3441352f7f91STakashi Iwai struct auto_pin_cfg *cfg = &spec->autocfg; 3442352f7f91STakashi Iwai int i; 3443352f7f91STakashi Iwai 3444352f7f91STakashi Iwai for (i = 0; i < cfg->num_inputs; i++) { 3445352f7f91STakashi Iwai hda_nid_t nid = cfg->inputs[i].pin; 3446352f7f91STakashi Iwai if (is_input_pin(codec, nid)) 3447352f7f91STakashi Iwai set_input_pin(codec, nid, cfg->inputs[i].type); 3448352f7f91STakashi Iwai 3449352f7f91STakashi Iwai /* init loopback inputs */ 3450352f7f91STakashi Iwai if (spec->mixer_nid) { 3451352f7f91STakashi Iwai struct nid_path *path; 3452352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, nid, spec->mixer_nid); 3453352f7f91STakashi Iwai if (path) 3454352f7f91STakashi Iwai snd_hda_activate_path(codec, path, 3455352f7f91STakashi Iwai path->active, false); 3456352f7f91STakashi Iwai } 3457352f7f91STakashi Iwai } 3458352f7f91STakashi Iwai } 3459352f7f91STakashi Iwai 3460352f7f91STakashi Iwai /* initialize ADC paths */ 3461352f7f91STakashi Iwai static void init_input_src(struct hda_codec *codec) 3462352f7f91STakashi Iwai { 3463352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3464352f7f91STakashi Iwai struct hda_input_mux *imux = &spec->input_mux; 3465352f7f91STakashi Iwai struct nid_path *path; 3466352f7f91STakashi Iwai int i, c, nums; 3467352f7f91STakashi Iwai 3468352f7f91STakashi Iwai if (spec->dyn_adc_switch) 3469352f7f91STakashi Iwai nums = 1; 3470352f7f91STakashi Iwai else 3471352f7f91STakashi Iwai nums = spec->num_adc_nids; 3472352f7f91STakashi Iwai 3473352f7f91STakashi Iwai for (c = 0; c < nums; c++) { 3474352f7f91STakashi Iwai for (i = 0; i < imux->num_items; i++) { 3475352f7f91STakashi Iwai path = snd_hda_get_nid_path(codec, spec->imux_pins[i], 3476352f7f91STakashi Iwai get_adc_nid(codec, c, i)); 3477352f7f91STakashi Iwai if (path) { 3478352f7f91STakashi Iwai bool active = path->active; 3479352f7f91STakashi Iwai if (i == spec->cur_mux[c]) 3480352f7f91STakashi Iwai active = true; 3481352f7f91STakashi Iwai snd_hda_activate_path(codec, path, active, false); 3482352f7f91STakashi Iwai } 3483352f7f91STakashi Iwai } 3484352f7f91STakashi Iwai } 3485352f7f91STakashi Iwai 3486352f7f91STakashi Iwai if (spec->shared_mic_hp) 3487352f7f91STakashi Iwai update_shared_mic_hp(codec, spec->cur_mux[0]); 3488352f7f91STakashi Iwai 3489352f7f91STakashi Iwai if (spec->cap_sync_hook) 3490352f7f91STakashi Iwai spec->cap_sync_hook(codec); 3491352f7f91STakashi Iwai } 3492352f7f91STakashi Iwai 3493352f7f91STakashi Iwai /* set right pin controls for digital I/O */ 3494352f7f91STakashi Iwai static void init_digital(struct hda_codec *codec) 3495352f7f91STakashi Iwai { 3496352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3497352f7f91STakashi Iwai int i; 3498352f7f91STakashi Iwai hda_nid_t pin; 3499352f7f91STakashi Iwai 3500352f7f91STakashi Iwai for (i = 0; i < spec->autocfg.dig_outs; i++) { 3501352f7f91STakashi Iwai pin = spec->autocfg.dig_out_pins[i]; 3502352f7f91STakashi Iwai if (!pin) 3503352f7f91STakashi Iwai continue; 3504352f7f91STakashi Iwai set_output_and_unmute(codec, pin, PIN_OUT, 0); 3505352f7f91STakashi Iwai } 3506352f7f91STakashi Iwai pin = spec->autocfg.dig_in_pin; 3507352f7f91STakashi Iwai if (pin) 3508352f7f91STakashi Iwai snd_hda_set_pin_ctl(codec, pin, PIN_IN); 3509352f7f91STakashi Iwai } 3510352f7f91STakashi Iwai 3511352f7f91STakashi Iwai int snd_hda_gen_init(struct hda_codec *codec) 3512352f7f91STakashi Iwai { 3513352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3514352f7f91STakashi Iwai 3515352f7f91STakashi Iwai if (spec->init_hook) 3516352f7f91STakashi Iwai spec->init_hook(codec); 3517352f7f91STakashi Iwai 3518352f7f91STakashi Iwai snd_hda_apply_verbs(codec); 3519352f7f91STakashi Iwai 3520352f7f91STakashi Iwai init_multi_out(codec); 3521352f7f91STakashi Iwai init_extra_out(codec); 3522352f7f91STakashi Iwai init_multi_io(codec); 3523352f7f91STakashi Iwai init_analog_input(codec); 3524352f7f91STakashi Iwai init_input_src(codec); 3525352f7f91STakashi Iwai init_digital(codec); 3526352f7f91STakashi Iwai 3527352f7f91STakashi Iwai /* call init functions of standard auto-mute helpers */ 3528352f7f91STakashi Iwai hp_automute(codec, NULL); 3529352f7f91STakashi Iwai line_automute(codec, NULL); 3530352f7f91STakashi Iwai mic_autoswitch(codec, NULL); 3531352f7f91STakashi Iwai 3532352f7f91STakashi Iwai if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook) 3533352f7f91STakashi Iwai snd_hda_sync_vmaster_hook(&spec->vmaster_mute); 3534352f7f91STakashi Iwai 3535352f7f91STakashi Iwai hda_call_check_power_status(codec, 0x01); 3536352f7f91STakashi Iwai return 0; 3537352f7f91STakashi Iwai } 3538352f7f91STakashi Iwai EXPORT_SYMBOL(snd_hda_gen_init); 3539352f7f91STakashi Iwai 3540352f7f91STakashi Iwai 3541352f7f91STakashi Iwai /* 3542352f7f91STakashi Iwai * the generic codec support 3543352f7f91STakashi Iwai */ 35441da177e4SLinus Torvalds 354583012a7cSTakashi Iwai #ifdef CONFIG_PM 3546cb53c626STakashi Iwai static int generic_check_power_status(struct hda_codec *codec, hda_nid_t nid) 3547cb53c626STakashi Iwai { 3548352f7f91STakashi Iwai struct hda_gen_spec *spec = codec->spec; 3549cb53c626STakashi Iwai return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 3550cb53c626STakashi Iwai } 3551cb53c626STakashi Iwai #endif 3552cb53c626STakashi Iwai 3553352f7f91STakashi Iwai static void generic_free(struct hda_codec *codec) 3554352f7f91STakashi Iwai { 3555352f7f91STakashi Iwai snd_hda_gen_spec_free(codec->spec); 3556352f7f91STakashi Iwai kfree(codec->spec); 3557352f7f91STakashi Iwai codec->spec = NULL; 3558352f7f91STakashi Iwai } 35591da177e4SLinus Torvalds 3560352f7f91STakashi Iwai static const struct hda_codec_ops generic_patch_ops = { 3561352f7f91STakashi Iwai .build_controls = snd_hda_gen_build_controls, 3562352f7f91STakashi Iwai .build_pcms = snd_hda_gen_build_pcms, 3563352f7f91STakashi Iwai .init = snd_hda_gen_init, 3564352f7f91STakashi Iwai .free = generic_free, 3565352f7f91STakashi Iwai .unsol_event = snd_hda_jack_unsol_event, 356683012a7cSTakashi Iwai #ifdef CONFIG_PM 3567cb53c626STakashi Iwai .check_power_status = generic_check_power_status, 3568cb53c626STakashi Iwai #endif 35691da177e4SLinus Torvalds }; 35701da177e4SLinus Torvalds 35711da177e4SLinus Torvalds int snd_hda_parse_generic_codec(struct hda_codec *codec) 35721da177e4SLinus Torvalds { 3573352f7f91STakashi Iwai struct hda_gen_spec *spec; 35741da177e4SLinus Torvalds int err; 35751da177e4SLinus Torvalds 3576e560d8d8STakashi Iwai spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3577352f7f91STakashi Iwai if (!spec) 35781da177e4SLinus Torvalds return -ENOMEM; 3579352f7f91STakashi Iwai snd_hda_gen_spec_init(spec); 35801da177e4SLinus Torvalds codec->spec = spec; 35811da177e4SLinus Torvalds 3582352f7f91STakashi Iwai err = snd_hda_gen_parse_auto_config(codec, NULL); 3583352f7f91STakashi Iwai if (err < 0) 35841da177e4SLinus Torvalds goto error; 35851da177e4SLinus Torvalds 35861da177e4SLinus Torvalds codec->patch_ops = generic_patch_ops; 35871da177e4SLinus Torvalds return 0; 35881da177e4SLinus Torvalds 35891da177e4SLinus Torvalds error: 3590352f7f91STakashi Iwai generic_free(codec); 35911da177e4SLinus Torvalds return err; 35921da177e4SLinus Torvalds } 35931289e9e8STakashi Iwai EXPORT_SYMBOL(snd_hda_parse_generic_codec); 3594