2 * Universal Interface for Intel High Definition Audio Codec
4 * Generic widget tree parser
6 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
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.
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.
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
23 #include <sound/driver.h>
24 #include <linux/init.h>
25 #include <linux/slab.h>
26 #include <sound/core.h>
27 #include "hda_codec.h"
28 #include "hda_local.h"
30 /* widget node for parsing */
32 hda_nid_t nid
; /* NID of this widget */
33 unsigned short nconns
; /* number of input connections */
35 hda_nid_t slist
[2]; /* temporay list */
36 unsigned int wid_caps
; /* widget capabilities */
37 unsigned char type
; /* widget type */
38 unsigned char pin_ctl
; /* pin controls */
39 unsigned char checked
; /* the flag indicates that the node is already parsed */
40 unsigned int pin_caps
; /* pin widget capabilities */
41 unsigned int def_cfg
; /* default configuration */
42 unsigned int amp_out_caps
; /* AMP out capabilities */
43 unsigned int amp_in_caps
; /* AMP in capabilities */
44 struct list_head list
;
47 /* patch-specific record */
49 #define MAX_PCM_VOLS 2
51 struct hda_gnode
*node
; /* Node for PCM volume */
52 unsigned int index
; /* connection of PCM volume */
56 struct hda_gnode
*dac_node
[2]; /* DAC node */
57 struct hda_gnode
*out_pin_node
[2]; /* Output pin (Line-Out) node */
58 struct pcm_vol pcm_vol
[MAX_PCM_VOLS
]; /* PCM volumes */
59 unsigned int pcm_vol_nodes
; /* number of PCM volumes */
61 struct hda_gnode
*adc_node
; /* ADC node */
62 struct hda_gnode
*cap_vol_node
; /* Node for capture volume */
63 unsigned int cur_cap_src
; /* current capture source */
64 struct hda_input_mux input_mux
;
65 char cap_labels
[HDA_MAX_NUM_INPUTS
][16];
67 unsigned int def_amp_in_caps
;
68 unsigned int def_amp_out_caps
;
70 struct hda_pcm pcm_rec
; /* PCM information */
72 struct list_head nid_list
; /* list of widgets */
76 * retrieve the default device type from the default config value
78 #define defcfg_type(node) (((node)->def_cfg & AC_DEFCFG_DEVICE) >> \
79 AC_DEFCFG_DEVICE_SHIFT)
80 #define defcfg_location(node) (((node)->def_cfg & AC_DEFCFG_LOCATION) >> \
81 AC_DEFCFG_LOCATION_SHIFT)
82 #define defcfg_port_conn(node) (((node)->def_cfg & AC_DEFCFG_PORT_CONN) >> \
83 AC_DEFCFG_PORT_CONN_SHIFT)
88 static void snd_hda_generic_free(struct hda_codec
*codec
)
90 struct hda_gspec
*spec
= codec
->spec
;
91 struct list_head
*p
, *n
;
95 /* free all widgets */
96 list_for_each_safe(p
, n
, &spec
->nid_list
) {
97 struct hda_gnode
*node
= list_entry(p
, struct hda_gnode
, list
);
98 if (node
->conn_list
!= node
->slist
)
99 kfree(node
->conn_list
);
107 * add a new widget node and read its attributes
109 static int add_new_node(struct hda_codec
*codec
, struct hda_gspec
*spec
, hda_nid_t nid
)
111 struct hda_gnode
*node
;
113 hda_nid_t conn_list
[HDA_MAX_CONNECTIONS
];
115 node
= kzalloc(sizeof(*node
), GFP_KERNEL
);
119 nconns
= snd_hda_get_connections(codec
, nid
, conn_list
,
120 HDA_MAX_CONNECTIONS
);
125 if (nconns
<= ARRAY_SIZE(node
->slist
))
126 node
->conn_list
= node
->slist
;
128 node
->conn_list
= kmalloc(sizeof(hda_nid_t
) * nconns
,
130 if (! node
->conn_list
) {
131 snd_printk(KERN_ERR
"hda-generic: cannot malloc\n");
136 memcpy(node
->conn_list
, conn_list
, nconns
);
137 node
->nconns
= nconns
;
138 node
->wid_caps
= get_wcaps(codec
, nid
);
139 node
->type
= (node
->wid_caps
& AC_WCAP_TYPE
) >> AC_WCAP_TYPE_SHIFT
;
141 if (node
->type
== AC_WID_PIN
) {
142 node
->pin_caps
= snd_hda_param_read(codec
, node
->nid
, AC_PAR_PIN_CAP
);
143 node
->pin_ctl
= snd_hda_codec_read(codec
, node
->nid
, 0, AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
144 node
->def_cfg
= snd_hda_codec_read(codec
, node
->nid
, 0, AC_VERB_GET_CONFIG_DEFAULT
, 0);
147 if (node
->wid_caps
& AC_WCAP_OUT_AMP
) {
148 if (node
->wid_caps
& AC_WCAP_AMP_OVRD
)
149 node
->amp_out_caps
= snd_hda_param_read(codec
, node
->nid
, AC_PAR_AMP_OUT_CAP
);
150 if (! node
->amp_out_caps
)
151 node
->amp_out_caps
= spec
->def_amp_out_caps
;
153 if (node
->wid_caps
& AC_WCAP_IN_AMP
) {
154 if (node
->wid_caps
& AC_WCAP_AMP_OVRD
)
155 node
->amp_in_caps
= snd_hda_param_read(codec
, node
->nid
, AC_PAR_AMP_IN_CAP
);
156 if (! node
->amp_in_caps
)
157 node
->amp_in_caps
= spec
->def_amp_in_caps
;
159 list_add_tail(&node
->list
, &spec
->nid_list
);
164 * build the AFG subtree
166 static int build_afg_tree(struct hda_codec
*codec
)
168 struct hda_gspec
*spec
= codec
->spec
;
172 snd_assert(spec
, return -EINVAL
);
174 spec
->def_amp_out_caps
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_AMP_OUT_CAP
);
175 spec
->def_amp_in_caps
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_AMP_IN_CAP
);
177 nodes
= snd_hda_get_sub_nodes(codec
, codec
->afg
, &nid
);
178 if (! nid
|| nodes
< 0) {
179 printk(KERN_ERR
"Invalid AFG subtree\n");
183 /* parse all nodes belonging to the AFG */
184 for (i
= 0; i
< nodes
; i
++, nid
++) {
185 if ((err
= add_new_node(codec
, spec
, nid
)) < 0)
194 * look for the node record for the given NID
196 /* FIXME: should avoid the braindead linear search */
197 static struct hda_gnode
*hda_get_node(struct hda_gspec
*spec
, hda_nid_t nid
)
200 struct hda_gnode
*node
;
202 list_for_each(p
, &spec
->nid_list
) {
203 node
= list_entry(p
, struct hda_gnode
, list
);
204 if (node
->nid
== nid
)
211 * unmute (and set max vol) the output amplifier
213 static int unmute_output(struct hda_codec
*codec
, struct hda_gnode
*node
)
215 unsigned int val
, ofs
;
216 snd_printdd("UNMUTE OUT: NID=0x%x\n", node
->nid
);
217 val
= (node
->amp_out_caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
218 ofs
= (node
->amp_out_caps
& AC_AMPCAP_OFFSET
) >> AC_AMPCAP_OFFSET_SHIFT
;
221 val
|= AC_AMP_SET_LEFT
| AC_AMP_SET_RIGHT
;
222 val
|= AC_AMP_SET_OUTPUT
;
223 return snd_hda_codec_write(codec
, node
->nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, val
);
227 * unmute (and set max vol) the input amplifier
229 static int unmute_input(struct hda_codec
*codec
, struct hda_gnode
*node
, unsigned int index
)
231 unsigned int val
, ofs
;
232 snd_printdd("UNMUTE IN: NID=0x%x IDX=0x%x\n", node
->nid
, index
);
233 val
= (node
->amp_in_caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
234 ofs
= (node
->amp_in_caps
& AC_AMPCAP_OFFSET
) >> AC_AMPCAP_OFFSET_SHIFT
;
237 val
|= AC_AMP_SET_LEFT
| AC_AMP_SET_RIGHT
;
238 val
|= AC_AMP_SET_INPUT
;
239 // awk added - fixed to allow unmuting of indexed amps
240 val
|= index
<< AC_AMP_SET_INDEX_SHIFT
;
241 return snd_hda_codec_write(codec
, node
->nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, val
);
245 * select the input connection of the given node.
247 static int select_input_connection(struct hda_codec
*codec
, struct hda_gnode
*node
,
250 snd_printdd("CONNECT: NID=0x%x IDX=0x%x\n", node
->nid
, index
);
251 return snd_hda_codec_write(codec
, node
->nid
, 0, AC_VERB_SET_CONNECT_SEL
, index
);
255 * clear checked flag of each node in the node list
257 static void clear_check_flags(struct hda_gspec
*spec
)
260 struct hda_gnode
*node
;
262 list_for_each(p
, &spec
->nid_list
) {
263 node
= list_entry(p
, struct hda_gnode
, list
);
269 * parse the output path recursively until reach to an audio output widget
271 * returns 0 if not found, 1 if found, or a negative error code.
273 static int parse_output_path(struct hda_codec
*codec
, struct hda_gspec
*spec
,
274 struct hda_gnode
*node
, int dac_idx
)
277 struct hda_gnode
*child
;
283 if (node
->type
== AC_WID_AUD_OUT
) {
284 if (node
->wid_caps
& AC_WCAP_DIGITAL
) {
285 snd_printdd("Skip Digital OUT node %x\n", node
->nid
);
288 snd_printdd("AUD_OUT found %x\n", node
->nid
);
289 if (spec
->dac_node
[dac_idx
]) {
290 /* already DAC node is assigned, just unmute & connect */
291 return node
== spec
->dac_node
[dac_idx
];
293 spec
->dac_node
[dac_idx
] = node
;
294 if ((node
->wid_caps
& AC_WCAP_OUT_AMP
) &&
295 spec
->pcm_vol_nodes
< MAX_PCM_VOLS
) {
296 spec
->pcm_vol
[spec
->pcm_vol_nodes
].node
= node
;
297 spec
->pcm_vol
[spec
->pcm_vol_nodes
].index
= 0;
298 spec
->pcm_vol_nodes
++;
300 return 1; /* found */
303 for (i
= 0; i
< node
->nconns
; i
++) {
304 child
= hda_get_node(spec
, node
->conn_list
[i
]);
307 err
= parse_output_path(codec
, spec
, child
, dac_idx
);
312 * select the path, unmute both input and output
314 if (node
->nconns
> 1)
315 select_input_connection(codec
, node
, i
);
316 unmute_input(codec
, node
, i
);
317 unmute_output(codec
, node
);
318 if (spec
->dac_node
[dac_idx
] &&
319 spec
->pcm_vol_nodes
< MAX_PCM_VOLS
&&
320 !(spec
->dac_node
[dac_idx
]->wid_caps
&
322 if ((node
->wid_caps
& AC_WCAP_IN_AMP
) ||
323 (node
->wid_caps
& AC_WCAP_OUT_AMP
)) {
324 int n
= spec
->pcm_vol_nodes
;
325 spec
->pcm_vol
[n
].node
= node
;
326 spec
->pcm_vol
[n
].index
= i
;
327 spec
->pcm_vol_nodes
++;
337 * Look for the output PIN widget with the given jack type
338 * and parse the output path to that PIN.
340 * Returns the PIN node when the path to DAC is established.
342 static struct hda_gnode
*parse_output_jack(struct hda_codec
*codec
,
343 struct hda_gspec
*spec
,
347 struct hda_gnode
*node
;
350 list_for_each(p
, &spec
->nid_list
) {
351 node
= list_entry(p
, struct hda_gnode
, list
);
352 if (node
->type
!= AC_WID_PIN
)
354 /* output capable? */
355 if (! (node
->pin_caps
& AC_PINCAP_OUT
))
357 if (defcfg_port_conn(node
) == AC_JACK_PORT_NONE
)
358 continue; /* unconnected */
359 if (jack_type
>= 0) {
360 if (jack_type
!= defcfg_type(node
))
362 if (node
->wid_caps
& AC_WCAP_DIGITAL
)
363 continue; /* skip SPDIF */
365 /* output as default? */
366 if (! (node
->pin_ctl
& AC_PINCTL_OUT_EN
))
369 clear_check_flags(spec
);
370 err
= parse_output_path(codec
, spec
, node
, 0);
373 if (! err
&& spec
->out_pin_node
[0]) {
374 err
= parse_output_path(codec
, spec
, node
, 1);
379 /* unmute the PIN output */
380 unmute_output(codec
, node
);
381 /* set PIN-Out enable */
382 snd_hda_codec_write(codec
, node
->nid
, 0,
383 AC_VERB_SET_PIN_WIDGET_CONTROL
,
385 ((node
->pin_caps
& AC_PINCAP_HP_DRV
) ?
386 AC_PINCTL_HP_EN
: 0));
397 static int parse_output(struct hda_codec
*codec
)
399 struct hda_gspec
*spec
= codec
->spec
;
400 struct hda_gnode
*node
;
403 * Look for the output PIN widget
405 /* first, look for the line-out pin */
406 node
= parse_output_jack(codec
, spec
, AC_JACK_LINE_OUT
);
407 if (node
) /* found, remember the PIN node */
408 spec
->out_pin_node
[0] = node
;
410 /* if no line-out is found, try speaker out */
411 node
= parse_output_jack(codec
, spec
, AC_JACK_SPEAKER
);
413 spec
->out_pin_node
[0] = node
;
415 /* look for the HP-out pin */
416 node
= parse_output_jack(codec
, spec
, AC_JACK_HP_OUT
);
418 if (! spec
->out_pin_node
[0])
419 spec
->out_pin_node
[0] = node
;
421 spec
->out_pin_node
[1] = node
;
424 if (! spec
->out_pin_node
[0]) {
425 /* no line-out or HP pins found,
426 * then choose for the first output pin
428 spec
->out_pin_node
[0] = parse_output_jack(codec
, spec
, -1);
429 if (! spec
->out_pin_node
[0])
430 snd_printd("hda_generic: no proper output path found\n");
440 /* control callbacks */
441 static int capture_source_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
443 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
444 struct hda_gspec
*spec
= codec
->spec
;
445 return snd_hda_input_mux_info(&spec
->input_mux
, uinfo
);
448 static int capture_source_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
450 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
451 struct hda_gspec
*spec
= codec
->spec
;
453 ucontrol
->value
.enumerated
.item
[0] = spec
->cur_cap_src
;
457 static int capture_source_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
459 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
460 struct hda_gspec
*spec
= codec
->spec
;
461 return snd_hda_input_mux_put(codec
, &spec
->input_mux
, ucontrol
,
462 spec
->adc_node
->nid
, &spec
->cur_cap_src
);
466 * return the string name of the given input PIN widget
468 static const char *get_input_type(struct hda_gnode
*node
, unsigned int *pinctl
)
470 unsigned int location
= defcfg_location(node
);
471 switch (defcfg_type(node
)) {
472 case AC_JACK_LINE_IN
:
473 if ((location
& 0x0f) == AC_JACK_LOC_FRONT
)
479 *pinctl
|= AC_PINCTL_VREF_GRD
;
483 if ((location
& 0x0f) == AC_JACK_LOC_FRONT
)
489 (AC_PINCAP_VREF_80
<< AC_PINCAP_VREF_SHIFT
)))
490 *pinctl
|= AC_PINCTL_VREF_80
;
491 if ((location
& 0x0f) == AC_JACK_LOC_FRONT
)
494 case AC_JACK_SPDIF_IN
:
496 case AC_JACK_DIG_OTHER_IN
:
503 * parse the nodes recursively until reach to the input PIN
505 * returns 0 if not found, 1 if found, or a negative error code.
507 static int parse_adc_sub_nodes(struct hda_codec
*codec
, struct hda_gspec
*spec
,
508 struct hda_gnode
*node
)
519 if (node
->type
!= AC_WID_PIN
) {
520 for (i
= 0; i
< node
->nconns
; i
++) {
521 struct hda_gnode
*child
;
522 child
= hda_get_node(spec
, node
->conn_list
[i
]);
525 err
= parse_adc_sub_nodes(codec
, spec
, child
);
530 * select the path, unmute both input and output
532 if (node
->nconns
> 1)
533 select_input_connection(codec
, node
, i
);
534 unmute_input(codec
, node
, i
);
535 unmute_output(codec
, node
);
543 if (! (node
->pin_caps
& AC_PINCAP_IN
))
546 if (defcfg_port_conn(node
) == AC_JACK_PORT_NONE
)
547 return 0; /* unconnected */
549 if (node
->wid_caps
& AC_WCAP_DIGITAL
)
550 return 0; /* skip SPDIF */
552 if (spec
->input_mux
.num_items
>= HDA_MAX_NUM_INPUTS
) {
553 snd_printk(KERN_ERR
"hda_generic: Too many items for capture\n");
557 pinctl
= AC_PINCTL_IN_EN
;
558 /* create a proper capture source label */
559 type
= get_input_type(node
, &pinctl
);
561 /* input as default? */
562 if (! (node
->pin_ctl
& AC_PINCTL_IN_EN
))
566 label
= spec
->cap_labels
[spec
->input_mux
.num_items
];
568 spec
->input_mux
.items
[spec
->input_mux
.num_items
].label
= label
;
570 /* unmute the PIN external input */
571 unmute_input(codec
, node
, 0); /* index = 0? */
572 /* set PIN-In enable */
573 snd_hda_codec_write(codec
, node
->nid
, 0, AC_VERB_SET_PIN_WIDGET_CONTROL
, pinctl
);
575 return 1; /* found */
578 /* add a capture source element */
579 static void add_cap_src(struct hda_gspec
*spec
, int idx
)
581 struct hda_input_mux_item
*csrc
;
585 num
= spec
->input_mux
.num_items
;
586 csrc
= &spec
->input_mux
.items
[num
];
587 buf
= spec
->cap_labels
[num
];
588 for (ocap
= 0; ocap
< num
; ocap
++) {
589 if (! strcmp(buf
, spec
->cap_labels
[ocap
])) {
590 /* same label already exists,
591 * put the index number to be unique
593 sprintf(buf
, "%s %d", spec
->cap_labels
[ocap
], num
);
598 spec
->input_mux
.num_items
++;
604 static int parse_input_path(struct hda_codec
*codec
, struct hda_gnode
*adc_node
)
606 struct hda_gspec
*spec
= codec
->spec
;
607 struct hda_gnode
*node
;
610 snd_printdd("AUD_IN = %x\n", adc_node
->nid
);
611 clear_check_flags(spec
);
613 // awk added - fixed no recording due to muted widget
614 unmute_input(codec
, adc_node
, 0);
617 * check each connection of the ADC
618 * if it reaches to a proper input PIN, add the path as the
621 /* first, check the direct connections to PIN widgets */
622 for (i
= 0; i
< adc_node
->nconns
; i
++) {
623 node
= hda_get_node(spec
, adc_node
->conn_list
[i
]);
624 if (node
&& node
->type
== AC_WID_PIN
) {
625 err
= parse_adc_sub_nodes(codec
, spec
, node
);
629 add_cap_src(spec
, i
);
632 /* ... then check the rests, more complicated connections */
633 for (i
= 0; i
< adc_node
->nconns
; i
++) {
634 node
= hda_get_node(spec
, adc_node
->conn_list
[i
]);
635 if (node
&& node
->type
!= AC_WID_PIN
) {
636 err
= parse_adc_sub_nodes(codec
, spec
, node
);
640 add_cap_src(spec
, i
);
644 if (! spec
->input_mux
.num_items
)
645 return 0; /* no input path found... */
647 snd_printdd("[Capture Source] NID=0x%x, #SRC=%d\n", adc_node
->nid
, spec
->input_mux
.num_items
);
648 for (i
= 0; i
< spec
->input_mux
.num_items
; i
++)
649 snd_printdd(" [%s] IDX=0x%x\n", spec
->input_mux
.items
[i
].label
,
650 spec
->input_mux
.items
[i
].index
);
652 spec
->adc_node
= adc_node
;
659 static int parse_input(struct hda_codec
*codec
)
661 struct hda_gspec
*spec
= codec
->spec
;
663 struct hda_gnode
*node
;
667 * At first we look for an audio input widget.
668 * If it reaches to certain input PINs, we take it as the
671 list_for_each(p
, &spec
->nid_list
) {
672 node
= list_entry(p
, struct hda_gnode
, list
);
673 if (node
->wid_caps
& AC_WCAP_DIGITAL
)
674 continue; /* skip SPDIF */
675 if (node
->type
== AC_WID_AUD_IN
) {
676 err
= parse_input_path(codec
, node
);
683 snd_printd("hda_generic: no proper input path found\n");
688 * create mixer controls if possible
690 static int create_mixer(struct hda_codec
*codec
, struct hda_gnode
*node
,
691 unsigned int index
, const char *type
, const char *dir_sfx
)
696 struct snd_kcontrol_new knew
;
699 sprintf(name
, "%s %s Switch", type
, dir_sfx
);
701 sprintf(name
, "%s Switch", dir_sfx
);
702 if ((node
->wid_caps
& AC_WCAP_IN_AMP
) &&
703 (node
->amp_in_caps
& AC_AMPCAP_MUTE
)) {
704 knew
= (struct snd_kcontrol_new
)HDA_CODEC_MUTE(name
, node
->nid
, index
, HDA_INPUT
);
705 snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name
, node
->nid
, index
);
706 if ((err
= snd_ctl_add(codec
->bus
->card
, snd_ctl_new1(&knew
, codec
))) < 0)
709 } else if ((node
->wid_caps
& AC_WCAP_OUT_AMP
) &&
710 (node
->amp_out_caps
& AC_AMPCAP_MUTE
)) {
711 knew
= (struct snd_kcontrol_new
)HDA_CODEC_MUTE(name
, node
->nid
, 0, HDA_OUTPUT
);
712 snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name
, node
->nid
);
713 if ((err
= snd_ctl_add(codec
->bus
->card
, snd_ctl_new1(&knew
, codec
))) < 0)
719 sprintf(name
, "%s %s Volume", type
, dir_sfx
);
721 sprintf(name
, "%s Volume", dir_sfx
);
722 if ((node
->wid_caps
& AC_WCAP_IN_AMP
) &&
723 (node
->amp_in_caps
& AC_AMPCAP_NUM_STEPS
)) {
724 knew
= (struct snd_kcontrol_new
)HDA_CODEC_VOLUME(name
, node
->nid
, index
, HDA_INPUT
);
725 snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name
, node
->nid
, index
);
726 if ((err
= snd_ctl_add(codec
->bus
->card
, snd_ctl_new1(&knew
, codec
))) < 0)
729 } else if ((node
->wid_caps
& AC_WCAP_OUT_AMP
) &&
730 (node
->amp_out_caps
& AC_AMPCAP_NUM_STEPS
)) {
731 knew
= (struct snd_kcontrol_new
)HDA_CODEC_VOLUME(name
, node
->nid
, 0, HDA_OUTPUT
);
732 snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name
, node
->nid
);
733 if ((err
= snd_ctl_add(codec
->bus
->card
, snd_ctl_new1(&knew
, codec
))) < 0)
742 * check whether the controls with the given name and direction suffix already exist
744 static int check_existing_control(struct hda_codec
*codec
, const char *type
, const char *dir
)
746 struct snd_ctl_elem_id id
;
747 memset(&id
, 0, sizeof(id
));
748 sprintf(id
.name
, "%s %s Volume", type
, dir
);
749 id
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
750 if (snd_ctl_find_id(codec
->bus
->card
, &id
))
752 sprintf(id
.name
, "%s %s Switch", type
, dir
);
753 id
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
754 if (snd_ctl_find_id(codec
->bus
->card
, &id
))
760 * build output mixer controls
762 static int create_output_mixers(struct hda_codec
*codec
, const char **names
)
764 struct hda_gspec
*spec
= codec
->spec
;
767 for (i
= 0; i
< spec
->pcm_vol_nodes
; i
++) {
768 err
= create_mixer(codec
, spec
->pcm_vol
[i
].node
,
769 spec
->pcm_vol
[i
].index
,
770 names
[i
], "Playback");
777 static int build_output_controls(struct hda_codec
*codec
)
779 struct hda_gspec
*spec
= codec
->spec
;
780 static const char *types_speaker
[] = { "Speaker", "Headphone" };
781 static const char *types_line
[] = { "Front", "Headphone" };
783 switch (spec
->pcm_vol_nodes
) {
785 return create_mixer(codec
, spec
->pcm_vol
[0].node
,
786 spec
->pcm_vol
[0].index
,
787 "Master", "Playback");
789 if (defcfg_type(spec
->out_pin_node
[0]) == AC_JACK_SPEAKER
)
790 return create_output_mixers(codec
, types_speaker
);
792 return create_output_mixers(codec
, types_line
);
797 /* create capture volume/switch */
798 static int build_input_controls(struct hda_codec
*codec
)
800 struct hda_gspec
*spec
= codec
->spec
;
801 struct hda_gnode
*adc_node
= spec
->adc_node
;
803 static struct snd_kcontrol_new cap_sel
= {
804 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
805 .name
= "Capture Source",
806 .info
= capture_source_info
,
807 .get
= capture_source_get
,
808 .put
= capture_source_put
,
811 if (! adc_node
|| ! spec
->input_mux
.num_items
)
812 return 0; /* not found */
814 spec
->cur_cap_src
= 0;
815 select_input_connection(codec
, adc_node
,
816 spec
->input_mux
.items
[0].index
);
818 /* create capture volume and switch controls if the ADC has an amp */
819 /* do we have only a single item? */
820 if (spec
->input_mux
.num_items
== 1) {
821 err
= create_mixer(codec
, adc_node
,
822 spec
->input_mux
.items
[0].index
,
829 /* create input MUX if multiple sources are available */
830 if ((err
= snd_ctl_add(codec
->bus
->card
,
831 snd_ctl_new1(&cap_sel
, codec
))) < 0)
834 /* no volume control? */
835 if (! (adc_node
->wid_caps
& AC_WCAP_IN_AMP
) ||
836 ! (adc_node
->amp_in_caps
& AC_AMPCAP_NUM_STEPS
))
839 for (i
= 0; i
< spec
->input_mux
.num_items
; i
++) {
840 struct snd_kcontrol_new knew
;
842 sprintf(name
, "%s Capture Volume",
843 spec
->input_mux
.items
[i
].label
);
844 knew
= (struct snd_kcontrol_new
)
845 HDA_CODEC_VOLUME(name
, adc_node
->nid
,
846 spec
->input_mux
.items
[i
].index
,
848 if ((err
= snd_ctl_add(codec
->bus
->card
,
849 snd_ctl_new1(&knew
, codec
))) < 0)
858 * parse the nodes recursively until reach to the output PIN.
860 * returns 0 - if not found,
861 * 1 - if found, but no mixer is created
862 * 2 - if found and mixer was already created, (just skip)
863 * a negative error code
865 static int parse_loopback_path(struct hda_codec
*codec
, struct hda_gspec
*spec
,
866 struct hda_gnode
*node
, struct hda_gnode
*dest_node
,
875 if (node
== dest_node
) {
876 /* loopback connection found */
880 for (i
= 0; i
< node
->nconns
; i
++) {
881 struct hda_gnode
*child
= hda_get_node(spec
, node
->conn_list
[i
]);
884 err
= parse_loopback_path(codec
, spec
, child
, dest_node
, type
);
889 err
= create_mixer(codec
, node
, i
, type
, "Playback");
893 return 2; /* ok, created */
894 /* not created, maybe in the lower path */
897 /* connect and unmute */
898 if (node
->nconns
> 1)
899 select_input_connection(codec
, node
, i
);
900 unmute_input(codec
, node
, i
);
901 unmute_output(codec
, node
);
909 * parse the tree and build the loopback controls
911 static int build_loopback_controls(struct hda_codec
*codec
)
913 struct hda_gspec
*spec
= codec
->spec
;
915 struct hda_gnode
*node
;
919 if (! spec
->out_pin_node
[0])
922 list_for_each(p
, &spec
->nid_list
) {
923 node
= list_entry(p
, struct hda_gnode
, list
);
924 if (node
->type
!= AC_WID_PIN
)
927 if (! (node
->pin_caps
& AC_PINCAP_IN
))
929 type
= get_input_type(node
, NULL
);
931 if (check_existing_control(codec
, type
, "Playback"))
933 clear_check_flags(spec
);
934 err
= parse_loopback_path(codec
, spec
,
935 spec
->out_pin_node
[0],
947 * build mixer controls
949 static int build_generic_controls(struct hda_codec
*codec
)
953 if ((err
= build_input_controls(codec
)) < 0 ||
954 (err
= build_output_controls(codec
)) < 0 ||
955 (err
= build_loopback_controls(codec
)) < 0)
964 static struct hda_pcm_stream generic_pcm_playback
= {
970 static int generic_pcm2_prepare(struct hda_pcm_stream
*hinfo
,
971 struct hda_codec
*codec
,
972 unsigned int stream_tag
,
974 struct snd_pcm_substream
*substream
)
976 struct hda_gspec
*spec
= codec
->spec
;
978 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, stream_tag
, 0, format
);
979 snd_hda_codec_setup_stream(codec
, spec
->dac_node
[1]->nid
,
980 stream_tag
, 0, format
);
984 static int generic_pcm2_cleanup(struct hda_pcm_stream
*hinfo
,
985 struct hda_codec
*codec
,
986 struct snd_pcm_substream
*substream
)
988 struct hda_gspec
*spec
= codec
->spec
;
990 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, 0, 0, 0);
991 snd_hda_codec_setup_stream(codec
, spec
->dac_node
[1]->nid
, 0, 0, 0);
995 static int build_generic_pcms(struct hda_codec
*codec
)
997 struct hda_gspec
*spec
= codec
->spec
;
998 struct hda_pcm
*info
= &spec
->pcm_rec
;
1000 if (! spec
->dac_node
[0] && ! spec
->adc_node
) {
1001 snd_printd("hda_generic: no PCM found\n");
1005 codec
->num_pcms
= 1;
1006 codec
->pcm_info
= info
;
1008 info
->name
= "HDA Generic";
1009 if (spec
->dac_node
[0]) {
1010 info
->stream
[0] = generic_pcm_playback
;
1011 info
->stream
[0].nid
= spec
->dac_node
[0]->nid
;
1012 if (spec
->dac_node
[1]) {
1013 info
->stream
[0].ops
.prepare
= generic_pcm2_prepare
;
1014 info
->stream
[0].ops
.cleanup
= generic_pcm2_cleanup
;
1017 if (spec
->adc_node
) {
1018 info
->stream
[1] = generic_pcm_playback
;
1019 info
->stream
[1].nid
= spec
->adc_node
->nid
;
1028 static struct hda_codec_ops generic_patch_ops
= {
1029 .build_controls
= build_generic_controls
,
1030 .build_pcms
= build_generic_pcms
,
1031 .free
= snd_hda_generic_free
,
1035 * the generic parser
1037 int snd_hda_parse_generic_codec(struct hda_codec
*codec
)
1039 struct hda_gspec
*spec
;
1045 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
1047 printk(KERN_ERR
"hda_generic: can't allocate spec\n");
1051 INIT_LIST_HEAD(&spec
->nid_list
);
1053 if ((err
= build_afg_tree(codec
)) < 0)
1056 if ((err
= parse_input(codec
)) < 0 ||
1057 (err
= parse_output(codec
)) < 0)
1060 codec
->patch_ops
= generic_patch_ops
;
1065 snd_hda_generic_free(codec
);