sound/pci/hda/hda_generic.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * Generic widget tree parser
   5  *
   6  * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
   7  *
   8  *  This driver is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This driver is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21  */
  22
  23 #include <sound/driver.h>
  24 #include <linux/init.h>
  25 #include <linux/slab.h>
  26 #include <linux/pci.h>
  27 #include <sound/core.h>
  28 #include "hda_codec.h"
  29 #include "hda_local.h"
  30
  31 /* widget node for parsing */
  32 struct hda_gnode {
  33         hda_nid_t nid;          /* NID of this widget */
  34         unsigned short nconns;  /* number of input connections */
  35         hda_nid_t *conn_list;
  36         hda_nid_t slist[2];     /* temporay list */
  37         unsigned int wid_caps;  /* widget capabilities */
  38         unsigned char type;     /* widget type */
  39         unsigned char pin_ctl;  /* pin controls */
  40         unsigned char checked;  /* the flag indicates that the node is already parsed */
  41         unsigned int pin_caps;  /* pin widget capabilities */
  42         unsigned int def_cfg;   /* default configuration */
  43         unsigned int amp_out_caps;      /* AMP out capabilities */
  44         unsigned int amp_in_caps;       /* AMP in capabilities */
  45         struct list_head list;
  46 };
  47
  48 /* patch-specific record */
  49 struct hda_gspec {
  50         struct hda_gnode *dac_node[2];  /* DAC node */
  51         struct hda_gnode *out_pin_node[2];      /* Output pin (Line-Out) node */
  52         struct hda_gnode *pcm_vol_node[2];      /* Node for PCM volume */
  53         unsigned int pcm_vol_index[2];  /* connection of PCM volume */
  54
  55         struct hda_gnode *adc_node;     /* ADC node */
  56         struct hda_gnode *cap_vol_node; /* Node for capture volume */
  57         unsigned int cur_cap_src;       /* current capture source */
  58         struct hda_input_mux input_mux;
  59         char cap_labels[HDA_MAX_NUM_INPUTS][16];
  60
  61         unsigned int def_amp_in_caps;
  62         unsigned int def_amp_out_caps;
  63
  64         struct hda_pcm pcm_rec;         /* PCM information */
  65
  66         struct list_head nid_list;      /* list of widgets */
  67 };
  68
  69 /*
  70  * retrieve the default device type from the default config value
  71  */
  72 #define defcfg_type(node) (((node)->def_cfg & AC_DEFCFG_DEVICE) >> \
  73                            AC_DEFCFG_DEVICE_SHIFT)
  74 #define defcfg_location(node) (((node)->def_cfg & AC_DEFCFG_LOCATION) >> \
  75                                AC_DEFCFG_LOCATION_SHIFT)
  76 #define defcfg_port_conn(node) (((node)->def_cfg & AC_DEFCFG_PORT_CONN) >> \
  77                                 AC_DEFCFG_PORT_CONN_SHIFT)
  78
  79 /*
  80  * destructor
  81  */
  82 static void snd_hda_generic_free(struct hda_codec *codec)
  83 {
  84         struct hda_gspec *spec = codec->spec;
  85         struct list_head *p, *n;
  86
  87         if (! spec)
  88                 return;
  89         /* free all widgets */
  90         list_for_each_safe(p, n, &spec->nid_list) {
  91                 struct hda_gnode *node = list_entry(p, struct hda_gnode, list);
  92                 if (node->conn_list != node->slist)
  93                         kfree(node->conn_list);
  94                 kfree(node);
  95         }
  96         kfree(spec);
  97 }
  98
  99
 100 /*
 101  * add a new widget node and read its attributes
 102  */
 103 static int add_new_node(struct hda_codec *codec, struct hda_gspec *spec, hda_nid_t nid)
 104 {
 105         struct hda_gnode *node;
 106         int nconns;
 107         hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
 108
 109         node = kzalloc(sizeof(*node), GFP_KERNEL);
 110         if (node == NULL)
 111                 return -ENOMEM;
 112         node->nid = nid;
 113         nconns = snd_hda_get_connections(codec, nid, conn_list,
 114                                          HDA_MAX_CONNECTIONS);
 115         if (nconns < 0) {
 116                 kfree(node);
 117                 return nconns;
 118         }
 119         if (nconns <= ARRAY_SIZE(node->slist))
 120                 node->conn_list = node->slist;
 121         else {
 122                 node->conn_list = kmalloc(sizeof(hda_nid_t) * nconns,
 123                                           GFP_KERNEL);
 124                 if (! node->conn_list) {
 125                         snd_printk(KERN_ERR "hda-generic: cannot malloc\n");
 126                         kfree(node);
 127                         return -ENOMEM;
 128                 }
 129         }
 130         memcpy(node->conn_list, conn_list, nconns);
 131         node->nconns = nconns;
 132         node->wid_caps = get_wcaps(codec, nid);
 133         node->type = (node->wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
 134
 135         if (node->type == AC_WID_PIN) {
 136                 node->pin_caps = snd_hda_param_read(codec, node->nid, AC_PAR_PIN_CAP);
 137                 node->pin_ctl = snd_hda_codec_read(codec, node->nid, 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 138                 node->def_cfg = snd_hda_codec_read(codec, node->nid, 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
 139         }
 140
 141         if (node->wid_caps & AC_WCAP_OUT_AMP) {
 142                 if (node->wid_caps & AC_WCAP_AMP_OVRD)
 143                         node->amp_out_caps = snd_hda_param_read(codec, node->nid, AC_PAR_AMP_OUT_CAP);
 144                 if (! node->amp_out_caps)
 145                         node->amp_out_caps = spec->def_amp_out_caps;
 146         }
 147         if (node->wid_caps & AC_WCAP_IN_AMP) {
 148                 if (node->wid_caps & AC_WCAP_AMP_OVRD)
 149                         node->amp_in_caps = snd_hda_param_read(codec, node->nid, AC_PAR_AMP_IN_CAP);
 150                 if (! node->amp_in_caps)
 151                         node->amp_in_caps = spec->def_amp_in_caps;
 152         }
 153         list_add_tail(&node->list, &spec->nid_list);
 154         return 0;
 155 }
 156
 157 /*
 158  * build the AFG subtree
 159  */
 160 static int build_afg_tree(struct hda_codec *codec)
 161 {
 162         struct hda_gspec *spec = codec->spec;
 163         int i, nodes, err;
 164         hda_nid_t nid;
 165
 166         snd_assert(spec, return -EINVAL);
 167
 168         spec->def_amp_out_caps = snd_hda_param_read(codec, codec->afg, AC_PAR_AMP_OUT_CAP);
 169         spec->def_amp_in_caps = snd_hda_param_read(codec, codec->afg, AC_PAR_AMP_IN_CAP);
 170
 171         nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid);
 172         if (! nid || nodes < 0) {
 173                 printk(KERN_ERR "Invalid AFG subtree\n");
 174                 return -EINVAL;
 175         }
 176
 177         /* parse all nodes belonging to the AFG */
 178         for (i = 0; i < nodes; i++, nid++) {
 179                 if ((err = add_new_node(codec, spec, nid)) < 0)
 180                         return err;
 181         }
 182
 183         return 0;
 184 }
 185
 186
 187 /*
 188  * look for the node record for the given NID
 189  */
 190 /* FIXME: should avoid the braindead linear search */
 191 static struct hda_gnode *hda_get_node(struct hda_gspec *spec, hda_nid_t nid)
 192 {
 193         struct list_head *p;
 194         struct hda_gnode *node;
 195
 196         list_for_each(p, &spec->nid_list) {
 197                 node = list_entry(p, struct hda_gnode, list);
 198                 if (node->nid == nid)
 199                         return node;
 200         }
 201         return NULL;
 202 }
 203
 204 /*
 205  * unmute (and set max vol) the output amplifier
 206  */
 207 static int unmute_output(struct hda_codec *codec, struct hda_gnode *node)
 208 {
 209         unsigned int val, ofs;
 210         snd_printdd("UNMUTE OUT: NID=0x%x\n", node->nid);
 211         val = (node->amp_out_caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
 212         ofs = (node->amp_out_caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
 213         if (val >= ofs)
 214                 val -= ofs;
 215         val |= AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT;
 216         val |= AC_AMP_SET_OUTPUT;
 217         return snd_hda_codec_write(codec, node->nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, val);
 218 }
 219
 220 /*
 221  * unmute (and set max vol) the input amplifier
 222  */
 223 static int unmute_input(struct hda_codec *codec, struct hda_gnode *node, unsigned int index)
 224 {
 225         unsigned int val, ofs;
 226         snd_printdd("UNMUTE IN: NID=0x%x IDX=0x%x\n", node->nid, index);
 227         val = (node->amp_in_caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
 228         ofs = (node->amp_in_caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
 229         if (val >= ofs)
 230                 val -= ofs;
 231         val |= AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT;
 232         val |= AC_AMP_SET_INPUT;
 233         // awk added - fixed to allow unmuting of indexed amps
 234         val |= index << AC_AMP_SET_INDEX_SHIFT;
 235         return snd_hda_codec_write(codec, node->nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, val);
 236 }
 237
 238 /*
 239  * select the input connection of the given node.
 240  */
 241 static int select_input_connection(struct hda_codec *codec, struct hda_gnode *node,
 242                                    unsigned int index)
 243 {
 244         snd_printdd("CONNECT: NID=0x%x IDX=0x%x\n", node->nid, index);
 245         return snd_hda_codec_write(codec, node->nid, 0, AC_VERB_SET_CONNECT_SEL, index);
 246 }
 247
 248 /*
 249  * clear checked flag of each node in the node list
 250  */
 251 static void clear_check_flags(struct hda_gspec *spec)
 252 {
 253         struct list_head *p;
 254         struct hda_gnode *node;
 255
 256         list_for_each(p, &spec->nid_list) {
 257                 node = list_entry(p, struct hda_gnode, list);
 258                 node->checked = 0;
 259         }
 260 }
 261
 262 /*
 263  * parse the output path recursively until reach to an audio output widget
 264  *
 265  * returns 0 if not found, 1 if found, or a negative error code.
 266  */
 267 static int parse_output_path(struct hda_codec *codec, struct hda_gspec *spec,
 268                              struct hda_gnode *node, int dac_idx)
 269 {
 270         int i, err;
 271         struct hda_gnode *child;
 272
 273         if (node->checked)
 274                 return 0;
 275
 276         node->checked = 1;
 277         if (node->type == AC_WID_AUD_OUT) {
 278                 if (node->wid_caps & AC_WCAP_DIGITAL) {
 279                         snd_printdd("Skip Digital OUT node %x\n", node->nid);
 280                         return 0;
 281                 }
 282                 snd_printdd("AUD_OUT found %x\n", node->nid);
 283                 if (spec->dac_node[dac_idx]) {
 284                         /* already DAC node is assigned, just unmute & connect */
 285                         return node == spec->dac_node[dac_idx];
 286                 }
 287                 spec->dac_node[dac_idx] = node;
 288                 if (node->wid_caps & AC_WCAP_OUT_AMP) {
 289                         spec->pcm_vol_node[dac_idx] = node;
 290                         spec->pcm_vol_index[dac_idx] = 0;
 291                 }
 292                 return 1; /* found */
 293         }
 294
 295         for (i = 0; i < node->nconns; i++) {
 296                 child = hda_get_node(spec, node->conn_list[i]);
 297                 if (! child)
 298                         continue;
 299                 err = parse_output_path(codec, spec, child, dac_idx);
 300                 if (err < 0)
 301                         return err;
 302                 else if (err > 0) {
 303                         /* found one,
 304                          * select the path, unmute both input and output
 305                          */
 306                         if (node->nconns > 1)
 307                                 select_input_connection(codec, node, i);
 308                         unmute_input(codec, node, i);
 309                         unmute_output(codec, node);
 310                         if (! spec->pcm_vol_node[dac_idx]) {
 311                                 if (node->wid_caps & AC_WCAP_IN_AMP) {
 312                                         spec->pcm_vol_node[dac_idx] = node;
 313                                         spec->pcm_vol_index[dac_idx] = i;
 314                                 } else if (node->wid_caps & AC_WCAP_OUT_AMP) {
 315                                         spec->pcm_vol_node[dac_idx] = node;
 316                                         spec->pcm_vol_index[dac_idx] = 0;
 317                                 }
 318                         }
 319                         return 1;
 320                 }
 321         }
 322         return 0;
 323 }
 324
 325 /*
 326  * Look for the output PIN widget with the given jack type
 327  * and parse the output path to that PIN.
 328  *
 329  * Returns the PIN node when the path to DAC is established.
 330  */
 331 static struct hda_gnode *parse_output_jack(struct hda_codec *codec,
 332                                            struct hda_gspec *spec,
 333                                            int jack_type)
 334 {
 335         struct list_head *p;
 336         struct hda_gnode *node;
 337         int err;
 338
 339         list_for_each(p, &spec->nid_list) {
 340                 node = list_entry(p, struct hda_gnode, list);
 341                 if (node->type != AC_WID_PIN)
 342                         continue;
 343                 /* output capable? */
 344                 if (! (node->pin_caps & AC_PINCAP_OUT))
 345                         continue;
 346                 if (defcfg_port_conn(node) == AC_JACK_PORT_NONE)
 347                         continue; /* unconnected */
 348                 if (jack_type >= 0) {
 349                         if (jack_type != defcfg_type(node))
 350                                 continue;
 351                         if (node->wid_caps & AC_WCAP_DIGITAL)
 352                                 continue; /* skip SPDIF */
 353                 } else {
 354                         /* output as default? */
 355                         if (! (node->pin_ctl & AC_PINCTL_OUT_EN))
 356                                 continue;
 357                 }
 358                 clear_check_flags(spec);
 359                 err = parse_output_path(codec, spec, node, 0);
 360                 if (err < 0)
 361                         return NULL;
 362                 if (! err && spec->out_pin_node[0]) {
 363                         err = parse_output_path(codec, spec, node, 1);
 364                         if (err < 0)
 365                                 return NULL;
 366                 }
 367                 if (err > 0) {
 368                         /* unmute the PIN output */
 369                         unmute_output(codec, node);
 370                         /* set PIN-Out enable */
 371                         snd_hda_codec_write(codec, node->nid, 0,
 372                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
 373                                             AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
 374                         return node;
 375                 }
 376         }
 377         return NULL;
 378 }
 379
 380
 381 /*
 382  * parse outputs
 383  */
 384 static int parse_output(struct hda_codec *codec)
 385 {
 386         struct hda_gspec *spec = codec->spec;
 387         struct hda_gnode *node;
 388
 389         /*
 390          * Look for the output PIN widget
 391          */
 392         /* first, look for the line-out pin */
 393         node = parse_output_jack(codec, spec, AC_JACK_LINE_OUT);
 394         if (node) /* found, remember the PIN node */
 395                 spec->out_pin_node[0] = node;
 396         else {
 397                 /* if no line-out is found, try speaker out */
 398                 node = parse_output_jack(codec, spec, AC_JACK_SPEAKER);
 399                 if (node)
 400                         spec->out_pin_node[0] = node;
 401         }
 402         /* look for the HP-out pin */
 403         node = parse_output_jack(codec, spec, AC_JACK_HP_OUT);
 404         if (node) {
 405                 if (! spec->out_pin_node[0])
 406                         spec->out_pin_node[0] = node;
 407                 else
 408                         spec->out_pin_node[1] = node;
 409         }
 410
 411         if (! spec->out_pin_node[0]) {
 412                 /* no line-out or HP pins found,
 413                  * then choose for the first output pin
 414                  */
 415                 spec->out_pin_node[0] = parse_output_jack(codec, spec, -1);
 416                 if (! spec->out_pin_node[0])
 417                         snd_printd("hda_generic: no proper output path found\n");
 418         }
 419
 420         return 0;
 421 }
 422
 423 /*
 424  * input MUX
 425  */
 426
 427 /* control callbacks */
 428 static int capture_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 429 {
 430         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 431         struct hda_gspec *spec = codec->spec;
 432         return snd_hda_input_mux_info(&spec->input_mux, uinfo);
 433 }
 434
 435 static int capture_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 436 {
 437         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 438         struct hda_gspec *spec = codec->spec;
 439
 440         ucontrol->value.enumerated.item[0] = spec->cur_cap_src;
 441         return 0;
 442 }
 443
 444 static int capture_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 445 {
 446         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 447         struct hda_gspec *spec = codec->spec;
 448         return snd_hda_input_mux_put(codec, &spec->input_mux, ucontrol,
 449                                      spec->adc_node->nid, &spec->cur_cap_src);
 450 }
 451
 452 /*
 453  * return the string name of the given input PIN widget
 454  */
 455 static const char *get_input_type(struct hda_gnode *node, unsigned int *pinctl)
 456 {
 457         unsigned int location = defcfg_location(node);
 458         switch (defcfg_type(node)) {
 459         case AC_JACK_LINE_IN:
 460                 if ((location & 0x0f) == AC_JACK_LOC_FRONT)
 461                         return "Front Line";
 462                 return "Line";
 463         case AC_JACK_CD:
 464                 if (pinctl)
 465                         *pinctl |= AC_PINCTL_VREF_GRD;
 466                 return "CD";
 467         case AC_JACK_AUX:
 468                 if ((location & 0x0f) == AC_JACK_LOC_FRONT)
 469                         return "Front Aux";
 470                 return "Aux";
 471         case AC_JACK_MIC_IN:
 472                 if ((location & 0x0f) == AC_JACK_LOC_FRONT)
 473                         return "Front Mic";
 474                 return "Mic";
 475         case AC_JACK_SPDIF_IN:
 476                 return "SPDIF";
 477         case AC_JACK_DIG_OTHER_IN:
 478                 return "Digital";
 479         }
 480         return NULL;
 481 }
 482
 483 /*
 484  * parse the nodes recursively until reach to the input PIN
 485  *
 486  * returns 0 if not found, 1 if found, or a negative error code.
 487  */
 488 static int parse_adc_sub_nodes(struct hda_codec *codec, struct hda_gspec *spec,
 489                                struct hda_gnode *node)
 490 {
 491         int i, err;
 492         unsigned int pinctl;
 493         char *label;
 494         const char *type;
 495
 496         if (node->checked)
 497                 return 0;
 498
 499         node->checked = 1;
 500         if (node->type != AC_WID_PIN) {
 501                 for (i = 0; i < node->nconns; i++) {
 502                         struct hda_gnode *child;
 503                         child = hda_get_node(spec, node->conn_list[i]);
 504                         if (! child)
 505                                 continue;
 506                         err = parse_adc_sub_nodes(codec, spec, child);
 507                         if (err < 0)
 508                                 return err;
 509                         if (err > 0) {
 510                                 /* found one,
 511                                  * select the path, unmute both input and output
 512                                  */
 513                                 if (node->nconns > 1)
 514                                         select_input_connection(codec, node, i);
 515                                 unmute_input(codec, node, i);
 516                                 unmute_output(codec, node);
 517                                 return err;
 518                         }
 519                 }
 520                 return 0;
 521         }
 522
 523         /* input capable? */
 524         if (! (node->pin_caps & AC_PINCAP_IN))
 525                 return 0;
 526
 527         if (defcfg_port_conn(node) == AC_JACK_PORT_NONE)
 528                 return 0; /* unconnected */
 529
 530         if (node->wid_caps & AC_WCAP_DIGITAL)
 531                 return 0; /* skip SPDIF */
 532
 533         if (spec->input_mux.num_items >= HDA_MAX_NUM_INPUTS) {
 534                 snd_printk(KERN_ERR "hda_generic: Too many items for capture\n");
 535                 return -EINVAL;
 536         }
 537
 538         pinctl = AC_PINCTL_IN_EN;
 539         /* create a proper capture source label */
 540         type = get_input_type(node, &pinctl);
 541         if (! type) {
 542                 /* input as default? */
 543                 if (! (node->pin_ctl & AC_PINCTL_IN_EN))
 544                         return 0;
 545                 type = "Input";
 546         }
 547         label = spec->cap_labels[spec->input_mux.num_items];
 548         strcpy(label, type);
 549         spec->input_mux.items[spec->input_mux.num_items].label = label;
 550
 551         /* unmute the PIN external input */
 552         unmute_input(codec, node, 0); /* index = 0? */
 553         /* set PIN-In enable */
 554         snd_hda_codec_write(codec, node->nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pinctl);
 555
 556         return 1; /* found */
 557 }
 558
 559 /*
 560  * parse input
 561  */
 562 static int parse_input_path(struct hda_codec *codec, struct hda_gnode *adc_node)
 563 {
 564         struct hda_gspec *spec = codec->spec;
 565         struct hda_gnode *node;
 566         int i, err;
 567
 568         snd_printdd("AUD_IN = %x\n", adc_node->nid);
 569         clear_check_flags(spec);
 570
 571         // awk added - fixed no recording due to muted widget
 572         unmute_input(codec, adc_node, 0);
 573
 574         /*
 575          * check each connection of the ADC
 576          * if it reaches to a proper input PIN, add the path as the
 577          * input path.
 578          */
 579         for (i = 0; i < adc_node->nconns; i++) {
 580                 node = hda_get_node(spec, adc_node->conn_list[i]);
 581                 if (! node)
 582                         continue;
 583                 err = parse_adc_sub_nodes(codec, spec, node);
 584                 if (err < 0)
 585                         return err;
 586                 else if (err > 0) {
 587                         struct hda_input_mux_item *csrc = &spec->input_mux.items[spec->input_mux.num_items];
 588                         char *buf = spec->cap_labels[spec->input_mux.num_items];
 589                         int ocap;
 590                         for (ocap = 0; ocap < spec->input_mux.num_items; ocap++) {
 591                                 if (! strcmp(buf, spec->cap_labels[ocap])) {
 592                                         /* same label already exists,
 593                                          * put the index number to be unique
 594                                          */
 595                                         sprintf(buf, "%s %d", spec->cap_labels[ocap],
 596                                                 spec->input_mux.num_items);
 597                                 }
 598                         }
 599                         csrc->index = i;
 600                         spec->input_mux.num_items++;
 601                 }
 602         }
 603
 604         if (! spec->input_mux.num_items)
 605                 return 0; /* no input path found... */
 606
 607         snd_printdd("[Capture Source] NID=0x%x, #SRC=%d\n", adc_node->nid, spec->input_mux.num_items);
 608         for (i = 0; i < spec->input_mux.num_items; i++)
 609                 snd_printdd("  [%s] IDX=0x%x\n", spec->input_mux.items[i].label,
 610                             spec->input_mux.items[i].index);
 611
 612         spec->adc_node = adc_node;
 613         return 1;
 614 }
 615
 616 /*
 617  * parse input
 618  */
 619 static int parse_input(struct hda_codec *codec)
 620 {
 621         struct hda_gspec *spec = codec->spec;
 622         struct list_head *p;
 623         struct hda_gnode *node;
 624         int err;
 625
 626         /*
 627          * At first we look for an audio input widget.
 628          * If it reaches to certain input PINs, we take it as the
 629          * input path.
 630          */
 631         list_for_each(p, &spec->nid_list) {
 632                 node = list_entry(p, struct hda_gnode, list);
 633                 if (node->wid_caps & AC_WCAP_DIGITAL)
 634                         continue; /* skip SPDIF */
 635                 if (node->type == AC_WID_AUD_IN) {
 636                         err = parse_input_path(codec, node);
 637                         if (err < 0)
 638                                 return err;
 639                         else if (err > 0)
 640                                 return 0;
 641                 }
 642         }
 643         snd_printd("hda_generic: no proper input path found\n");
 644         return 0;
 645 }
 646
 647 /*
 648  * create mixer controls if possible
 649  */
 650 #define DIR_OUT         0x1
 651 #define DIR_IN          0x2
 652
 653 static int create_mixer(struct hda_codec *codec, struct hda_gnode *node,
 654                         unsigned int index, const char *type, const char *dir_sfx)
 655 {
 656         char name[32];
 657         int err;
 658         int created = 0;
 659         struct snd_kcontrol_new knew;
 660
 661         if (type)
 662                 sprintf(name, "%s %s Switch", type, dir_sfx);
 663         else
 664                 sprintf(name, "%s Switch", dir_sfx);
 665         if ((node->wid_caps & AC_WCAP_IN_AMP) &&
 666             (node->amp_in_caps & AC_AMPCAP_MUTE)) {
 667                 knew = (struct snd_kcontrol_new)HDA_CODEC_MUTE(name, node->nid, index, HDA_INPUT);
 668                 snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name, node->nid, index);
 669                 if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&knew, codec))) < 0)
 670                         return err;
 671                 created = 1;
 672         } else if ((node->wid_caps & AC_WCAP_OUT_AMP) &&
 673                    (node->amp_out_caps & AC_AMPCAP_MUTE)) {
 674                 knew = (struct snd_kcontrol_new)HDA_CODEC_MUTE(name, node->nid, 0, HDA_OUTPUT);
 675                 snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name, node->nid);
 676                 if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&knew, codec))) < 0)
 677                         return err;
 678                 created = 1;
 679         }
 680
 681         if (type)
 682                 sprintf(name, "%s %s Volume", type, dir_sfx);
 683         else
 684                 sprintf(name, "%s Volume", dir_sfx);
 685         if ((node->wid_caps & AC_WCAP_IN_AMP) &&
 686             (node->amp_in_caps & AC_AMPCAP_NUM_STEPS)) {
 687                 knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, index, HDA_INPUT);
 688                 snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name, node->nid, index);
 689                 if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&knew, codec))) < 0)
 690                         return err;
 691                 created = 1;
 692         } else if ((node->wid_caps & AC_WCAP_OUT_AMP) &&
 693                    (node->amp_out_caps & AC_AMPCAP_NUM_STEPS)) {
 694                 knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, 0, HDA_OUTPUT);
 695                 snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name, node->nid);
 696                 if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&knew, codec))) < 0)
 697                         return err;
 698                 created = 1;
 699         }
 700
 701         return created;
 702 }
 703
 704 /*
 705  * check whether the controls with the given name and direction suffix already exist
 706  */
 707 static int check_existing_control(struct hda_codec *codec, const char *type, const char *dir)
 708 {
 709         struct snd_ctl_elem_id id;
 710         memset(&id, 0, sizeof(id));
 711         sprintf(id.name, "%s %s Volume", type, dir);
 712         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 713         if (snd_ctl_find_id(codec->bus->card, &id))
 714                 return 1;
 715         sprintf(id.name, "%s %s Switch", type, dir);
 716         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 717         if (snd_ctl_find_id(codec->bus->card, &id))
 718                 return 1;
 719         return 0;
 720 }
 721
 722 /*
 723  * build output mixer controls
 724  */
 725 static int build_output_controls(struct hda_codec *codec)
 726 {
 727         struct hda_gspec *spec = codec->spec;
 728         static const char *types[2] = { "Master", "Headphone" };
 729         int i, err;
 730
 731         for (i = 0; i < 2 && spec->pcm_vol_node[i]; i++) {
 732                 err = create_mixer(codec, spec->pcm_vol_node[i],
 733                                    spec->pcm_vol_index[i],
 734                                    types[i], "Playback");
 735                 if (err < 0)
 736                         return err;
 737         }
 738         return 0;
 739 }
 740
 741 /* create capture volume/switch */
 742 static int build_input_controls(struct hda_codec *codec)
 743 {
 744         struct hda_gspec *spec = codec->spec;
 745         struct hda_gnode *adc_node = spec->adc_node;
 746         int err;
 747
 748         if (! adc_node)
 749                 return 0; /* not found */
 750
 751         /* create capture volume and switch controls if the ADC has an amp */
 752         err = create_mixer(codec, adc_node, 0, NULL, "Capture");
 753
 754         /* create input MUX if multiple sources are available */
 755         if (spec->input_mux.num_items > 1) {
 756                 static struct snd_kcontrol_new cap_sel = {
 757                         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 758                         .name = "Capture Source",
 759                         .info = capture_source_info,
 760                         .get = capture_source_get,
 761                         .put = capture_source_put,
 762                 };
 763                 if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&cap_sel, codec))) < 0)
 764                         return err;
 765                 spec->cur_cap_src = 0;
 766                 select_input_connection(codec, adc_node, spec->input_mux.items[0].index);
 767         }
 768         return 0;
 769 }
 770
 771
 772 /*
 773  * parse the nodes recursively until reach to the output PIN.
 774  *
 775  * returns 0 - if not found,
 776  *         1 - if found, but no mixer is created
 777  *         2 - if found and mixer was already created, (just skip)
 778  *         a negative error code
 779  */
 780 static int parse_loopback_path(struct hda_codec *codec, struct hda_gspec *spec,
 781                                struct hda_gnode *node, struct hda_gnode *dest_node,
 782                                const char *type)
 783 {
 784         int i, err;
 785
 786         if (node->checked)
 787                 return 0;
 788
 789         node->checked = 1;
 790         if (node == dest_node) {
 791                 /* loopback connection found */
 792                 return 1;
 793         }
 794
 795         for (i = 0; i < node->nconns; i++) {
 796                 struct hda_gnode *child = hda_get_node(spec, node->conn_list[i]);
 797                 if (! child)
 798                         continue;
 799                 err = parse_loopback_path(codec, spec, child, dest_node, type);
 800                 if (err < 0)
 801                         return err;
 802                 else if (err >= 1) {
 803                         if (err == 1) {
 804                                 err = create_mixer(codec, node, i, type, "Playback");
 805                                 if (err < 0)
 806                                         return err;
 807                                 if (err > 0)
 808                                         return 2; /* ok, created */
 809                                 /* not created, maybe in the lower path */
 810                                 err = 1;
 811                         }
 812                         /* connect and unmute */
 813                         if (node->nconns > 1)
 814                                 select_input_connection(codec, node, i);
 815                         unmute_input(codec, node, i);
 816                         unmute_output(codec, node);
 817                         return err;
 818                 }
 819         }
 820         return 0;
 821 }
 822
 823 /*
 824  * parse the tree and build the loopback controls
 825  */
 826 static int build_loopback_controls(struct hda_codec *codec)
 827 {
 828         struct hda_gspec *spec = codec->spec;
 829         struct list_head *p;
 830         struct hda_gnode *node;
 831         int err;
 832         const char *type;
 833
 834         if (! spec->out_pin_node[0])
 835                 return 0;
 836
 837         list_for_each(p, &spec->nid_list) {
 838                 node = list_entry(p, struct hda_gnode, list);
 839                 if (node->type != AC_WID_PIN)
 840                         continue;
 841                 /* input capable? */
 842                 if (! (node->pin_caps & AC_PINCAP_IN))
 843                         return 0;
 844                 type = get_input_type(node, NULL);
 845                 if (type) {
 846                         if (check_existing_control(codec, type, "Playback"))
 847                                 continue;
 848                         clear_check_flags(spec);
 849                         err = parse_loopback_path(codec, spec,
 850                                                   spec->out_pin_node[0],
 851                                                   node, type);
 852                         if (err < 0)
 853                                 return err;
 854                         if (! err)
 855                                 continue;
 856                 }
 857         }
 858         return 0;
 859 }
 860
 861 /*
 862  * build mixer controls
 863  */
 864 static int build_generic_controls(struct hda_codec *codec)
 865 {
 866         int err;
 867
 868         if ((err = build_input_controls(codec)) < 0 ||
 869             (err = build_output_controls(codec)) < 0 ||
 870             (err = build_loopback_controls(codec)) < 0)
 871                 return err;
 872
 873         return 0;
 874 }
 875
 876 /*
 877  * PCM
 878  */
 879 static struct hda_pcm_stream generic_pcm_playback = {
 880         .substreams = 1,
 881         .channels_min = 2,
 882         .channels_max = 2,
 883 };
 884
 885 static int generic_pcm2_prepare(struct hda_pcm_stream *hinfo,
 886                                 struct hda_codec *codec,
 887                                 unsigned int stream_tag,
 888                                 unsigned int format,
 889                                 struct snd_pcm_substream *substream)
 890 {
 891         struct hda_gspec *spec = codec->spec;
 892
 893         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
 894         snd_hda_codec_setup_stream(codec, spec->dac_node[1]->nid,
 895                                    stream_tag, 0, format);
 896         return 0;
 897 }
 898
 899 static int generic_pcm2_cleanup(struct hda_pcm_stream *hinfo,
 900                                 struct hda_codec *codec,
 901                                 struct snd_pcm_substream *substream)
 902 {
 903         struct hda_gspec *spec = codec->spec;
 904
 905         snd_hda_codec_setup_stream(codec, hinfo->nid, 0, 0, 0);
 906         snd_hda_codec_setup_stream(codec, spec->dac_node[1]->nid, 0, 0, 0);
 907         return 0;
 908 }
 909
 910 static int build_generic_pcms(struct hda_codec *codec)
 911 {
 912         struct hda_gspec *spec = codec->spec;
 913         struct hda_pcm *info = &spec->pcm_rec;
 914
 915         if (! spec->dac_node[0] && ! spec->adc_node) {
 916                 snd_printd("hda_generic: no PCM found\n");
 917                 return 0;
 918         }
 919
 920         codec->num_pcms = 1;
 921         codec->pcm_info = info;
 922
 923         info->name = "HDA Generic";
 924         if (spec->dac_node[0]) {
 925                 info->stream[0] = generic_pcm_playback;
 926                 info->stream[0].nid = spec->dac_node[0]->nid;
 927                 if (spec->dac_node[1]) {
 928                         info->stream[0].ops.prepare = generic_pcm2_prepare;
 929                         info->stream[0].ops.cleanup = generic_pcm2_cleanup;
 930                 }
 931         }
 932         if (spec->adc_node) {
 933                 info->stream[1] = generic_pcm_playback;
 934                 info->stream[1].nid = spec->adc_node->nid;
 935         }
 936
 937         return 0;
 938 }
 939
 940
 941 /*
 942  */
 943 static struct hda_codec_ops generic_patch_ops = {
 944         .build_controls = build_generic_controls,
 945         .build_pcms = build_generic_pcms,
 946         .free = snd_hda_generic_free,
 947 };
 948
 949 /*
 950  * the generic parser
 951  */
 952 int snd_hda_parse_generic_codec(struct hda_codec *codec)
 953 {
 954         struct hda_gspec *spec;
 955         int err;
 956
 957         if(!codec->afg)
 958                 return 0;
 959
 960         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
 961         if (spec == NULL) {
 962                 printk(KERN_ERR "hda_generic: can't allocate spec\n");
 963                 return -ENOMEM;
 964         }
 965         codec->spec = spec;
 966         INIT_LIST_HEAD(&spec->nid_list);
 967
 968         if ((err = build_afg_tree(codec)) < 0)
 969                 goto error;
 970
 971         if ((err = parse_input(codec)) < 0 ||
 972             (err = parse_output(codec)) < 0)
 973                 goto error;
 974
 975         codec->patch_ops = generic_patch_ops;
 976
 977         return 0;
 978
 979  error:
 980         snd_hda_generic_free(codec);
 981         return err;
 982 }