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 /* is this a stereo widget or a stereo-to-mono mix? */
133 static bool is_stereo_amps(struct hda_codec
*codec
, hda_nid_t nid
,
134 int dir
, unsigned int wcaps
, int indices
)
138 if (wcaps
& AC_WCAP_STEREO
)
140 /* check for a stereo-to-mono mix; it must be:
141 * only a single connection, only for input, and only a mixer widget
143 if (indices
!= 1 || dir
!= HDA_INPUT
||
144 get_wcaps_type(wcaps
) != AC_WID_AUD_MIX
)
147 if (snd_hda_get_raw_connections(codec
, nid
, &conn
, 1) < 0)
149 /* the connection source is a stereo? */
150 wcaps
= snd_hda_param_read(codec
, conn
, AC_PAR_AUDIO_WIDGET_CAP
);
151 return !!(wcaps
& AC_WCAP_STEREO
);
154 static void print_amp_vals(struct snd_info_buffer
*buffer
,
155 struct hda_codec
*codec
, hda_nid_t nid
,
156 int dir
, unsigned int wcaps
, int indices
)
162 stereo
= is_stereo_amps(codec
, nid
, dir
, wcaps
, indices
);
164 dir
= dir
== HDA_OUTPUT
? AC_AMP_GET_OUTPUT
: AC_AMP_GET_INPUT
;
165 for (i
= 0; i
< indices
; i
++) {
166 snd_iprintf(buffer
, " [");
167 val
= snd_hda_codec_read(codec
, nid
, 0,
168 AC_VERB_GET_AMP_GAIN_MUTE
,
169 AC_AMP_GET_LEFT
| dir
| i
);
170 snd_iprintf(buffer
, "0x%02x", val
);
172 val
= snd_hda_codec_read(codec
, nid
, 0,
173 AC_VERB_GET_AMP_GAIN_MUTE
,
174 AC_AMP_GET_RIGHT
| dir
| i
);
175 snd_iprintf(buffer
, " 0x%02x", val
);
177 snd_iprintf(buffer
, "]");
179 snd_iprintf(buffer
, "\n");
182 static void print_pcm_rates(struct snd_info_buffer
*buffer
, unsigned int pcm
)
184 static unsigned int rates
[] = {
185 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
186 96000, 176400, 192000, 384000
190 pcm
&= AC_SUPPCM_RATES
;
191 snd_iprintf(buffer
, " rates [0x%x]:", pcm
);
192 for (i
= 0; i
< ARRAY_SIZE(rates
); i
++)
194 snd_iprintf(buffer
, " %d", rates
[i
]);
195 snd_iprintf(buffer
, "\n");
198 static void print_pcm_bits(struct snd_info_buffer
*buffer
, unsigned int pcm
)
200 char buf
[SND_PRINT_BITS_ADVISED_BUFSIZE
];
202 snd_iprintf(buffer
, " bits [0x%x]:", (pcm
>> 16) & 0xff);
203 snd_print_pcm_bits(pcm
, buf
, sizeof(buf
));
204 snd_iprintf(buffer
, "%s\n", buf
);
207 static void print_pcm_formats(struct snd_info_buffer
*buffer
,
208 unsigned int streams
)
210 snd_iprintf(buffer
, " formats [0x%x]:", streams
& 0xf);
211 if (streams
& AC_SUPFMT_PCM
)
212 snd_iprintf(buffer
, " PCM");
213 if (streams
& AC_SUPFMT_FLOAT32
)
214 snd_iprintf(buffer
, " FLOAT");
215 if (streams
& AC_SUPFMT_AC3
)
216 snd_iprintf(buffer
, " AC3");
217 snd_iprintf(buffer
, "\n");
220 static void print_pcm_caps(struct snd_info_buffer
*buffer
,
221 struct hda_codec
*codec
, hda_nid_t nid
)
223 unsigned int pcm
= snd_hda_param_read(codec
, nid
, AC_PAR_PCM
);
224 unsigned int stream
= snd_hda_param_read(codec
, nid
, AC_PAR_STREAM
);
225 if (pcm
== -1 || stream
== -1) {
226 snd_iprintf(buffer
, "N/A\n");
229 print_pcm_rates(buffer
, pcm
);
230 print_pcm_bits(buffer
, pcm
);
231 print_pcm_formats(buffer
, stream
);
234 static const char *get_jack_connection(u32 cfg
)
236 static char *names
[16] = {
237 "Unknown", "1/8", "1/4", "ATAPI",
238 "RCA", "Optical","Digital", "Analog",
239 "DIN", "XLR", "RJ11", "Comb",
240 NULL
, NULL
, NULL
, "Other"
242 cfg
= (cfg
& AC_DEFCFG_CONN_TYPE
) >> AC_DEFCFG_CONN_TYPE_SHIFT
;
249 static const char *get_jack_color(u32 cfg
)
251 static char *names
[16] = {
252 "Unknown", "Black", "Grey", "Blue",
253 "Green", "Red", "Orange", "Yellow",
254 "Purple", "Pink", NULL
, NULL
,
255 NULL
, NULL
, "White", "Other",
257 cfg
= (cfg
& AC_DEFCFG_COLOR
) >> AC_DEFCFG_COLOR_SHIFT
;
264 static void print_pin_caps(struct snd_info_buffer
*buffer
,
265 struct hda_codec
*codec
, hda_nid_t nid
,
268 static char *jack_conns
[4] = { "Jack", "N/A", "Fixed", "Both" };
269 unsigned int caps
, val
;
271 caps
= snd_hda_param_read(codec
, nid
, AC_PAR_PIN_CAP
);
272 snd_iprintf(buffer
, " Pincap 0x%08x:", caps
);
273 if (caps
& AC_PINCAP_IN
)
274 snd_iprintf(buffer
, " IN");
275 if (caps
& AC_PINCAP_OUT
)
276 snd_iprintf(buffer
, " OUT");
277 if (caps
& AC_PINCAP_HP_DRV
)
278 snd_iprintf(buffer
, " HP");
279 if (caps
& AC_PINCAP_EAPD
)
280 snd_iprintf(buffer
, " EAPD");
281 if (caps
& AC_PINCAP_PRES_DETECT
)
282 snd_iprintf(buffer
, " Detect");
283 if (caps
& AC_PINCAP_BALANCE
)
284 snd_iprintf(buffer
, " Balanced");
285 if (caps
& AC_PINCAP_HDMI
) {
286 /* Realtek uses this bit as a different meaning */
287 if ((codec
->vendor_id
>> 16) == 0x10ec)
288 snd_iprintf(buffer
, " R/L");
290 if (caps
& AC_PINCAP_HBR
)
291 snd_iprintf(buffer
, " HBR");
292 snd_iprintf(buffer
, " HDMI");
295 if (caps
& AC_PINCAP_DP
)
296 snd_iprintf(buffer
, " DP");
297 if (caps
& AC_PINCAP_TRIG_REQ
)
298 snd_iprintf(buffer
, " Trigger");
299 if (caps
& AC_PINCAP_IMP_SENSE
)
300 snd_iprintf(buffer
, " ImpSense");
301 snd_iprintf(buffer
, "\n");
302 if (caps
& AC_PINCAP_VREF
) {
304 (caps
& AC_PINCAP_VREF
) >> AC_PINCAP_VREF_SHIFT
;
305 snd_iprintf(buffer
, " Vref caps:");
306 if (vref
& AC_PINCAP_VREF_HIZ
)
307 snd_iprintf(buffer
, " HIZ");
308 if (vref
& AC_PINCAP_VREF_50
)
309 snd_iprintf(buffer
, " 50");
310 if (vref
& AC_PINCAP_VREF_GRD
)
311 snd_iprintf(buffer
, " GRD");
312 if (vref
& AC_PINCAP_VREF_80
)
313 snd_iprintf(buffer
, " 80");
314 if (vref
& AC_PINCAP_VREF_100
)
315 snd_iprintf(buffer
, " 100");
316 snd_iprintf(buffer
, "\n");
320 if (caps
& AC_PINCAP_EAPD
) {
321 val
= snd_hda_codec_read(codec
, nid
, 0,
322 AC_VERB_GET_EAPD_BTLENABLE
, 0);
323 snd_iprintf(buffer
, " EAPD 0x%x:", val
);
324 if (val
& AC_EAPDBTL_BALANCED
)
325 snd_iprintf(buffer
, " BALANCED");
326 if (val
& AC_EAPDBTL_EAPD
)
327 snd_iprintf(buffer
, " EAPD");
328 if (val
& AC_EAPDBTL_LR_SWAP
)
329 snd_iprintf(buffer
, " R/L");
330 snd_iprintf(buffer
, "\n");
332 caps
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_CONFIG_DEFAULT
, 0);
333 snd_iprintf(buffer
, " Pin Default 0x%08x: [%s] %s at %s %s\n", caps
,
334 jack_conns
[(caps
& AC_DEFCFG_PORT_CONN
) >> AC_DEFCFG_PORT_CONN_SHIFT
],
335 snd_hda_get_jack_type(caps
),
336 snd_hda_get_jack_connectivity(caps
),
337 snd_hda_get_jack_location(caps
));
338 snd_iprintf(buffer
, " Conn = %s, Color = %s\n",
339 get_jack_connection(caps
),
340 get_jack_color(caps
));
341 /* Default association and sequence values refer to default grouping
342 * of pin complexes and their sequence within the group. This is used
343 * for priority and resource allocation.
345 snd_iprintf(buffer
, " DefAssociation = 0x%x, Sequence = 0x%x\n",
346 (caps
& AC_DEFCFG_DEF_ASSOC
) >> AC_DEFCFG_ASSOC_SHIFT
,
347 caps
& AC_DEFCFG_SEQUENCE
);
348 if (((caps
& AC_DEFCFG_MISC
) >> AC_DEFCFG_MISC_SHIFT
) &
349 AC_DEFCFG_MISC_NO_PRESENCE
) {
350 /* Miscellaneous bit indicates external hardware does not
351 * support presence detection even if the pin complex
352 * indicates it is supported.
354 snd_iprintf(buffer
, " Misc = NO_PRESENCE\n");
358 static void print_pin_ctls(struct snd_info_buffer
*buffer
,
359 struct hda_codec
*codec
, hda_nid_t nid
,
362 unsigned int pinctls
;
364 pinctls
= snd_hda_codec_read(codec
, nid
, 0,
365 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
366 snd_iprintf(buffer
, " Pin-ctls: 0x%02x:", pinctls
);
367 if (pinctls
& AC_PINCTL_IN_EN
)
368 snd_iprintf(buffer
, " IN");
369 if (pinctls
& AC_PINCTL_OUT_EN
)
370 snd_iprintf(buffer
, " OUT");
371 if (pinctls
& AC_PINCTL_HP_EN
)
372 snd_iprintf(buffer
, " HP");
374 int vref
= pinctls
& AC_PINCTL_VREFEN
;
376 case AC_PINCTL_VREF_HIZ
:
377 snd_iprintf(buffer
, " VREF_HIZ");
379 case AC_PINCTL_VREF_50
:
380 snd_iprintf(buffer
, " VREF_50");
382 case AC_PINCTL_VREF_GRD
:
383 snd_iprintf(buffer
, " VREF_GRD");
385 case AC_PINCTL_VREF_80
:
386 snd_iprintf(buffer
, " VREF_80");
388 case AC_PINCTL_VREF_100
:
389 snd_iprintf(buffer
, " VREF_100");
393 snd_iprintf(buffer
, "\n");
396 static void print_vol_knob(struct snd_info_buffer
*buffer
,
397 struct hda_codec
*codec
, hda_nid_t nid
)
399 unsigned int cap
= snd_hda_param_read(codec
, nid
,
401 snd_iprintf(buffer
, " Volume-Knob: delta=%d, steps=%d, ",
402 (cap
>> 7) & 1, cap
& 0x7f);
403 cap
= snd_hda_codec_read(codec
, nid
, 0,
404 AC_VERB_GET_VOLUME_KNOB_CONTROL
, 0);
405 snd_iprintf(buffer
, "direct=%d, val=%d\n",
406 (cap
>> 7) & 1, cap
& 0x7f);
409 static void print_audio_io(struct snd_info_buffer
*buffer
,
410 struct hda_codec
*codec
, hda_nid_t nid
,
411 unsigned int wid_type
)
413 int conv
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_CONV
, 0);
415 " Converter: stream=%d, channel=%d\n",
416 (conv
& AC_CONV_STREAM
) >> AC_CONV_STREAM_SHIFT
,
417 conv
& AC_CONV_CHANNEL
);
419 if (wid_type
== AC_WID_AUD_IN
&& (conv
& AC_CONV_CHANNEL
) == 0) {
420 int sdi
= snd_hda_codec_read(codec
, nid
, 0,
421 AC_VERB_GET_SDI_SELECT
, 0);
422 snd_iprintf(buffer
, " SDI-Select: %d\n",
423 sdi
& AC_SDI_SELECT
);
427 static void print_digital_conv(struct snd_info_buffer
*buffer
,
428 struct hda_codec
*codec
, hda_nid_t nid
)
430 unsigned int digi1
= snd_hda_codec_read(codec
, nid
, 0,
431 AC_VERB_GET_DIGI_CONVERT_1
, 0);
432 unsigned char digi2
= digi1
>> 8;
433 unsigned char digi3
= digi1
>> 16;
435 snd_iprintf(buffer
, " Digital:");
436 if (digi1
& AC_DIG1_ENABLE
)
437 snd_iprintf(buffer
, " Enabled");
438 if (digi1
& AC_DIG1_V
)
439 snd_iprintf(buffer
, " Validity");
440 if (digi1
& AC_DIG1_VCFG
)
441 snd_iprintf(buffer
, " ValidityCfg");
442 if (digi1
& AC_DIG1_EMPHASIS
)
443 snd_iprintf(buffer
, " Preemphasis");
444 if (digi1
& AC_DIG1_COPYRIGHT
)
445 snd_iprintf(buffer
, " Non-Copyright");
446 if (digi1
& AC_DIG1_NONAUDIO
)
447 snd_iprintf(buffer
, " Non-Audio");
448 if (digi1
& AC_DIG1_PROFESSIONAL
)
449 snd_iprintf(buffer
, " Pro");
450 if (digi1
& AC_DIG1_LEVEL
)
451 snd_iprintf(buffer
, " GenLevel");
452 if (digi3
& AC_DIG3_KAE
)
453 snd_iprintf(buffer
, " KAE");
454 snd_iprintf(buffer
, "\n");
455 snd_iprintf(buffer
, " Digital category: 0x%x\n",
457 snd_iprintf(buffer
, " IEC Coding Type: 0x%x\n",
458 digi3
& AC_DIG3_ICT
);
461 static const char *get_pwr_state(u32 state
)
463 static const char * const buf
[] = {
464 "D0", "D1", "D2", "D3", "D3cold"
466 if (state
< ARRAY_SIZE(buf
))
471 static void print_power_state(struct snd_info_buffer
*buffer
,
472 struct hda_codec
*codec
, hda_nid_t nid
)
474 static char *names
[] = {
475 [ilog2(AC_PWRST_D0SUP
)] = "D0",
476 [ilog2(AC_PWRST_D1SUP
)] = "D1",
477 [ilog2(AC_PWRST_D2SUP
)] = "D2",
478 [ilog2(AC_PWRST_D3SUP
)] = "D3",
479 [ilog2(AC_PWRST_D3COLDSUP
)] = "D3cold",
480 [ilog2(AC_PWRST_S3D3COLDSUP
)] = "S3D3cold",
481 [ilog2(AC_PWRST_CLKSTOP
)] = "CLKSTOP",
482 [ilog2(AC_PWRST_EPSS
)] = "EPSS",
485 int sup
= snd_hda_param_read(codec
, nid
, AC_PAR_POWER_STATE
);
486 int pwr
= snd_hda_codec_read(codec
, nid
, 0,
487 AC_VERB_GET_POWER_STATE
, 0);
489 snd_iprintf(buffer
, " Power states: %s\n",
490 bits_names(sup
, names
, ARRAY_SIZE(names
)));
492 snd_iprintf(buffer
, " Power: setting=%s, actual=%s",
493 get_pwr_state(pwr
& AC_PWRST_SETTING
),
494 get_pwr_state((pwr
& AC_PWRST_ACTUAL
) >>
495 AC_PWRST_ACTUAL_SHIFT
));
496 if (pwr
& AC_PWRST_ERROR
)
497 snd_iprintf(buffer
, ", Error");
498 if (pwr
& AC_PWRST_CLK_STOP_OK
)
499 snd_iprintf(buffer
, ", Clock-stop-OK");
500 if (pwr
& AC_PWRST_SETTING_RESET
)
501 snd_iprintf(buffer
, ", Setting-reset");
502 snd_iprintf(buffer
, "\n");
505 static void print_unsol_cap(struct snd_info_buffer
*buffer
,
506 struct hda_codec
*codec
, hda_nid_t nid
)
508 int unsol
= snd_hda_codec_read(codec
, nid
, 0,
509 AC_VERB_GET_UNSOLICITED_RESPONSE
, 0);
511 " Unsolicited: tag=%02x, enabled=%d\n",
512 unsol
& AC_UNSOL_TAG
,
513 (unsol
& AC_UNSOL_ENABLED
) ? 1 : 0);
516 static void print_proc_caps(struct snd_info_buffer
*buffer
,
517 struct hda_codec
*codec
, hda_nid_t nid
)
519 unsigned int proc_caps
= snd_hda_param_read(codec
, nid
,
521 snd_iprintf(buffer
, " Processing caps: benign=%d, ncoeff=%d\n",
522 proc_caps
& AC_PCAP_BENIGN
,
523 (proc_caps
& AC_PCAP_NUM_COEF
) >> AC_PCAP_NUM_COEF_SHIFT
);
526 static void print_conn_list(struct snd_info_buffer
*buffer
,
527 struct hda_codec
*codec
, hda_nid_t nid
,
528 unsigned int wid_type
, hda_nid_t
*conn
,
534 wid_type
!= AC_WID_AUD_MIX
&&
535 wid_type
!= AC_WID_VOL_KNB
&&
536 wid_type
!= AC_WID_POWER
)
537 curr
= snd_hda_codec_read(codec
, nid
, 0,
538 AC_VERB_GET_CONNECT_SEL
, 0);
539 snd_iprintf(buffer
, " Connection: %d\n", conn_len
);
541 snd_iprintf(buffer
, " ");
542 for (c
= 0; c
< conn_len
; c
++) {
543 snd_iprintf(buffer
, " 0x%02x", conn
[c
]);
545 snd_iprintf(buffer
, "*");
547 snd_iprintf(buffer
, "\n");
551 static void print_gpio(struct snd_info_buffer
*buffer
,
552 struct hda_codec
*codec
, hda_nid_t nid
)
555 snd_hda_param_read(codec
, codec
->afg
, AC_PAR_GPIO_CAP
);
556 unsigned int enable
, direction
, wake
, unsol
, sticky
, data
;
558 snd_iprintf(buffer
, "GPIO: io=%d, o=%d, i=%d, "
559 "unsolicited=%d, wake=%d\n",
560 gpio
& AC_GPIO_IO_COUNT
,
561 (gpio
& AC_GPIO_O_COUNT
) >> AC_GPIO_O_COUNT_SHIFT
,
562 (gpio
& AC_GPIO_I_COUNT
) >> AC_GPIO_I_COUNT_SHIFT
,
563 (gpio
& AC_GPIO_UNSOLICITED
) ? 1 : 0,
564 (gpio
& AC_GPIO_WAKE
) ? 1 : 0);
565 max
= gpio
& AC_GPIO_IO_COUNT
;
568 enable
= snd_hda_codec_read(codec
, nid
, 0,
569 AC_VERB_GET_GPIO_MASK
, 0);
570 direction
= snd_hda_codec_read(codec
, nid
, 0,
571 AC_VERB_GET_GPIO_DIRECTION
, 0);
572 wake
= snd_hda_codec_read(codec
, nid
, 0,
573 AC_VERB_GET_GPIO_WAKE_MASK
, 0);
574 unsol
= snd_hda_codec_read(codec
, nid
, 0,
575 AC_VERB_GET_GPIO_UNSOLICITED_RSP_MASK
, 0);
576 sticky
= snd_hda_codec_read(codec
, nid
, 0,
577 AC_VERB_GET_GPIO_STICKY_MASK
, 0);
578 data
= snd_hda_codec_read(codec
, nid
, 0,
579 AC_VERB_GET_GPIO_DATA
, 0);
580 for (i
= 0; i
< max
; ++i
)
582 " IO[%d]: enable=%d, dir=%d, wake=%d, "
583 "sticky=%d, data=%d, unsol=%d\n", i
,
584 (enable
& (1<<i
)) ? 1 : 0,
585 (direction
& (1<<i
)) ? 1 : 0,
586 (wake
& (1<<i
)) ? 1 : 0,
587 (sticky
& (1<<i
)) ? 1 : 0,
588 (data
& (1<<i
)) ? 1 : 0,
589 (unsol
& (1<<i
)) ? 1 : 0);
590 /* FIXME: add GPO and GPI pin information */
591 print_nid_array(buffer
, codec
, nid
, &codec
->mixers
);
592 print_nid_array(buffer
, codec
, nid
, &codec
->nids
);
595 static void print_codec_info(struct snd_info_entry
*entry
,
596 struct snd_info_buffer
*buffer
)
598 struct hda_codec
*codec
= entry
->private_data
;
602 snd_iprintf(buffer
, "Codec: ");
603 if (codec
->vendor_name
&& codec
->chip_name
)
604 snd_iprintf(buffer
, "%s %s\n",
605 codec
->vendor_name
, codec
->chip_name
);
607 snd_iprintf(buffer
, "Not Set\n");
608 snd_iprintf(buffer
, "Address: %d\n", codec
->addr
);
610 snd_iprintf(buffer
, "AFG Function Id: 0x%x (unsol %u)\n",
611 codec
->afg_function_id
, codec
->afg_unsol
);
613 snd_iprintf(buffer
, "MFG Function Id: 0x%x (unsol %u)\n",
614 codec
->mfg_function_id
, codec
->mfg_unsol
);
615 snd_iprintf(buffer
, "Vendor Id: 0x%08x\n", codec
->vendor_id
);
616 snd_iprintf(buffer
, "Subsystem Id: 0x%08x\n", codec
->subsystem_id
);
617 snd_iprintf(buffer
, "Revision Id: 0x%x\n", codec
->revision_id
);
620 snd_iprintf(buffer
, "Modem Function Group: 0x%x\n", codec
->mfg
);
622 snd_iprintf(buffer
, "No Modem Function Group found\n");
626 snd_hda_power_up(codec
);
627 snd_iprintf(buffer
, "Default PCM:\n");
628 print_pcm_caps(buffer
, codec
, codec
->afg
);
629 snd_iprintf(buffer
, "Default Amp-In caps: ");
630 print_amp_caps(buffer
, codec
, codec
->afg
, HDA_INPUT
);
631 snd_iprintf(buffer
, "Default Amp-Out caps: ");
632 print_amp_caps(buffer
, codec
, codec
->afg
, HDA_OUTPUT
);
633 snd_iprintf(buffer
, "State of AFG node 0x%02x:\n", codec
->afg
);
634 print_power_state(buffer
, codec
, codec
->afg
);
636 nodes
= snd_hda_get_sub_nodes(codec
, codec
->afg
, &nid
);
637 if (! nid
|| nodes
< 0) {
638 snd_iprintf(buffer
, "Invalid AFG subtree\n");
639 snd_hda_power_down(codec
);
643 print_gpio(buffer
, codec
, codec
->afg
);
644 if (codec
->proc_widget_hook
)
645 codec
->proc_widget_hook(buffer
, codec
, codec
->afg
);
647 for (i
= 0; i
< nodes
; i
++, nid
++) {
648 unsigned int wid_caps
=
649 snd_hda_param_read(codec
, nid
,
650 AC_PAR_AUDIO_WIDGET_CAP
);
651 unsigned int wid_type
= get_wcaps_type(wid_caps
);
652 hda_nid_t
*conn
= NULL
;
655 snd_iprintf(buffer
, "Node 0x%02x [%s] wcaps 0x%x:", nid
,
656 get_wid_type_name(wid_type
), wid_caps
);
657 if (wid_caps
& AC_WCAP_STEREO
) {
658 unsigned int chans
= get_wcaps_channels(wid_caps
);
660 snd_iprintf(buffer
, " Stereo");
662 snd_iprintf(buffer
, " %d-Channels", chans
);
664 snd_iprintf(buffer
, " Mono");
665 if (wid_caps
& AC_WCAP_DIGITAL
)
666 snd_iprintf(buffer
, " Digital");
667 if (wid_caps
& AC_WCAP_IN_AMP
)
668 snd_iprintf(buffer
, " Amp-In");
669 if (wid_caps
& AC_WCAP_OUT_AMP
)
670 snd_iprintf(buffer
, " Amp-Out");
671 if (wid_caps
& AC_WCAP_STRIPE
)
672 snd_iprintf(buffer
, " Stripe");
673 if (wid_caps
& AC_WCAP_LR_SWAP
)
674 snd_iprintf(buffer
, " R/L");
675 if (wid_caps
& AC_WCAP_CP_CAPS
)
676 snd_iprintf(buffer
, " CP");
677 snd_iprintf(buffer
, "\n");
679 print_nid_array(buffer
, codec
, nid
, &codec
->mixers
);
680 print_nid_array(buffer
, codec
, nid
, &codec
->nids
);
681 print_nid_pcms(buffer
, codec
, nid
);
683 /* volume knob is a special widget that always have connection
686 if (wid_type
== AC_WID_VOL_KNB
)
687 wid_caps
|= AC_WCAP_CONN_LIST
;
689 if (wid_caps
& AC_WCAP_CONN_LIST
) {
690 conn_len
= snd_hda_get_num_raw_conns(codec
, nid
);
692 conn
= kmalloc(sizeof(hda_nid_t
) * conn_len
,
696 if (snd_hda_get_raw_connections(codec
, nid
, conn
,
702 if (wid_caps
& AC_WCAP_IN_AMP
) {
703 snd_iprintf(buffer
, " Amp-In caps: ");
704 print_amp_caps(buffer
, codec
, nid
, HDA_INPUT
);
705 snd_iprintf(buffer
, " Amp-In vals: ");
706 if (wid_type
== AC_WID_PIN
||
707 (codec
->single_adc_amp
&&
708 wid_type
== AC_WID_AUD_IN
))
709 print_amp_vals(buffer
, codec
, nid
, HDA_INPUT
,
712 print_amp_vals(buffer
, codec
, nid
, HDA_INPUT
,
715 if (wid_caps
& AC_WCAP_OUT_AMP
) {
716 snd_iprintf(buffer
, " Amp-Out caps: ");
717 print_amp_caps(buffer
, codec
, nid
, HDA_OUTPUT
);
718 snd_iprintf(buffer
, " Amp-Out vals: ");
719 if (wid_type
== AC_WID_PIN
&&
720 codec
->pin_amp_workaround
)
721 print_amp_vals(buffer
, codec
, nid
, HDA_OUTPUT
,
724 print_amp_vals(buffer
, codec
, nid
, HDA_OUTPUT
,
731 print_pin_caps(buffer
, codec
, nid
, &supports_vref
);
732 print_pin_ctls(buffer
, codec
, nid
, supports_vref
);
736 print_vol_knob(buffer
, codec
, nid
);
740 print_audio_io(buffer
, codec
, nid
, wid_type
);
741 if (wid_caps
& AC_WCAP_DIGITAL
)
742 print_digital_conv(buffer
, codec
, nid
);
743 if (wid_caps
& AC_WCAP_FORMAT_OVRD
) {
744 snd_iprintf(buffer
, " PCM:\n");
745 print_pcm_caps(buffer
, codec
, nid
);
750 if (wid_caps
& AC_WCAP_UNSOL_CAP
)
751 print_unsol_cap(buffer
, codec
, nid
);
753 if (wid_caps
& AC_WCAP_POWER
)
754 print_power_state(buffer
, codec
, nid
);
756 if (wid_caps
& AC_WCAP_DELAY
)
757 snd_iprintf(buffer
, " Delay: %d samples\n",
758 (wid_caps
& AC_WCAP_DELAY
) >>
759 AC_WCAP_DELAY_SHIFT
);
761 if (wid_caps
& AC_WCAP_CONN_LIST
)
762 print_conn_list(buffer
, codec
, nid
, wid_type
,
765 if (wid_caps
& AC_WCAP_PROC_WID
)
766 print_proc_caps(buffer
, codec
, nid
);
768 if (codec
->proc_widget_hook
)
769 codec
->proc_widget_hook(buffer
, codec
, nid
);
773 snd_hda_power_down(codec
);
779 int snd_hda_codec_proc_new(struct hda_codec
*codec
)
782 struct snd_info_entry
*entry
;
785 snprintf(name
, sizeof(name
), "codec#%d", codec
->addr
);
786 err
= snd_card_proc_new(codec
->bus
->card
, name
, &entry
);
790 snd_info_set_text_ops(entry
, codec
, print_codec_info
);