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