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