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