2 * Universal Interface for Intel High Definition Audio Codec
4 * Generic proc interface
6 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
9 * This driver is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This driver is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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 static char *bits_names(unsigned int bits
, char *names
[], int size
)
35 for (i
= 0, n
= 0; i
< size
; i
++) {
36 if (bits
& (1U<<i
) && names
[i
])
37 n
+= snprintf(buf
+ n
, sizeof(buf
) - n
, " %s",
45 static const char *get_wid_type_name(unsigned int wid_value
)
47 static char *names
[16] = {
48 [AC_WID_AUD_OUT
] = "Audio Output",
49 [AC_WID_AUD_IN
] = "Audio Input",
50 [AC_WID_AUD_MIX
] = "Audio Mixer",
51 [AC_WID_AUD_SEL
] = "Audio Selector",
52 [AC_WID_PIN
] = "Pin Complex",
53 [AC_WID_POWER
] = "Power Widget",
54 [AC_WID_VOL_KNB
] = "Volume Knob Widget",
55 [AC_WID_BEEP
] = "Beep Generator Widget",
56 [AC_WID_VENDOR
] = "Vendor Defined Widget",
59 return "UNKNOWN Widget";
62 return names
[wid_value
];
64 return "UNKNOWN Widget";
67 static void print_nid_array(struct snd_info_buffer
*buffer
,
68 struct hda_codec
*codec
, hda_nid_t nid
,
69 struct snd_array
*array
)
72 struct hda_nid_item
*items
= array
->list
, *item
;
73 struct snd_kcontrol
*kctl
;
74 for (i
= 0; i
< array
->used
; i
++) {
76 if (item
->nid
== nid
) {
79 " Control: name=\"%s\", index=%i, device=%i\n",
80 kctl
->id
.name
, kctl
->id
.index
+ item
->index
,
82 if (item
->flags
& HDA_NID_ITEM_AMP
)
84 " ControlAmp: chs=%lu, dir=%s, "
86 get_amp_channels(kctl
),
87 get_amp_direction(kctl
) ? "Out" : "In",
89 get_amp_offset(kctl
));
94 static void print_nid_pcms(struct snd_info_buffer
*buffer
,
95 struct hda_codec
*codec
, hda_nid_t nid
)
99 for (pcm
= 0; pcm
< codec
->num_pcms
; pcm
++) {
100 cpcm
= &codec
->pcm_info
[pcm
];
101 for (type
= 0; type
< 2; type
++) {
102 if (cpcm
->stream
[type
].nid
!= nid
|| cpcm
->pcm
== NULL
)
104 snd_iprintf(buffer
, " Device: name=\"%s\", "
105 "type=\"%s\", device=%i\n",
107 snd_hda_pcm_type_name
[cpcm
->pcm_type
],
113 static void print_amp_caps(struct snd_info_buffer
*buffer
,
114 struct hda_codec
*codec
, hda_nid_t nid
, int dir
)
117 caps
= snd_hda_param_read(codec
, nid
,
119 AC_PAR_AMP_OUT_CAP
: AC_PAR_AMP_IN_CAP
);
120 if (caps
== -1 || caps
== 0) {
121 snd_iprintf(buffer
, "N/A\n");
124 snd_iprintf(buffer
, "ofs=0x%02x, nsteps=0x%02x, stepsize=0x%02x, "
126 caps
& AC_AMPCAP_OFFSET
,
127 (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
,
128 (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
,
129 (caps
& AC_AMPCAP_MUTE
) >> AC_AMPCAP_MUTE_SHIFT
);
132 static void print_amp_vals(struct snd_info_buffer
*buffer
,
133 struct hda_codec
*codec
, hda_nid_t nid
,
134 int dir
, int stereo
, int indices
)
139 dir
= dir
== HDA_OUTPUT
? AC_AMP_GET_OUTPUT
: AC_AMP_GET_INPUT
;
140 for (i
= 0; i
< indices
; i
++) {
141 snd_iprintf(buffer
, " [");
142 val
= snd_hda_codec_read(codec
, nid
, 0,
143 AC_VERB_GET_AMP_GAIN_MUTE
,
144 AC_AMP_GET_LEFT
| dir
| i
);
145 snd_iprintf(buffer
, "0x%02x", val
);
147 val
= snd_hda_codec_read(codec
, nid
, 0,
148 AC_VERB_GET_AMP_GAIN_MUTE
,
149 AC_AMP_GET_RIGHT
| dir
| i
);
150 snd_iprintf(buffer
, " 0x%02x", val
);
152 snd_iprintf(buffer
, "]");
154 snd_iprintf(buffer
, "\n");
157 static void print_pcm_rates(struct snd_info_buffer
*buffer
, unsigned int pcm
)
159 static unsigned int rates
[] = {
160 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
161 96000, 176400, 192000, 384000
165 pcm
&= AC_SUPPCM_RATES
;
166 snd_iprintf(buffer
, " rates [0x%x]:", pcm
);
167 for (i
= 0; i
< ARRAY_SIZE(rates
); i
++)
169 snd_iprintf(buffer
, " %d", rates
[i
]);
170 snd_iprintf(buffer
, "\n");
173 static void print_pcm_bits(struct snd_info_buffer
*buffer
, unsigned int pcm
)
175 char buf
[SND_PRINT_BITS_ADVISED_BUFSIZE
];
177 snd_iprintf(buffer
, " bits [0x%x]:", (pcm
>> 16) & 0xff);
178 snd_print_pcm_bits(pcm
, buf
, sizeof(buf
));
179 snd_iprintf(buffer
, "%s\n", buf
);
182 static void print_pcm_formats(struct snd_info_buffer
*buffer
,
183 unsigned int streams
)
185 snd_iprintf(buffer
, " formats [0x%x]:", streams
& 0xf);
186 if (streams
& AC_SUPFMT_PCM
)
187 snd_iprintf(buffer
, " PCM");
188 if (streams
& AC_SUPFMT_FLOAT32
)
189 snd_iprintf(buffer
, " FLOAT");
190 if (streams
& AC_SUPFMT_AC3
)
191 snd_iprintf(buffer
, " AC3");
192 snd_iprintf(buffer
, "\n");
195 static void print_pcm_caps(struct snd_info_buffer
*buffer
,
196 struct hda_codec
*codec
, hda_nid_t nid
)
198 unsigned int pcm
= snd_hda_param_read(codec
, nid
, AC_PAR_PCM
);
199 unsigned int stream
= snd_hda_param_read(codec
, nid
, AC_PAR_STREAM
);
200 if (pcm
== -1 || stream
== -1) {
201 snd_iprintf(buffer
, "N/A\n");
204 print_pcm_rates(buffer
, pcm
);
205 print_pcm_bits(buffer
, pcm
);
206 print_pcm_formats(buffer
, stream
);
209 static const char *get_jack_connection(u32 cfg
)
211 static char *names
[16] = {
212 "Unknown", "1/8", "1/4", "ATAPI",
213 "RCA", "Optical","Digital", "Analog",
214 "DIN", "XLR", "RJ11", "Comb",
215 NULL
, NULL
, NULL
, "Other"
217 cfg
= (cfg
& AC_DEFCFG_CONN_TYPE
) >> AC_DEFCFG_CONN_TYPE_SHIFT
;
224 static const char *get_jack_color(u32 cfg
)
226 static char *names
[16] = {
227 "Unknown", "Black", "Grey", "Blue",
228 "Green", "Red", "Orange", "Yellow",
229 "Purple", "Pink", NULL
, NULL
,
230 NULL
, NULL
, "White", "Other",
232 cfg
= (cfg
& AC_DEFCFG_COLOR
) >> AC_DEFCFG_COLOR_SHIFT
;
239 static void print_pin_caps(struct snd_info_buffer
*buffer
,
240 struct hda_codec
*codec
, hda_nid_t nid
,
243 static char *jack_conns
[4] = { "Jack", "N/A", "Fixed", "Both" };
244 unsigned int caps
, val
;
246 caps
= snd_hda_param_read(codec
, nid
, AC_PAR_PIN_CAP
);
247 snd_iprintf(buffer
, " Pincap 0x%08x:", caps
);
248 if (caps
& AC_PINCAP_IN
)
249 snd_iprintf(buffer
, " IN");
250 if (caps
& AC_PINCAP_OUT
)
251 snd_iprintf(buffer
, " OUT");
252 if (caps
& AC_PINCAP_HP_DRV
)
253 snd_iprintf(buffer
, " HP");
254 if (caps
& AC_PINCAP_EAPD
)
255 snd_iprintf(buffer
, " EAPD");
256 if (caps
& AC_PINCAP_PRES_DETECT
)
257 snd_iprintf(buffer
, " Detect");
258 if (caps
& AC_PINCAP_BALANCE
)
259 snd_iprintf(buffer
, " Balanced");
260 if (caps
& AC_PINCAP_HDMI
) {
261 /* Realtek uses this bit as a different meaning */
262 if ((codec
->vendor_id
>> 16) == 0x10ec)
263 snd_iprintf(buffer
, " R/L");
265 if (caps
& AC_PINCAP_HBR
)
266 snd_iprintf(buffer
, " HBR");
267 snd_iprintf(buffer
, " HDMI");
270 if (caps
& AC_PINCAP_DP
)
271 snd_iprintf(buffer
, " DP");
272 if (caps
& AC_PINCAP_TRIG_REQ
)
273 snd_iprintf(buffer
, " Trigger");
274 if (caps
& AC_PINCAP_IMP_SENSE
)
275 snd_iprintf(buffer
, " ImpSense");
276 snd_iprintf(buffer
, "\n");
277 if (caps
& AC_PINCAP_VREF
) {
279 (caps
& AC_PINCAP_VREF
) >> AC_PINCAP_VREF_SHIFT
;
280 snd_iprintf(buffer
, " Vref caps:");
281 if (vref
& AC_PINCAP_VREF_HIZ
)
282 snd_iprintf(buffer
, " HIZ");
283 if (vref
& AC_PINCAP_VREF_50
)
284 snd_iprintf(buffer
, " 50");
285 if (vref
& AC_PINCAP_VREF_GRD
)
286 snd_iprintf(buffer
, " GRD");
287 if (vref
& AC_PINCAP_VREF_80
)
288 snd_iprintf(buffer
, " 80");
289 if (vref
& AC_PINCAP_VREF_100
)
290 snd_iprintf(buffer
, " 100");
291 snd_iprintf(buffer
, "\n");
295 if (caps
& AC_PINCAP_EAPD
) {
296 val
= snd_hda_codec_read(codec
, nid
, 0,
297 AC_VERB_GET_EAPD_BTLENABLE
, 0);
298 snd_iprintf(buffer
, " EAPD 0x%x:", val
);
299 if (val
& AC_EAPDBTL_BALANCED
)
300 snd_iprintf(buffer
, " BALANCED");
301 if (val
& AC_EAPDBTL_EAPD
)
302 snd_iprintf(buffer
, " EAPD");
303 if (val
& AC_EAPDBTL_LR_SWAP
)
304 snd_iprintf(buffer
, " R/L");
305 snd_iprintf(buffer
, "\n");
307 caps
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_CONFIG_DEFAULT
, 0);
308 snd_iprintf(buffer
, " Pin Default 0x%08x: [%s] %s at %s %s\n", caps
,
309 jack_conns
[(caps
& AC_DEFCFG_PORT_CONN
) >> AC_DEFCFG_PORT_CONN_SHIFT
],
310 snd_hda_get_jack_type(caps
),
311 snd_hda_get_jack_connectivity(caps
),
312 snd_hda_get_jack_location(caps
));
313 snd_iprintf(buffer
, " Conn = %s, Color = %s\n",
314 get_jack_connection(caps
),
315 get_jack_color(caps
));
316 /* Default association and sequence values refer to default grouping
317 * of pin complexes and their sequence within the group. This is used
318 * for priority and resource allocation.
320 snd_iprintf(buffer
, " DefAssociation = 0x%x, Sequence = 0x%x\n",
321 (caps
& AC_DEFCFG_DEF_ASSOC
) >> AC_DEFCFG_ASSOC_SHIFT
,
322 caps
& AC_DEFCFG_SEQUENCE
);
323 if (((caps
& AC_DEFCFG_MISC
) >> AC_DEFCFG_MISC_SHIFT
) &
324 AC_DEFCFG_MISC_NO_PRESENCE
) {
325 /* Miscellaneous bit indicates external hardware does not
326 * support presence detection even if the pin complex
327 * indicates it is supported.
329 snd_iprintf(buffer
, " Misc = NO_PRESENCE\n");
333 static void print_pin_ctls(struct snd_info_buffer
*buffer
,
334 struct hda_codec
*codec
, hda_nid_t nid
,
337 unsigned int pinctls
;
339 pinctls
= snd_hda_codec_read(codec
, nid
, 0,
340 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
341 snd_iprintf(buffer
, " Pin-ctls: 0x%02x:", pinctls
);
342 if (pinctls
& AC_PINCTL_IN_EN
)
343 snd_iprintf(buffer
, " IN");
344 if (pinctls
& AC_PINCTL_OUT_EN
)
345 snd_iprintf(buffer
, " OUT");
346 if (pinctls
& AC_PINCTL_HP_EN
)
347 snd_iprintf(buffer
, " HP");
349 int vref
= pinctls
& AC_PINCTL_VREFEN
;
351 case AC_PINCTL_VREF_HIZ
:
352 snd_iprintf(buffer
, " VREF_HIZ");
354 case AC_PINCTL_VREF_50
:
355 snd_iprintf(buffer
, " VREF_50");
357 case AC_PINCTL_VREF_GRD
:
358 snd_iprintf(buffer
, " VREF_GRD");
360 case AC_PINCTL_VREF_80
:
361 snd_iprintf(buffer
, " VREF_80");
363 case AC_PINCTL_VREF_100
:
364 snd_iprintf(buffer
, " VREF_100");
368 snd_iprintf(buffer
, "\n");
371 static void print_vol_knob(struct snd_info_buffer
*buffer
,
372 struct hda_codec
*codec
, hda_nid_t nid
)
374 unsigned int cap
= snd_hda_param_read(codec
, nid
,
376 snd_iprintf(buffer
, " Volume-Knob: delta=%d, steps=%d, ",
377 (cap
>> 7) & 1, cap
& 0x7f);
378 cap
= snd_hda_codec_read(codec
, nid
, 0,
379 AC_VERB_GET_VOLUME_KNOB_CONTROL
, 0);
380 snd_iprintf(buffer
, "direct=%d, val=%d\n",
381 (cap
>> 7) & 1, cap
& 0x7f);
384 static void print_audio_io(struct snd_info_buffer
*buffer
,
385 struct hda_codec
*codec
, hda_nid_t nid
,
386 unsigned int wid_type
)
388 int conv
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_CONV
, 0);
390 " Converter: stream=%d, channel=%d\n",
391 (conv
& AC_CONV_STREAM
) >> AC_CONV_STREAM_SHIFT
,
392 conv
& AC_CONV_CHANNEL
);
394 if (wid_type
== AC_WID_AUD_IN
&& (conv
& AC_CONV_CHANNEL
) == 0) {
395 int sdi
= snd_hda_codec_read(codec
, nid
, 0,
396 AC_VERB_GET_SDI_SELECT
, 0);
397 snd_iprintf(buffer
, " SDI-Select: %d\n",
398 sdi
& AC_SDI_SELECT
);
402 static void print_digital_conv(struct snd_info_buffer
*buffer
,
403 struct hda_codec
*codec
, hda_nid_t nid
)
405 unsigned int digi1
= snd_hda_codec_read(codec
, nid
, 0,
406 AC_VERB_GET_DIGI_CONVERT_1
, 0);
407 unsigned char digi2
= digi1
>> 8;
408 unsigned char digi3
= digi1
>> 16;
410 snd_iprintf(buffer
, " Digital:");
411 if (digi1
& AC_DIG1_ENABLE
)
412 snd_iprintf(buffer
, " Enabled");
413 if (digi1
& AC_DIG1_V
)
414 snd_iprintf(buffer
, " Validity");
415 if (digi1
& AC_DIG1_VCFG
)
416 snd_iprintf(buffer
, " ValidityCfg");
417 if (digi1
& AC_DIG1_EMPHASIS
)
418 snd_iprintf(buffer
, " Preemphasis");
419 if (digi1
& AC_DIG1_COPYRIGHT
)
420 snd_iprintf(buffer
, " Non-Copyright");
421 if (digi1
& AC_DIG1_NONAUDIO
)
422 snd_iprintf(buffer
, " Non-Audio");
423 if (digi1
& AC_DIG1_PROFESSIONAL
)
424 snd_iprintf(buffer
, " Pro");
425 if (digi1
& AC_DIG1_LEVEL
)
426 snd_iprintf(buffer
, " GenLevel");
427 if (digi3
& AC_DIG3_KAE
)
428 snd_iprintf(buffer
, " KAE");
429 snd_iprintf(buffer
, "\n");
430 snd_iprintf(buffer
, " Digital category: 0x%x\n",
432 snd_iprintf(buffer
, " IEC Coding Type: 0x%x\n",
433 digi3
& AC_DIG3_ICT
);
436 static const char *get_pwr_state(u32 state
)
438 static const char * const buf
[] = {
439 "D0", "D1", "D2", "D3", "D3cold"
441 if (state
< ARRAY_SIZE(buf
))
446 static void print_power_state(struct snd_info_buffer
*buffer
,
447 struct hda_codec
*codec
, hda_nid_t nid
)
449 static char *names
[] = {
450 [ilog2(AC_PWRST_D0SUP
)] = "D0",
451 [ilog2(AC_PWRST_D1SUP
)] = "D1",
452 [ilog2(AC_PWRST_D2SUP
)] = "D2",
453 [ilog2(AC_PWRST_D3SUP
)] = "D3",
454 [ilog2(AC_PWRST_D3COLDSUP
)] = "D3cold",
455 [ilog2(AC_PWRST_S3D3COLDSUP
)] = "S3D3cold",
456 [ilog2(AC_PWRST_CLKSTOP
)] = "CLKSTOP",
457 [ilog2(AC_PWRST_EPSS
)] = "EPSS",
460 int sup
= snd_hda_param_read(codec
, nid
, AC_PAR_POWER_STATE
);
461 int pwr
= snd_hda_codec_read(codec
, nid
, 0,
462 AC_VERB_GET_POWER_STATE
, 0);
464 snd_iprintf(buffer
, " Power states: %s\n",
465 bits_names(sup
, names
, ARRAY_SIZE(names
)));
467 snd_iprintf(buffer
, " Power: setting=%s, actual=%s",
468 get_pwr_state(pwr
& AC_PWRST_SETTING
),
469 get_pwr_state((pwr
& AC_PWRST_ACTUAL
) >>
470 AC_PWRST_ACTUAL_SHIFT
));
471 if (pwr
& AC_PWRST_ERROR
)
472 snd_iprintf(buffer
, ", Error");
473 if (pwr
& AC_PWRST_CLK_STOP_OK
)
474 snd_iprintf(buffer
, ", Clock-stop-OK");
475 if (pwr
& AC_PWRST_SETTING_RESET
)
476 snd_iprintf(buffer
, ", Setting-reset");
477 snd_iprintf(buffer
, "\n");
480 static void print_unsol_cap(struct snd_info_buffer
*buffer
,
481 struct hda_codec
*codec
, hda_nid_t nid
)
483 int unsol
= snd_hda_codec_read(codec
, nid
, 0,
484 AC_VERB_GET_UNSOLICITED_RESPONSE
, 0);
486 " Unsolicited: tag=%02x, enabled=%d\n",
487 unsol
& AC_UNSOL_TAG
,
488 (unsol
& AC_UNSOL_ENABLED
) ? 1 : 0);
491 static void print_proc_caps(struct snd_info_buffer
*buffer
,
492 struct hda_codec
*codec
, hda_nid_t nid
)
494 unsigned int proc_caps
= snd_hda_param_read(codec
, nid
,
496 snd_iprintf(buffer
, " Processing caps: benign=%d, ncoeff=%d\n",
497 proc_caps
& AC_PCAP_BENIGN
,
498 (proc_caps
& AC_PCAP_NUM_COEF
) >> AC_PCAP_NUM_COEF_SHIFT
);
501 static void print_conn_list(struct snd_info_buffer
*buffer
,
502 struct hda_codec
*codec
, hda_nid_t nid
,
503 unsigned int wid_type
, hda_nid_t
*conn
,
509 wid_type
!= AC_WID_AUD_MIX
&&
510 wid_type
!= AC_WID_VOL_KNB
&&
511 wid_type
!= AC_WID_POWER
)
512 curr
= snd_hda_codec_read(codec
, nid
, 0,
513 AC_VERB_GET_CONNECT_SEL
, 0);
514 snd_iprintf(buffer
, " Connection: %d\n", conn_len
);
516 snd_iprintf(buffer
, " ");
517 for (c
= 0; c
< conn_len
; c
++) {
518 snd_iprintf(buffer
, " 0x%02x", conn
[c
]);
520 snd_iprintf(buffer
, "*");
522 snd_iprintf(buffer
, "\n");
526 static void print_gpio(struct snd_info_buffer
*buffer
,
527 struct hda_codec
*codec
, hda_nid_t nid
)
530 snd_hda_param_read(codec
, codec
->afg
, AC_PAR_GPIO_CAP
);
531 unsigned int enable
, direction
, wake
, unsol
, sticky
, data
;
533 snd_iprintf(buffer
, "GPIO: io=%d, o=%d, i=%d, "
534 "unsolicited=%d, wake=%d\n",
535 gpio
& AC_GPIO_IO_COUNT
,
536 (gpio
& AC_GPIO_O_COUNT
) >> AC_GPIO_O_COUNT_SHIFT
,
537 (gpio
& AC_GPIO_I_COUNT
) >> AC_GPIO_I_COUNT_SHIFT
,
538 (gpio
& AC_GPIO_UNSOLICITED
) ? 1 : 0,
539 (gpio
& AC_GPIO_WAKE
) ? 1 : 0);
540 max
= gpio
& AC_GPIO_IO_COUNT
;
543 enable
= snd_hda_codec_read(codec
, nid
, 0,
544 AC_VERB_GET_GPIO_MASK
, 0);
545 direction
= snd_hda_codec_read(codec
, nid
, 0,
546 AC_VERB_GET_GPIO_DIRECTION
, 0);
547 wake
= snd_hda_codec_read(codec
, nid
, 0,
548 AC_VERB_GET_GPIO_WAKE_MASK
, 0);
549 unsol
= snd_hda_codec_read(codec
, nid
, 0,
550 AC_VERB_GET_GPIO_UNSOLICITED_RSP_MASK
, 0);
551 sticky
= snd_hda_codec_read(codec
, nid
, 0,
552 AC_VERB_GET_GPIO_STICKY_MASK
, 0);
553 data
= snd_hda_codec_read(codec
, nid
, 0,
554 AC_VERB_GET_GPIO_DATA
, 0);
555 for (i
= 0; i
< max
; ++i
)
557 " IO[%d]: enable=%d, dir=%d, wake=%d, "
558 "sticky=%d, data=%d, unsol=%d\n", i
,
559 (enable
& (1<<i
)) ? 1 : 0,
560 (direction
& (1<<i
)) ? 1 : 0,
561 (wake
& (1<<i
)) ? 1 : 0,
562 (sticky
& (1<<i
)) ? 1 : 0,
563 (data
& (1<<i
)) ? 1 : 0,
564 (unsol
& (1<<i
)) ? 1 : 0);
565 /* FIXME: add GPO and GPI pin information */
566 print_nid_array(buffer
, codec
, nid
, &codec
->mixers
);
567 print_nid_array(buffer
, codec
, nid
, &codec
->nids
);
570 static void print_codec_info(struct snd_info_entry
*entry
,
571 struct snd_info_buffer
*buffer
)
573 struct hda_codec
*codec
= entry
->private_data
;
577 snd_iprintf(buffer
, "Codec: ");
578 if (codec
->vendor_name
&& codec
->chip_name
)
579 snd_iprintf(buffer
, "%s %s\n",
580 codec
->vendor_name
, codec
->chip_name
);
582 snd_iprintf(buffer
, "Not Set\n");
583 snd_iprintf(buffer
, "Address: %d\n", codec
->addr
);
585 snd_iprintf(buffer
, "AFG Function Id: 0x%x (unsol %u)\n",
586 codec
->afg_function_id
, codec
->afg_unsol
);
588 snd_iprintf(buffer
, "MFG Function Id: 0x%x (unsol %u)\n",
589 codec
->mfg_function_id
, codec
->mfg_unsol
);
590 snd_iprintf(buffer
, "Vendor Id: 0x%08x\n", codec
->vendor_id
);
591 snd_iprintf(buffer
, "Subsystem Id: 0x%08x\n", codec
->subsystem_id
);
592 snd_iprintf(buffer
, "Revision Id: 0x%x\n", codec
->revision_id
);
595 snd_iprintf(buffer
, "Modem Function Group: 0x%x\n", codec
->mfg
);
597 snd_iprintf(buffer
, "No Modem Function Group found\n");
601 snd_hda_power_up(codec
);
602 snd_iprintf(buffer
, "Default PCM:\n");
603 print_pcm_caps(buffer
, codec
, codec
->afg
);
604 snd_iprintf(buffer
, "Default Amp-In caps: ");
605 print_amp_caps(buffer
, codec
, codec
->afg
, HDA_INPUT
);
606 snd_iprintf(buffer
, "Default Amp-Out caps: ");
607 print_amp_caps(buffer
, codec
, codec
->afg
, HDA_OUTPUT
);
608 snd_iprintf(buffer
, "State of AFG node 0x%02x:\n", codec
->afg
);
609 print_power_state(buffer
, codec
, codec
->afg
);
611 nodes
= snd_hda_get_sub_nodes(codec
, codec
->afg
, &nid
);
612 if (! nid
|| nodes
< 0) {
613 snd_iprintf(buffer
, "Invalid AFG subtree\n");
614 snd_hda_power_down(codec
);
618 print_gpio(buffer
, codec
, codec
->afg
);
619 if (codec
->proc_widget_hook
)
620 codec
->proc_widget_hook(buffer
, codec
, codec
->afg
);
622 for (i
= 0; i
< nodes
; i
++, nid
++) {
623 unsigned int wid_caps
=
624 snd_hda_param_read(codec
, nid
,
625 AC_PAR_AUDIO_WIDGET_CAP
);
626 unsigned int wid_type
= get_wcaps_type(wid_caps
);
627 hda_nid_t
*conn
= NULL
;
630 snd_iprintf(buffer
, "Node 0x%02x [%s] wcaps 0x%x:", nid
,
631 get_wid_type_name(wid_type
), wid_caps
);
632 if (wid_caps
& AC_WCAP_STEREO
) {
633 unsigned int chans
= get_wcaps_channels(wid_caps
);
635 snd_iprintf(buffer
, " Stereo");
637 snd_iprintf(buffer
, " %d-Channels", chans
);
639 snd_iprintf(buffer
, " Mono");
640 if (wid_caps
& AC_WCAP_DIGITAL
)
641 snd_iprintf(buffer
, " Digital");
642 if (wid_caps
& AC_WCAP_IN_AMP
)
643 snd_iprintf(buffer
, " Amp-In");
644 if (wid_caps
& AC_WCAP_OUT_AMP
)
645 snd_iprintf(buffer
, " Amp-Out");
646 if (wid_caps
& AC_WCAP_STRIPE
)
647 snd_iprintf(buffer
, " Stripe");
648 if (wid_caps
& AC_WCAP_LR_SWAP
)
649 snd_iprintf(buffer
, " R/L");
650 if (wid_caps
& AC_WCAP_CP_CAPS
)
651 snd_iprintf(buffer
, " CP");
652 snd_iprintf(buffer
, "\n");
654 print_nid_array(buffer
, codec
, nid
, &codec
->mixers
);
655 print_nid_array(buffer
, codec
, nid
, &codec
->nids
);
656 print_nid_pcms(buffer
, codec
, nid
);
658 /* volume knob is a special widget that always have connection
661 if (wid_type
== AC_WID_VOL_KNB
)
662 wid_caps
|= AC_WCAP_CONN_LIST
;
664 if (wid_caps
& AC_WCAP_CONN_LIST
) {
665 conn_len
= snd_hda_get_num_raw_conns(codec
, nid
);
667 conn
= kmalloc(sizeof(hda_nid_t
) * conn_len
,
671 if (snd_hda_get_raw_connections(codec
, nid
, conn
,
677 if (wid_caps
& AC_WCAP_IN_AMP
) {
678 snd_iprintf(buffer
, " Amp-In caps: ");
679 print_amp_caps(buffer
, codec
, nid
, HDA_INPUT
);
680 snd_iprintf(buffer
, " Amp-In vals: ");
681 if (wid_type
== AC_WID_PIN
||
682 (codec
->single_adc_amp
&&
683 wid_type
== AC_WID_AUD_IN
))
684 print_amp_vals(buffer
, codec
, nid
, HDA_INPUT
,
685 wid_caps
& AC_WCAP_STEREO
,
688 print_amp_vals(buffer
, codec
, nid
, HDA_INPUT
,
689 wid_caps
& AC_WCAP_STEREO
,
692 if (wid_caps
& AC_WCAP_OUT_AMP
) {
693 snd_iprintf(buffer
, " Amp-Out caps: ");
694 print_amp_caps(buffer
, codec
, nid
, HDA_OUTPUT
);
695 snd_iprintf(buffer
, " Amp-Out vals: ");
696 if (wid_type
== AC_WID_PIN
&&
697 codec
->pin_amp_workaround
)
698 print_amp_vals(buffer
, codec
, nid
, HDA_OUTPUT
,
699 wid_caps
& AC_WCAP_STEREO
,
702 print_amp_vals(buffer
, codec
, nid
, HDA_OUTPUT
,
703 wid_caps
& AC_WCAP_STEREO
, 1);
709 print_pin_caps(buffer
, codec
, nid
, &supports_vref
);
710 print_pin_ctls(buffer
, codec
, nid
, supports_vref
);
714 print_vol_knob(buffer
, codec
, nid
);
718 print_audio_io(buffer
, codec
, nid
, wid_type
);
719 if (wid_caps
& AC_WCAP_DIGITAL
)
720 print_digital_conv(buffer
, codec
, nid
);
721 if (wid_caps
& AC_WCAP_FORMAT_OVRD
) {
722 snd_iprintf(buffer
, " PCM:\n");
723 print_pcm_caps(buffer
, codec
, nid
);
728 if (wid_caps
& AC_WCAP_UNSOL_CAP
)
729 print_unsol_cap(buffer
, codec
, nid
);
731 if (wid_caps
& AC_WCAP_POWER
)
732 print_power_state(buffer
, codec
, nid
);
734 if (wid_caps
& AC_WCAP_DELAY
)
735 snd_iprintf(buffer
, " Delay: %d samples\n",
736 (wid_caps
& AC_WCAP_DELAY
) >>
737 AC_WCAP_DELAY_SHIFT
);
739 if (wid_caps
& AC_WCAP_CONN_LIST
)
740 print_conn_list(buffer
, codec
, nid
, wid_type
,
743 if (wid_caps
& AC_WCAP_PROC_WID
)
744 print_proc_caps(buffer
, codec
, nid
);
746 if (codec
->proc_widget_hook
)
747 codec
->proc_widget_hook(buffer
, codec
, nid
);
751 snd_hda_power_down(codec
);
757 int snd_hda_codec_proc_new(struct hda_codec
*codec
)
760 struct snd_info_entry
*entry
;
763 snprintf(name
, sizeof(name
), "codec#%d", codec
->addr
);
764 err
= snd_card_proc_new(codec
->bus
->card
, name
, &entry
);
768 snd_info_set_text_ops(entry
, codec
, print_codec_info
);