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 103 /* amp value bits */ 104 #define HDA_AMP_MUTE 0x80 105 #define HDA_AMP_UNMUTE 0x00 106 #define HDA_AMP_VOLMASK 0x7f 107 108 /* mono switch binding multiple inputs */ 109 #define HDA_BIND_MUTE_MONO(xname, nid, channel, indices, direction) \ 110 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 111 .info = snd_hda_mixer_amp_switch_info, \ 112 .get = snd_hda_mixer_bind_switch_get, \ 113 .put = snd_hda_mixer_bind_switch_put, \ 114 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, indices, direction) } 115 116 /* stereo switch binding multiple inputs */ 117 #define HDA_BIND_MUTE(xname,nid,indices,dir) \ 118 HDA_BIND_MUTE_MONO(xname,nid,3,indices,dir) 119 120 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, 121 struct snd_ctl_elem_value *ucontrol); 122 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, 123 struct snd_ctl_elem_value *ucontrol); 124 125 /* more generic bound controls */ 126 struct hda_ctl_ops { 127 snd_kcontrol_info_t *info; 128 snd_kcontrol_get_t *get; 129 snd_kcontrol_put_t *put; 130 snd_kcontrol_tlv_rw_t *tlv; 131 }; 132 133 extern struct hda_ctl_ops snd_hda_bind_vol; /* for bind-volume with TLV */ 134 extern struct hda_ctl_ops snd_hda_bind_sw; /* for bind-switch */ 135 136 struct hda_bind_ctls { 137 struct hda_ctl_ops *ops; 138 unsigned long values[]; 139 }; 140 141 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol, 142 struct snd_ctl_elem_info *uinfo); 143 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol, 144 struct snd_ctl_elem_value *ucontrol); 145 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol, 146 struct snd_ctl_elem_value *ucontrol); 147 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag, 148 unsigned int size, unsigned int __user *tlv); 149 150 #define HDA_BIND_VOL(xname, bindrec) \ 151 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 152 .name = xname, \ 153 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\ 154 SNDRV_CTL_ELEM_ACCESS_TLV_READ |\ 155 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK,\ 156 .info = snd_hda_mixer_bind_ctls_info,\ 157 .get = snd_hda_mixer_bind_ctls_get,\ 158 .put = snd_hda_mixer_bind_ctls_put,\ 159 .tlv = { .c = snd_hda_mixer_bind_tlv },\ 160 .private_value = (long) (bindrec) } 161 #define HDA_BIND_SW(xname, bindrec) \ 162 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\ 163 .name = xname, \ 164 .info = snd_hda_mixer_bind_ctls_info,\ 165 .get = snd_hda_mixer_bind_ctls_get,\ 166 .put = snd_hda_mixer_bind_ctls_put,\ 167 .private_value = (long) (bindrec) } 168 169 /* 170 * SPDIF I/O 171 */ 172 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid); 173 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid); 174 175 /* 176 * input MUX helper 177 */ 178 #define HDA_MAX_NUM_INPUTS 16 179 struct hda_input_mux_item { 180 const char *label; 181 unsigned int index; 182 }; 183 struct hda_input_mux { 184 unsigned int num_items; 185 struct hda_input_mux_item items[HDA_MAX_NUM_INPUTS]; 186 }; 187 188 int snd_hda_input_mux_info(const struct hda_input_mux *imux, 189 struct snd_ctl_elem_info *uinfo); 190 int snd_hda_input_mux_put(struct hda_codec *codec, 191 const struct hda_input_mux *imux, 192 struct snd_ctl_elem_value *ucontrol, hda_nid_t nid, 193 unsigned int *cur_val); 194 195 /* 196 * Channel mode helper 197 */ 198 struct hda_channel_mode { 199 int channels; 200 const struct hda_verb *sequence; 201 }; 202 203 int snd_hda_ch_mode_info(struct hda_codec *codec, 204 struct snd_ctl_elem_info *uinfo, 205 const struct hda_channel_mode *chmode, 206 int num_chmodes); 207 int snd_hda_ch_mode_get(struct hda_codec *codec, 208 struct snd_ctl_elem_value *ucontrol, 209 const struct hda_channel_mode *chmode, 210 int num_chmodes, 211 int max_channels); 212 int snd_hda_ch_mode_put(struct hda_codec *codec, 213 struct snd_ctl_elem_value *ucontrol, 214 const struct hda_channel_mode *chmode, 215 int num_chmodes, 216 int *max_channelsp); 217 218 /* 219 * Multi-channel / digital-out PCM helper 220 */ 221 222 enum { HDA_FRONT, HDA_REAR, HDA_CLFE, HDA_SIDE }; /* index for dac_nidx */ 223 enum { HDA_DIG_NONE, HDA_DIG_EXCLUSIVE, HDA_DIG_ANALOG_DUP }; /* dig_out_used */ 224 225 struct hda_multi_out { 226 int num_dacs; /* # of DACs, must be more than 1 */ 227 hda_nid_t *dac_nids; /* DAC list */ 228 hda_nid_t hp_nid; /* optional DAC for HP, 0 when not exists */ 229 hda_nid_t extra_out_nid[3]; /* optional DACs, 0 when not exists */ 230 hda_nid_t dig_out_nid; /* digital out audio widget */ 231 hda_nid_t *slave_dig_outs; 232 int max_channels; /* currently supported analog channels */ 233 int dig_out_used; /* current usage of digital out (HDA_DIG_XXX) */ 234 int no_share_stream; /* don't share a stream with multiple pins */ 235 int share_spdif; /* share SPDIF pin */ 236 /* PCM information for both analog and SPDIF DACs */ 237 unsigned int analog_rates; 238 unsigned int analog_maxbps; 239 u64 analog_formats; 240 unsigned int spdif_rates; 241 unsigned int spdif_maxbps; 242 u64 spdif_formats; 243 }; 244 245 int snd_hda_create_spdif_share_sw(struct hda_codec *codec, 246 struct hda_multi_out *mout); 247 int snd_hda_multi_out_dig_open(struct hda_codec *codec, 248 struct hda_multi_out *mout); 249 int snd_hda_multi_out_dig_close(struct hda_codec *codec, 250 struct hda_multi_out *mout); 251 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, 252 struct hda_multi_out *mout, 253 unsigned int stream_tag, 254 unsigned int format, 255 struct snd_pcm_substream *substream); 256 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec, 257 struct hda_multi_out *mout); 258 int snd_hda_multi_out_analog_open(struct hda_codec *codec, 259 struct hda_multi_out *mout, 260 struct snd_pcm_substream *substream, 261 struct hda_pcm_stream *hinfo); 262 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, 263 struct hda_multi_out *mout, 264 unsigned int stream_tag, 265 unsigned int format, 266 struct snd_pcm_substream *substream); 267 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, 268 struct hda_multi_out *mout); 269 270 /* 271 * generic codec parser 272 */ 273 #ifdef CONFIG_SND_HDA_GENERIC 274 int snd_hda_parse_generic_codec(struct hda_codec *codec); 275 #else 276 static inline int snd_hda_parse_generic_codec(struct hda_codec *codec) 277 { 278 return -ENODEV; 279 } 280 #endif 281 282 /* 283 * generic proc interface 284 */ 285 #ifdef CONFIG_PROC_FS 286 int snd_hda_codec_proc_new(struct hda_codec *codec); 287 #else 288 static inline int snd_hda_codec_proc_new(struct hda_codec *codec) { return 0; } 289 #endif 290 291 #define SND_PRINT_RATES_ADVISED_BUFSIZE 80 292 void snd_print_pcm_rates(int pcm, char *buf, int buflen); 293 294 #define SND_PRINT_BITS_ADVISED_BUFSIZE 16 295 void snd_print_pcm_bits(int pcm, char *buf, int buflen); 296 297 /* 298 * Misc 299 */ 300 int snd_hda_check_board_config(struct hda_codec *codec, int num_configs, 301 const char **modelnames, 302 const struct snd_pci_quirk *pci_list); 303 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec, 304 int num_configs, const char **models, 305 const struct snd_pci_quirk *tbl); 306 int snd_hda_add_new_ctls(struct hda_codec *codec, 307 struct snd_kcontrol_new *knew); 308 309 /* 310 * unsolicited event handler 311 */ 312 313 #define HDA_UNSOL_QUEUE_SIZE 64 314 315 struct hda_bus_unsolicited { 316 /* ring buffer */ 317 u32 queue[HDA_UNSOL_QUEUE_SIZE * 2]; 318 unsigned int rp, wp; 319 320 /* workqueue */ 321 struct work_struct work; 322 struct hda_bus *bus; 323 }; 324 325 /* 326 * Helper for automatic ping configuration 327 */ 328 329 enum { 330 AUTO_PIN_MIC, 331 AUTO_PIN_FRONT_MIC, 332 AUTO_PIN_LINE, 333 AUTO_PIN_FRONT_LINE, 334 AUTO_PIN_CD, 335 AUTO_PIN_AUX, 336 AUTO_PIN_LAST 337 }; 338 339 enum { 340 AUTO_PIN_LINE_OUT, 341 AUTO_PIN_SPEAKER_OUT, 342 AUTO_PIN_HP_OUT 343 }; 344 345 extern const char *auto_pin_cfg_labels[AUTO_PIN_LAST]; 346 347 #define AUTO_CFG_MAX_OUTS 5 348 349 struct auto_pin_cfg { 350 int line_outs; 351 /* sorted in the order of Front/Surr/CLFE/Side */ 352 hda_nid_t line_out_pins[AUTO_CFG_MAX_OUTS]; 353 int speaker_outs; 354 hda_nid_t speaker_pins[AUTO_CFG_MAX_OUTS]; 355 int hp_outs; 356 int line_out_type; /* AUTO_PIN_XXX_OUT */ 357 hda_nid_t hp_pins[AUTO_CFG_MAX_OUTS]; 358 hda_nid_t input_pins[AUTO_PIN_LAST]; 359 int dig_outs; 360 hda_nid_t dig_out_pins[2]; 361 hda_nid_t dig_in_pin; 362 hda_nid_t mono_out_pin; 363 int dig_out_type[2]; /* HDA_PCM_TYPE_XXX */ 364 int dig_in_type; /* HDA_PCM_TYPE_XXX */ 365 }; 366 367 #define get_defcfg_connect(cfg) \ 368 ((cfg & AC_DEFCFG_PORT_CONN) >> AC_DEFCFG_PORT_CONN_SHIFT) 369 #define get_defcfg_association(cfg) \ 370 ((cfg & AC_DEFCFG_DEF_ASSOC) >> AC_DEFCFG_ASSOC_SHIFT) 371 #define get_defcfg_location(cfg) \ 372 ((cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT) 373 #define get_defcfg_sequence(cfg) \ 374 (cfg & AC_DEFCFG_SEQUENCE) 375 #define get_defcfg_device(cfg) \ 376 ((cfg & AC_DEFCFG_DEVICE) >> AC_DEFCFG_DEVICE_SHIFT) 377 378 int snd_hda_parse_pin_def_config(struct hda_codec *codec, 379 struct auto_pin_cfg *cfg, 380 hda_nid_t *ignore_nids); 381 382 /* amp values */ 383 #define AMP_IN_MUTE(idx) (0x7080 | ((idx)<<8)) 384 #define AMP_IN_UNMUTE(idx) (0x7000 | ((idx)<<8)) 385 #define AMP_OUT_MUTE 0xb080 386 #define AMP_OUT_UNMUTE 0xb000 387 #define AMP_OUT_ZERO 0xb000 388 /* pinctl values */ 389 #define PIN_IN (AC_PINCTL_IN_EN) 390 #define PIN_VREFHIZ (AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ) 391 #define PIN_VREF50 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_50) 392 #define PIN_VREFGRD (AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD) 393 #define PIN_VREF80 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_80) 394 #define PIN_VREF100 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_100) 395 #define PIN_OUT (AC_PINCTL_OUT_EN) 396 #define PIN_HP (AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN) 397 #define PIN_HP_AMP (AC_PINCTL_HP_EN) 398 399 /* 400 * get widget capabilities 401 */ 402 static inline u32 get_wcaps(struct hda_codec *codec, hda_nid_t nid) 403 { 404 if (nid < codec->start_nid || 405 nid >= codec->start_nid + codec->num_nodes) 406 return 0; 407 return codec->wcaps[nid - codec->start_nid]; 408 } 409 410 /* get the widget type from widget capability bits */ 411 #define get_wcaps_type(wcaps) (((wcaps) & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT) 412 413 static inline unsigned int get_wcaps_channels(u32 wcaps) 414 { 415 unsigned int chans; 416 417 chans = (wcaps & AC_WCAP_CHAN_CNT_EXT) >> 13; 418 chans = ((chans << 1) | 1) + 1; 419 420 return chans; 421 } 422 423 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction); 424 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, 425 unsigned int caps); 426 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid); 427 428 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl); 429 void snd_hda_ctls_clear(struct hda_codec *codec); 430 431 /* 432 * hwdep interface 433 */ 434 #ifdef CONFIG_SND_HDA_HWDEP 435 int snd_hda_create_hwdep(struct hda_codec *codec); 436 #else 437 static inline int snd_hda_create_hwdep(struct hda_codec *codec) { return 0; } 438 #endif 439 440 #ifdef CONFIG_SND_HDA_RECONFIG 441 int snd_hda_hwdep_add_sysfs(struct hda_codec *codec); 442 #else 443 static inline int snd_hda_hwdep_add_sysfs(struct hda_codec *codec) 444 { 445 return 0; 446 } 447 #endif 448 449 #ifdef CONFIG_SND_HDA_RECONFIG 450 const char *snd_hda_get_hint(struct hda_codec *codec, const char *key); 451 int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key); 452 #else 453 static inline 454 const char *snd_hda_get_hint(struct hda_codec *codec, const char *key) 455 { 456 return NULL; 457 } 458 459 static inline 460 int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key) 461 { 462 return -ENOENT; 463 } 464 #endif 465 466 /* 467 * power-management 468 */ 469 470 #ifdef CONFIG_SND_HDA_POWER_SAVE 471 void snd_hda_schedule_power_save(struct hda_codec *codec); 472 473 struct hda_amp_list { 474 hda_nid_t nid; 475 unsigned char dir; 476 unsigned char idx; 477 }; 478 479 struct hda_loopback_check { 480 struct hda_amp_list *amplist; 481 int power_on; 482 }; 483 484 int snd_hda_check_amp_list_power(struct hda_codec *codec, 485 struct hda_loopback_check *check, 486 hda_nid_t nid); 487 #endif /* CONFIG_SND_HDA_POWER_SAVE */ 488 489 /* 490 * AMP control callbacks 491 */ 492 /* retrieve parameters from private_value */ 493 #define get_amp_nid(kc) ((kc)->private_value & 0xffff) 494 #define get_amp_channels(kc) (((kc)->private_value >> 16) & 0x3) 495 #define get_amp_direction(kc) (((kc)->private_value >> 18) & 0x1) 496 #define get_amp_index(kc) (((kc)->private_value >> 19) & 0xf) 497 #define get_amp_offset(kc) (((kc)->private_value >> 23) & 0x3f) 498 499 /* 500 * CEA Short Audio Descriptor data 501 */ 502 struct cea_sad { 503 int channels; 504 int format; /* (format == 0) indicates invalid SAD */ 505 int rates; 506 int sample_bits; /* for LPCM */ 507 int max_bitrate; /* for AC3...ATRAC */ 508 int profile; /* for WMAPRO */ 509 }; 510 511 #define ELD_FIXED_BYTES 20 512 #define ELD_MAX_MNL 16 513 #define ELD_MAX_SAD 16 514 515 /* 516 * ELD: EDID Like Data 517 */ 518 struct hdmi_eld { 519 int eld_size; 520 int baseline_len; 521 int eld_ver; /* (eld_ver == 0) indicates invalid ELD */ 522 int cea_edid_ver; 523 char monitor_name[ELD_MAX_MNL + 1]; 524 int manufacture_id; 525 int product_id; 526 u64 port_id; 527 int support_hdcp; 528 int support_ai; 529 int conn_type; 530 int aud_synch_delay; 531 int spk_alloc; 532 int sad_count; 533 struct cea_sad sad[ELD_MAX_SAD]; 534 #ifdef CONFIG_PROC_FS 535 struct snd_info_entry *proc_entry; 536 #endif 537 }; 538 539 int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid); 540 int snd_hdmi_get_eld(struct hdmi_eld *, struct hda_codec *, hda_nid_t); 541 void snd_hdmi_show_eld(struct hdmi_eld *eld); 542 543 #ifdef CONFIG_PROC_FS 544 int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld); 545 void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld); 546 #else 547 static inline int snd_hda_eld_proc_new(struct hda_codec *codec, 548 struct hdmi_eld *eld) 549 { 550 return 0; 551 } 552 static inline void snd_hda_eld_proc_free(struct hda_codec *codec, 553 struct hdmi_eld *eld) 554 { 555 } 556 #endif 557 558 #define SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE 80 559 void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen); 560 561 #endif /* __SOUND_HDA_LOCAL_H */ 562