1 /* 2 * Universal Interface for Intel High Definition Audio Codec 3 * 4 * Local helper functions 5 * 6 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de> 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the Free 10 * Software Foundation; either version 2 of the License, or (at your option) 11 * any later version. 12 * 13 * This program is distributed in the hope that it will be useful, but WITHOUT 14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 16 * more details. 17 * 18 * You should have received a copy of the GNU General Public License along with 19 * this program; if not, write to the Free Software Foundation, Inc., 59 20 * Temple Place - Suite 330, Boston, MA 02111-1307, USA. 21 */ 22 23 #ifndef __SOUND_HDA_LOCAL_H 24 #define __SOUND_HDA_LOCAL_H 25 26 /* 27 * for mixer controls 28 */ 29 #define HDA_COMPOSE_AMP_VAL_OFS(nid,chs,idx,dir,ofs) \ 30 ((nid) | ((chs)<<16) | ((dir)<<18) | ((idx)<<19) | ((ofs)<<23)) 31 #define HDA_COMPOSE_AMP_VAL(nid,chs,idx,dir) \ 32 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, idx, dir, 0) 33 /* mono volume with index (index=0,1,...) (channel=1,2) */ 34 #define HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \ 35 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \ 36 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \ 37 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ 38 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \ 39 .info = snd_hda_mixer_amp_volume_info, \ 40 .get = snd_hda_mixer_amp_volume_get, \ 41 .put = snd_hda_mixer_amp_volume_put, \ 42 .tlv = { .c = snd_hda_mixer_amp_tlv }, \ 43 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) } 44 /* stereo volume with index */ 45 #define HDA_CODEC_VOLUME_IDX(xname, xcidx, nid, xindex, direction) \ 46 HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, 3, xindex, direction) 47 /* mono volume */ 48 #define HDA_CODEC_VOLUME_MONO(xname, nid, channel, xindex, direction) \ 49 HDA_CODEC_VOLUME_MONO_IDX(xname, 0, nid, channel, xindex, direction) 50 /* stereo volume */ 51 #define HDA_CODEC_VOLUME(xname, nid, xindex, direction) \ 52 HDA_CODEC_VOLUME_MONO(xname, nid, 3, xindex, direction) 53 /* mono mute switch with index (index=0,1,...) (channel=1,2) */ 54 #define HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \ 55 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \ 56 .info = snd_hda_mixer_amp_switch_info, \ 57 .get = snd_hda_mixer_amp_switch_get, \ 58 .put = snd_hda_mixer_amp_switch_put, \ 59 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) } 60 /* stereo mute switch with index */ 61 #define HDA_CODEC_MUTE_IDX(xname, xcidx, nid, xindex, direction) \ 62 HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, 3, xindex, direction) 63 /* mono mute switch */ 64 #define HDA_CODEC_MUTE_MONO(xname, nid, channel, xindex, direction) \ 65 HDA_CODEC_MUTE_MONO_IDX(xname, 0, nid, channel, xindex, direction) 66 /* stereo mute switch */ 67 #define HDA_CODEC_MUTE(xname, nid, xindex, direction) \ 68 HDA_CODEC_MUTE_MONO(xname, nid, 3, xindex, direction) 69 70 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol, 71 struct snd_ctl_elem_info *uinfo); 72 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol, 73 struct snd_ctl_elem_value *ucontrol); 74 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol, 75 struct snd_ctl_elem_value *ucontrol); 76 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag, 77 unsigned int size, unsigned int __user *tlv); 78 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol, 79 struct snd_ctl_elem_info *uinfo); 80 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, 81 struct snd_ctl_elem_value *ucontrol); 82 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, 83 struct snd_ctl_elem_value *ucontrol); 84 /* lowlevel accessor with caching; use carefully */ 85 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch, 86 int direction, int index); 87 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch, 88 int direction, int idx, int mask, int val); 89 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid, 90 int dir, int idx, int mask, int val); 91 #ifdef SND_HDA_NEEDS_RESUME 92 void snd_hda_codec_resume_amp(struct hda_codec *codec); 93 #endif 94 95 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir, 96 unsigned int *tlv); 97 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec, 98 const char *name); 99 int snd_hda_add_vmaster(struct hda_codec *codec, char *name, 100 unsigned int *tlv, const char **slaves); 101 int snd_hda_codec_reset(struct hda_codec *codec); 102 int snd_hda_codec_configure(struct hda_codec *codec); 103 104 /* amp value bits */ 105 #define HDA_AMP_MUTE 0x80 106 #define HDA_AMP_UNMUTE 0x00 107 #define HDA_AMP_VOLMASK 0x7f 108 109 /* mono switch binding multiple inputs */ 110 #define HDA_BIND_MUTE_MONO(xname, nid, channel, indices, direction) \ 111 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 112 .info = snd_hda_mixer_amp_switch_info, \ 113 .get = snd_hda_mixer_bind_switch_get, \ 114 .put = snd_hda_mixer_bind_switch_put, \ 115 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, indices, direction) } 116 117 /* stereo switch binding multiple inputs */ 118 #define HDA_BIND_MUTE(xname,nid,indices,dir) \ 119 HDA_BIND_MUTE_MONO(xname,nid,3,indices,dir) 120 121 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, 122 struct snd_ctl_elem_value *ucontrol); 123 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, 124 struct snd_ctl_elem_value *ucontrol); 125 126 /* more generic bound controls */ 127 struct hda_ctl_ops { 128 snd_kcontrol_info_t *info; 129 snd_kcontrol_get_t *get; 130 snd_kcontrol_put_t *put; 131 snd_kcontrol_tlv_rw_t *tlv; 132 }; 133 134 extern struct hda_ctl_ops snd_hda_bind_vol; /* for bind-volume with TLV */ 135 extern struct hda_ctl_ops snd_hda_bind_sw; /* for bind-switch */ 136 137 struct hda_bind_ctls { 138 struct hda_ctl_ops *ops; 139 unsigned long values[]; 140 }; 141 142 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol, 143 struct snd_ctl_elem_info *uinfo); 144 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol, 145 struct snd_ctl_elem_value *ucontrol); 146 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol, 147 struct snd_ctl_elem_value *ucontrol); 148 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag, 149 unsigned int size, unsigned int __user *tlv); 150 151 #define HDA_BIND_VOL(xname, bindrec) \ 152 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 153 .name = xname, \ 154 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\ 155 SNDRV_CTL_ELEM_ACCESS_TLV_READ |\ 156 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK,\ 157 .info = snd_hda_mixer_bind_ctls_info,\ 158 .get = snd_hda_mixer_bind_ctls_get,\ 159 .put = snd_hda_mixer_bind_ctls_put,\ 160 .tlv = { .c = snd_hda_mixer_bind_tlv },\ 161 .private_value = (long) (bindrec) } 162 #define HDA_BIND_SW(xname, bindrec) \ 163 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\ 164 .name = xname, \ 165 .info = snd_hda_mixer_bind_ctls_info,\ 166 .get = snd_hda_mixer_bind_ctls_get,\ 167 .put = snd_hda_mixer_bind_ctls_put,\ 168 .private_value = (long) (bindrec) } 169 170 /* 171 * SPDIF I/O 172 */ 173 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid); 174 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid); 175 176 /* 177 * input MUX helper 178 */ 179 #define HDA_MAX_NUM_INPUTS 16 180 struct hda_input_mux_item { 181 const char *label; 182 unsigned int index; 183 }; 184 struct hda_input_mux { 185 unsigned int num_items; 186 struct hda_input_mux_item items[HDA_MAX_NUM_INPUTS]; 187 }; 188 189 int snd_hda_input_mux_info(const struct hda_input_mux *imux, 190 struct snd_ctl_elem_info *uinfo); 191 int snd_hda_input_mux_put(struct hda_codec *codec, 192 const struct hda_input_mux *imux, 193 struct snd_ctl_elem_value *ucontrol, hda_nid_t nid, 194 unsigned int *cur_val); 195 196 /* 197 * Channel mode helper 198 */ 199 struct hda_channel_mode { 200 int channels; 201 const struct hda_verb *sequence; 202 }; 203 204 int snd_hda_ch_mode_info(struct hda_codec *codec, 205 struct snd_ctl_elem_info *uinfo, 206 const struct hda_channel_mode *chmode, 207 int num_chmodes); 208 int snd_hda_ch_mode_get(struct hda_codec *codec, 209 struct snd_ctl_elem_value *ucontrol, 210 const struct hda_channel_mode *chmode, 211 int num_chmodes, 212 int max_channels); 213 int snd_hda_ch_mode_put(struct hda_codec *codec, 214 struct snd_ctl_elem_value *ucontrol, 215 const struct hda_channel_mode *chmode, 216 int num_chmodes, 217 int *max_channelsp); 218 219 /* 220 * Multi-channel / digital-out PCM helper 221 */ 222 223 enum { HDA_FRONT, HDA_REAR, HDA_CLFE, HDA_SIDE }; /* index for dac_nidx */ 224 enum { HDA_DIG_NONE, HDA_DIG_EXCLUSIVE, HDA_DIG_ANALOG_DUP }; /* dig_out_used */ 225 226 struct hda_multi_out { 227 int num_dacs; /* # of DACs, must be more than 1 */ 228 hda_nid_t *dac_nids; /* DAC list */ 229 hda_nid_t hp_nid; /* optional DAC for HP, 0 when not exists */ 230 hda_nid_t extra_out_nid[3]; /* optional DACs, 0 when not exists */ 231 hda_nid_t dig_out_nid; /* digital out audio widget */ 232 hda_nid_t *slave_dig_outs; 233 int max_channels; /* currently supported analog channels */ 234 int dig_out_used; /* current usage of digital out (HDA_DIG_XXX) */ 235 int no_share_stream; /* don't share a stream with multiple pins */ 236 int share_spdif; /* share SPDIF pin */ 237 /* PCM information for both analog and SPDIF DACs */ 238 unsigned int analog_rates; 239 unsigned int analog_maxbps; 240 u64 analog_formats; 241 unsigned int spdif_rates; 242 unsigned int spdif_maxbps; 243 u64 spdif_formats; 244 }; 245 246 int snd_hda_create_spdif_share_sw(struct hda_codec *codec, 247 struct hda_multi_out *mout); 248 int snd_hda_multi_out_dig_open(struct hda_codec *codec, 249 struct hda_multi_out *mout); 250 int snd_hda_multi_out_dig_close(struct hda_codec *codec, 251 struct hda_multi_out *mout); 252 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, 253 struct hda_multi_out *mout, 254 unsigned int stream_tag, 255 unsigned int format, 256 struct snd_pcm_substream *substream); 257 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec, 258 struct hda_multi_out *mout); 259 int snd_hda_multi_out_analog_open(struct hda_codec *codec, 260 struct hda_multi_out *mout, 261 struct snd_pcm_substream *substream, 262 struct hda_pcm_stream *hinfo); 263 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, 264 struct hda_multi_out *mout, 265 unsigned int stream_tag, 266 unsigned int format, 267 struct snd_pcm_substream *substream); 268 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, 269 struct hda_multi_out *mout); 270 271 /* 272 * generic codec parser 273 */ 274 #ifdef CONFIG_SND_HDA_GENERIC 275 int snd_hda_parse_generic_codec(struct hda_codec *codec); 276 #else 277 static inline int snd_hda_parse_generic_codec(struct hda_codec *codec) 278 { 279 return -ENODEV; 280 } 281 #endif 282 283 /* 284 * generic proc interface 285 */ 286 #ifdef CONFIG_PROC_FS 287 int snd_hda_codec_proc_new(struct hda_codec *codec); 288 #else 289 static inline int snd_hda_codec_proc_new(struct hda_codec *codec) { return 0; } 290 #endif 291 292 #define SND_PRINT_RATES_ADVISED_BUFSIZE 80 293 void snd_print_pcm_rates(int pcm, char *buf, int buflen); 294 295 #define SND_PRINT_BITS_ADVISED_BUFSIZE 16 296 void snd_print_pcm_bits(int pcm, char *buf, int buflen); 297 298 /* 299 * Misc 300 */ 301 int snd_hda_check_board_config(struct hda_codec *codec, int num_configs, 302 const char **modelnames, 303 const struct snd_pci_quirk *pci_list); 304 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec, 305 int num_configs, const char **models, 306 const struct snd_pci_quirk *tbl); 307 int snd_hda_add_new_ctls(struct hda_codec *codec, 308 struct snd_kcontrol_new *knew); 309 310 /* 311 * unsolicited event handler 312 */ 313 314 #define HDA_UNSOL_QUEUE_SIZE 64 315 316 struct hda_bus_unsolicited { 317 /* ring buffer */ 318 u32 queue[HDA_UNSOL_QUEUE_SIZE * 2]; 319 unsigned int rp, wp; 320 321 /* workqueue */ 322 struct work_struct work; 323 struct hda_bus *bus; 324 }; 325 326 /* 327 * Helper for automatic ping configuration 328 */ 329 330 enum { 331 AUTO_PIN_MIC, 332 AUTO_PIN_FRONT_MIC, 333 AUTO_PIN_LINE, 334 AUTO_PIN_FRONT_LINE, 335 AUTO_PIN_CD, 336 AUTO_PIN_AUX, 337 AUTO_PIN_LAST 338 }; 339 340 enum { 341 AUTO_PIN_LINE_OUT, 342 AUTO_PIN_SPEAKER_OUT, 343 AUTO_PIN_HP_OUT 344 }; 345 346 extern const char *auto_pin_cfg_labels[AUTO_PIN_LAST]; 347 348 #define AUTO_CFG_MAX_OUTS 5 349 350 struct auto_pin_cfg { 351 int line_outs; 352 /* sorted in the order of Front/Surr/CLFE/Side */ 353 hda_nid_t line_out_pins[AUTO_CFG_MAX_OUTS]; 354 int speaker_outs; 355 hda_nid_t speaker_pins[AUTO_CFG_MAX_OUTS]; 356 int hp_outs; 357 int line_out_type; /* AUTO_PIN_XXX_OUT */ 358 hda_nid_t hp_pins[AUTO_CFG_MAX_OUTS]; 359 hda_nid_t input_pins[AUTO_PIN_LAST]; 360 int dig_outs; 361 hda_nid_t dig_out_pins[2]; 362 hda_nid_t dig_in_pin; 363 hda_nid_t mono_out_pin; 364 int dig_out_type[2]; /* HDA_PCM_TYPE_XXX */ 365 int dig_in_type; /* HDA_PCM_TYPE_XXX */ 366 }; 367 368 #define get_defcfg_connect(cfg) \ 369 ((cfg & AC_DEFCFG_PORT_CONN) >> AC_DEFCFG_PORT_CONN_SHIFT) 370 #define get_defcfg_association(cfg) \ 371 ((cfg & AC_DEFCFG_DEF_ASSOC) >> AC_DEFCFG_ASSOC_SHIFT) 372 #define get_defcfg_location(cfg) \ 373 ((cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT) 374 #define get_defcfg_sequence(cfg) \ 375 (cfg & AC_DEFCFG_SEQUENCE) 376 #define get_defcfg_device(cfg) \ 377 ((cfg & AC_DEFCFG_DEVICE) >> AC_DEFCFG_DEVICE_SHIFT) 378 379 int snd_hda_parse_pin_def_config(struct hda_codec *codec, 380 struct auto_pin_cfg *cfg, 381 hda_nid_t *ignore_nids); 382 383 /* amp values */ 384 #define AMP_IN_MUTE(idx) (0x7080 | ((idx)<<8)) 385 #define AMP_IN_UNMUTE(idx) (0x7000 | ((idx)<<8)) 386 #define AMP_OUT_MUTE 0xb080 387 #define AMP_OUT_UNMUTE 0xb000 388 #define AMP_OUT_ZERO 0xb000 389 /* pinctl values */ 390 #define PIN_IN (AC_PINCTL_IN_EN) 391 #define PIN_VREFHIZ (AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ) 392 #define PIN_VREF50 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_50) 393 #define PIN_VREFGRD (AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD) 394 #define PIN_VREF80 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_80) 395 #define PIN_VREF100 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_100) 396 #define PIN_OUT (AC_PINCTL_OUT_EN) 397 #define PIN_HP (AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN) 398 #define PIN_HP_AMP (AC_PINCTL_HP_EN) 399 400 /* 401 * get widget capabilities 402 */ 403 static inline u32 get_wcaps(struct hda_codec *codec, hda_nid_t nid) 404 { 405 if (nid < codec->start_nid || 406 nid >= codec->start_nid + codec->num_nodes) 407 return 0; 408 return codec->wcaps[nid - codec->start_nid]; 409 } 410 411 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction); 412 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, 413 unsigned int caps); 414 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid); 415 416 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl); 417 void snd_hda_ctls_clear(struct hda_codec *codec); 418 419 /* 420 * hwdep interface 421 */ 422 #ifdef CONFIG_SND_HDA_HWDEP 423 int snd_hda_create_hwdep(struct hda_codec *codec); 424 #else 425 static inline int snd_hda_create_hwdep(struct hda_codec *codec) { return 0; } 426 #endif 427 428 #ifdef CONFIG_SND_HDA_RECONFIG 429 int snd_hda_hwdep_add_sysfs(struct hda_codec *codec); 430 #else 431 static inline int snd_hda_hwdep_add_sysfs(struct hda_codec *codec) 432 { 433 return 0; 434 } 435 #endif 436 437 #ifdef CONFIG_SND_HDA_RECONFIG 438 const char *snd_hda_get_hint(struct hda_codec *codec, const char *key); 439 int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key); 440 #else 441 static inline 442 const char *snd_hda_get_hint(struct hda_codec *codec, const char *key) 443 { 444 return NULL; 445 } 446 447 static inline 448 int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key) 449 { 450 return -ENOENT; 451 } 452 #endif 453 454 /* 455 * power-management 456 */ 457 458 #ifdef CONFIG_SND_HDA_POWER_SAVE 459 void snd_hda_schedule_power_save(struct hda_codec *codec); 460 461 struct hda_amp_list { 462 hda_nid_t nid; 463 unsigned char dir; 464 unsigned char idx; 465 }; 466 467 struct hda_loopback_check { 468 struct hda_amp_list *amplist; 469 int power_on; 470 }; 471 472 int snd_hda_check_amp_list_power(struct hda_codec *codec, 473 struct hda_loopback_check *check, 474 hda_nid_t nid); 475 #endif /* CONFIG_SND_HDA_POWER_SAVE */ 476 477 /* 478 * AMP control callbacks 479 */ 480 /* retrieve parameters from private_value */ 481 #define get_amp_nid(kc) ((kc)->private_value & 0xffff) 482 #define get_amp_channels(kc) (((kc)->private_value >> 16) & 0x3) 483 #define get_amp_direction(kc) (((kc)->private_value >> 18) & 0x1) 484 #define get_amp_index(kc) (((kc)->private_value >> 19) & 0xf) 485 #define get_amp_offset(kc) (((kc)->private_value >> 23) & 0x3f) 486 487 /* 488 * CEA Short Audio Descriptor data 489 */ 490 struct cea_sad { 491 int channels; 492 int format; /* (format == 0) indicates invalid SAD */ 493 int rates; 494 int sample_bits; /* for LPCM */ 495 int max_bitrate; /* for AC3...ATRAC */ 496 int profile; /* for WMAPRO */ 497 }; 498 499 #define ELD_FIXED_BYTES 20 500 #define ELD_MAX_MNL 16 501 #define ELD_MAX_SAD 16 502 503 /* 504 * ELD: EDID Like Data 505 */ 506 struct hdmi_eld { 507 int eld_size; 508 int baseline_len; 509 int eld_ver; /* (eld_ver == 0) indicates invalid ELD */ 510 int cea_edid_ver; 511 char monitor_name[ELD_MAX_MNL + 1]; 512 int manufacture_id; 513 int product_id; 514 u64 port_id; 515 int support_hdcp; 516 int support_ai; 517 int conn_type; 518 int aud_synch_delay; 519 int spk_alloc; 520 int sad_count; 521 struct cea_sad sad[ELD_MAX_SAD]; 522 #ifdef CONFIG_PROC_FS 523 struct snd_info_entry *proc_entry; 524 #endif 525 }; 526 527 int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid); 528 int snd_hdmi_get_eld(struct hdmi_eld *, struct hda_codec *, hda_nid_t); 529 void snd_hdmi_show_eld(struct hdmi_eld *eld); 530 531 #ifdef CONFIG_PROC_FS 532 int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld); 533 void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld); 534 #else 535 static inline int snd_hda_eld_proc_new(struct hda_codec *codec, 536 struct hdmi_eld *eld) 537 { 538 return 0; 539 } 540 static inline void snd_hda_eld_proc_free(struct hda_codec *codec, 541 struct hdmi_eld *eld) 542 { 543 } 544 #endif 545 546 #define SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE 80 547 void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen); 548 549 #endif /* __SOUND_HDA_LOCAL_H */ 550