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_beep, \ 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_get_beep(struct snd_kcontrol *kcontrol, 125 struct snd_ctl_elem_value *ucontrol); 126 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol, 127 struct snd_ctl_elem_value *ucontrol); 128 #endif 129 /* lowlevel accessor with caching; use carefully */ 130 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch, 131 int direction, int index); 132 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch, 133 int direction, int idx, int mask, int val); 134 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid, 135 int dir, int idx, int mask, int val); 136 int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch, 137 int direction, int idx, int mask, int val); 138 int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid, 139 int dir, int idx, int mask, int val); 140 void snd_hda_codec_resume_amp(struct hda_codec *codec); 141 142 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir, 143 unsigned int *tlv); 144 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec, 145 const char *name); 146 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name, 147 unsigned int *tlv, const char * const *slaves, 148 const char *suffix, bool init_slave_vol, 149 struct snd_kcontrol **ctl_ret); 150 #define snd_hda_add_vmaster(codec, name, tlv, slaves, suffix) \ 151 __snd_hda_add_vmaster(codec, name, tlv, slaves, suffix, true, NULL) 152 int snd_hda_codec_reset(struct hda_codec *codec); 153 154 enum { 155 HDA_VMUTE_OFF, 156 HDA_VMUTE_ON, 157 HDA_VMUTE_FOLLOW_MASTER, 158 }; 159 160 struct hda_vmaster_mute_hook { 161 /* below two fields must be filled by the caller of 162 * snd_hda_add_vmaster_hook() beforehand 163 */ 164 struct snd_kcontrol *sw_kctl; 165 void (*hook)(void *, int); 166 /* below are initialized automatically */ 167 unsigned int mute_mode; /* HDA_VMUTE_XXX */ 168 struct hda_codec *codec; 169 }; 170 171 int snd_hda_add_vmaster_hook(struct hda_codec *codec, 172 struct hda_vmaster_mute_hook *hook, 173 bool expose_enum_ctl); 174 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook); 175 176 /* amp value bits */ 177 #define HDA_AMP_MUTE 0x80 178 #define HDA_AMP_UNMUTE 0x00 179 #define HDA_AMP_VOLMASK 0x7f 180 181 /* mono switch binding multiple inputs */ 182 #define HDA_BIND_MUTE_MONO(xname, nid, channel, indices, direction) \ 183 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 184 .info = snd_hda_mixer_amp_switch_info, \ 185 .get = snd_hda_mixer_bind_switch_get, \ 186 .put = snd_hda_mixer_bind_switch_put, \ 187 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, indices, direction) } 188 189 /* stereo switch binding multiple inputs */ 190 #define HDA_BIND_MUTE(xname,nid,indices,dir) \ 191 HDA_BIND_MUTE_MONO(xname,nid,3,indices,dir) 192 193 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, 194 struct snd_ctl_elem_value *ucontrol); 195 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, 196 struct snd_ctl_elem_value *ucontrol); 197 198 /* more generic bound controls */ 199 struct hda_ctl_ops { 200 snd_kcontrol_info_t *info; 201 snd_kcontrol_get_t *get; 202 snd_kcontrol_put_t *put; 203 snd_kcontrol_tlv_rw_t *tlv; 204 }; 205 206 extern struct hda_ctl_ops snd_hda_bind_vol; /* for bind-volume with TLV */ 207 extern struct hda_ctl_ops snd_hda_bind_sw; /* for bind-switch */ 208 209 struct hda_bind_ctls { 210 struct hda_ctl_ops *ops; 211 unsigned long values[]; 212 }; 213 214 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol, 215 struct snd_ctl_elem_info *uinfo); 216 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol, 217 struct snd_ctl_elem_value *ucontrol); 218 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol, 219 struct snd_ctl_elem_value *ucontrol); 220 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag, 221 unsigned int size, unsigned int __user *tlv); 222 223 #define HDA_BIND_VOL(xname, bindrec) \ 224 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 225 .name = xname, \ 226 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\ 227 SNDRV_CTL_ELEM_ACCESS_TLV_READ |\ 228 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK,\ 229 .info = snd_hda_mixer_bind_ctls_info,\ 230 .get = snd_hda_mixer_bind_ctls_get,\ 231 .put = snd_hda_mixer_bind_ctls_put,\ 232 .tlv = { .c = snd_hda_mixer_bind_tlv },\ 233 .private_value = (long) (bindrec) } 234 #define HDA_BIND_SW(xname, bindrec) \ 235 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\ 236 .name = xname, \ 237 .info = snd_hda_mixer_bind_ctls_info,\ 238 .get = snd_hda_mixer_bind_ctls_get,\ 239 .put = snd_hda_mixer_bind_ctls_put,\ 240 .private_value = (long) (bindrec) } 241 242 /* 243 * SPDIF I/O 244 */ 245 int snd_hda_create_dig_out_ctls(struct hda_codec *codec, 246 hda_nid_t associated_nid, 247 hda_nid_t cvt_nid, int type); 248 #define snd_hda_create_spdif_out_ctls(codec, anid, cnid) \ 249 snd_hda_create_dig_out_ctls(codec, anid, cnid, HDA_PCM_TYPE_SPDIF) 250 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid); 251 252 /* 253 * input MUX helper 254 */ 255 #define HDA_MAX_NUM_INPUTS 16 256 struct hda_input_mux_item { 257 char label[32]; 258 unsigned int index; 259 }; 260 struct hda_input_mux { 261 unsigned int num_items; 262 struct hda_input_mux_item items[HDA_MAX_NUM_INPUTS]; 263 }; 264 265 int snd_hda_input_mux_info(const struct hda_input_mux *imux, 266 struct snd_ctl_elem_info *uinfo); 267 int snd_hda_input_mux_put(struct hda_codec *codec, 268 const struct hda_input_mux *imux, 269 struct snd_ctl_elem_value *ucontrol, hda_nid_t nid, 270 unsigned int *cur_val); 271 int snd_hda_add_imux_item(struct hda_codec *codec, 272 struct hda_input_mux *imux, const char *label, 273 int index, int *type_index_ret); 274 275 /* 276 * Channel mode helper 277 */ 278 struct hda_channel_mode { 279 int channels; 280 const struct hda_verb *sequence; 281 }; 282 283 int snd_hda_ch_mode_info(struct hda_codec *codec, 284 struct snd_ctl_elem_info *uinfo, 285 const struct hda_channel_mode *chmode, 286 int num_chmodes); 287 int snd_hda_ch_mode_get(struct hda_codec *codec, 288 struct snd_ctl_elem_value *ucontrol, 289 const struct hda_channel_mode *chmode, 290 int num_chmodes, 291 int max_channels); 292 int snd_hda_ch_mode_put(struct hda_codec *codec, 293 struct snd_ctl_elem_value *ucontrol, 294 const struct hda_channel_mode *chmode, 295 int num_chmodes, 296 int *max_channelsp); 297 298 /* 299 * Multi-channel / digital-out PCM helper 300 */ 301 302 enum { HDA_FRONT, HDA_REAR, HDA_CLFE, HDA_SIDE }; /* index for dac_nidx */ 303 enum { HDA_DIG_NONE, HDA_DIG_EXCLUSIVE, HDA_DIG_ANALOG_DUP }; /* dig_out_used */ 304 305 #define HDA_MAX_OUTS 5 306 307 struct hda_multi_out { 308 int num_dacs; /* # of DACs, must be more than 1 */ 309 const hda_nid_t *dac_nids; /* DAC list */ 310 hda_nid_t hp_nid; /* optional DAC for HP, 0 when not exists */ 311 hda_nid_t hp_out_nid[HDA_MAX_OUTS]; /* DACs for multiple HPs */ 312 hda_nid_t extra_out_nid[HDA_MAX_OUTS]; /* other (e.g. speaker) DACs */ 313 hda_nid_t dig_out_nid; /* digital out audio widget */ 314 const hda_nid_t *slave_dig_outs; 315 int max_channels; /* currently supported analog channels */ 316 int dig_out_used; /* current usage of digital out (HDA_DIG_XXX) */ 317 int no_share_stream; /* don't share a stream with multiple pins */ 318 int share_spdif; /* share SPDIF pin */ 319 /* PCM information for both analog and SPDIF DACs */ 320 unsigned int analog_rates; 321 unsigned int analog_maxbps; 322 u64 analog_formats; 323 unsigned int spdif_rates; 324 unsigned int spdif_maxbps; 325 u64 spdif_formats; 326 }; 327 328 int snd_hda_create_spdif_share_sw(struct hda_codec *codec, 329 struct hda_multi_out *mout); 330 int snd_hda_multi_out_dig_open(struct hda_codec *codec, 331 struct hda_multi_out *mout); 332 int snd_hda_multi_out_dig_close(struct hda_codec *codec, 333 struct hda_multi_out *mout); 334 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, 335 struct hda_multi_out *mout, 336 unsigned int stream_tag, 337 unsigned int format, 338 struct snd_pcm_substream *substream); 339 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec, 340 struct hda_multi_out *mout); 341 int snd_hda_multi_out_analog_open(struct hda_codec *codec, 342 struct hda_multi_out *mout, 343 struct snd_pcm_substream *substream, 344 struct hda_pcm_stream *hinfo); 345 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, 346 struct hda_multi_out *mout, 347 unsigned int stream_tag, 348 unsigned int format, 349 struct snd_pcm_substream *substream); 350 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, 351 struct hda_multi_out *mout); 352 353 /* 354 * generic codec parser 355 */ 356 int snd_hda_parse_generic_codec(struct hda_codec *codec); 357 int snd_hda_parse_hdmi_codec(struct hda_codec *codec); 358 359 /* 360 * generic proc interface 361 */ 362 #ifdef CONFIG_PROC_FS 363 int snd_hda_codec_proc_new(struct hda_codec *codec); 364 #else 365 static inline int snd_hda_codec_proc_new(struct hda_codec *codec) { return 0; } 366 #endif 367 368 #define SND_PRINT_BITS_ADVISED_BUFSIZE 16 369 void snd_print_pcm_bits(int pcm, char *buf, int buflen); 370 371 /* 372 * Misc 373 */ 374 int snd_hda_add_new_ctls(struct hda_codec *codec, 375 const struct snd_kcontrol_new *knew); 376 377 /* 378 * Fix-up pin default configurations and add default verbs 379 */ 380 381 struct hda_pintbl { 382 hda_nid_t nid; 383 u32 val; 384 }; 385 386 struct hda_model_fixup { 387 const int id; 388 const char *name; 389 }; 390 391 struct hda_fixup { 392 int type; 393 bool chained:1; /* call the chained fixup(s) after this */ 394 bool chained_before:1; /* call the chained fixup(s) before this */ 395 int chain_id; 396 union { 397 const struct hda_pintbl *pins; 398 const struct hda_verb *verbs; 399 void (*func)(struct hda_codec *codec, 400 const struct hda_fixup *fix, 401 int action); 402 } v; 403 }; 404 405 struct snd_hda_pin_quirk { 406 unsigned int codec; /* Codec vendor/device ID */ 407 unsigned short subvendor; /* PCI subvendor ID */ 408 const struct hda_pintbl *pins; /* list of matching pins */ 409 #ifdef CONFIG_SND_DEBUG_VERBOSE 410 const char *name; 411 #endif 412 int value; /* quirk value */ 413 }; 414 415 #ifdef CONFIG_SND_DEBUG_VERBOSE 416 417 #define SND_HDA_PIN_QUIRK(_codec, _subvendor, _name, _value, _pins...) \ 418 { .codec = _codec,\ 419 .subvendor = _subvendor,\ 420 .name = _name,\ 421 .value = _value,\ 422 .pins = (const struct hda_pintbl[]) { _pins, {0, 0}} \ 423 } 424 #else 425 426 #define SND_HDA_PIN_QUIRK(_codec, _subvendor, _name, _value, _pins...) \ 427 { .codec = _codec,\ 428 .subvendor = _subvendor,\ 429 .value = _value,\ 430 .pins = (const struct hda_pintbl[]) { _pins, {0, 0}} \ 431 } 432 433 #endif 434 435 #define HDA_FIXUP_ID_NOT_SET -1 436 #define HDA_FIXUP_ID_NO_FIXUP -2 437 438 /* fixup types */ 439 enum { 440 HDA_FIXUP_INVALID, 441 HDA_FIXUP_PINS, 442 HDA_FIXUP_VERBS, 443 HDA_FIXUP_FUNC, 444 HDA_FIXUP_PINCTLS, 445 }; 446 447 /* fixup action definitions */ 448 enum { 449 HDA_FIXUP_ACT_PRE_PROBE, 450 HDA_FIXUP_ACT_PROBE, 451 HDA_FIXUP_ACT_INIT, 452 HDA_FIXUP_ACT_BUILD, 453 HDA_FIXUP_ACT_FREE, 454 }; 455 456 int snd_hda_add_verbs(struct hda_codec *codec, const struct hda_verb *list); 457 void snd_hda_apply_verbs(struct hda_codec *codec); 458 void snd_hda_apply_pincfgs(struct hda_codec *codec, 459 const struct hda_pintbl *cfg); 460 void snd_hda_apply_fixup(struct hda_codec *codec, int action); 461 void snd_hda_pick_fixup(struct hda_codec *codec, 462 const struct hda_model_fixup *models, 463 const struct snd_pci_quirk *quirk, 464 const struct hda_fixup *fixlist); 465 void snd_hda_pick_pin_fixup(struct hda_codec *codec, 466 const struct snd_hda_pin_quirk *pin_quirk, 467 const struct hda_fixup *fixlist); 468 469 470 /* 471 * unsolicited event handler 472 */ 473 474 #define HDA_UNSOL_QUEUE_SIZE 64 475 476 struct hda_bus_unsolicited { 477 /* ring buffer */ 478 u32 queue[HDA_UNSOL_QUEUE_SIZE * 2]; 479 unsigned int rp, wp; 480 481 /* workqueue */ 482 struct work_struct work; 483 struct hda_bus *bus; 484 }; 485 486 /* helper macros to retrieve pin default-config values */ 487 #define get_defcfg_connect(cfg) \ 488 ((cfg & AC_DEFCFG_PORT_CONN) >> AC_DEFCFG_PORT_CONN_SHIFT) 489 #define get_defcfg_association(cfg) \ 490 ((cfg & AC_DEFCFG_DEF_ASSOC) >> AC_DEFCFG_ASSOC_SHIFT) 491 #define get_defcfg_location(cfg) \ 492 ((cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT) 493 #define get_defcfg_sequence(cfg) \ 494 (cfg & AC_DEFCFG_SEQUENCE) 495 #define get_defcfg_device(cfg) \ 496 ((cfg & AC_DEFCFG_DEVICE) >> AC_DEFCFG_DEVICE_SHIFT) 497 #define get_defcfg_misc(cfg) \ 498 ((cfg & AC_DEFCFG_MISC) >> AC_DEFCFG_MISC_SHIFT) 499 500 /* amp values */ 501 #define AMP_IN_MUTE(idx) (0x7080 | ((idx)<<8)) 502 #define AMP_IN_UNMUTE(idx) (0x7000 | ((idx)<<8)) 503 #define AMP_OUT_MUTE 0xb080 504 #define AMP_OUT_UNMUTE 0xb000 505 #define AMP_OUT_ZERO 0xb000 506 /* pinctl values */ 507 #define PIN_IN (AC_PINCTL_IN_EN) 508 #define PIN_VREFHIZ (AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ) 509 #define PIN_VREF50 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_50) 510 #define PIN_VREFGRD (AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD) 511 #define PIN_VREF80 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_80) 512 #define PIN_VREF100 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_100) 513 #define PIN_OUT (AC_PINCTL_OUT_EN) 514 #define PIN_HP (AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN) 515 #define PIN_HP_AMP (AC_PINCTL_HP_EN) 516 517 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin); 518 unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec, 519 hda_nid_t pin, unsigned int val); 520 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin, 521 unsigned int val, bool cached); 522 523 /** 524 * _snd_hda_set_pin_ctl - Set a pin-control value safely 525 * @codec: the codec instance 526 * @pin: the pin NID to set the control 527 * @val: the pin-control value (AC_PINCTL_* bits) 528 * 529 * This function sets the pin-control value to the given pin, but 530 * filters out the invalid pin-control bits when the pin has no such 531 * capabilities. For example, when PIN_HP is passed but the pin has no 532 * HP-drive capability, the HP bit is omitted. 533 * 534 * The function doesn't check the input VREF capability bits, though. 535 * Use snd_hda_get_default_vref() to guess the right value. 536 * Also, this function is only for analog pins, not for HDMI pins. 537 */ 538 static inline int 539 snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin, unsigned int val) 540 { 541 return _snd_hda_set_pin_ctl(codec, pin, val, false); 542 } 543 544 /** 545 * snd_hda_set_pin_ctl_cache - Set a pin-control value safely 546 * @codec: the codec instance 547 * @pin: the pin NID to set the control 548 * @val: the pin-control value (AC_PINCTL_* bits) 549 * 550 * Just like snd_hda_set_pin_ctl() but write to cache as well. 551 */ 552 static inline int 553 snd_hda_set_pin_ctl_cache(struct hda_codec *codec, hda_nid_t pin, 554 unsigned int val) 555 { 556 return _snd_hda_set_pin_ctl(codec, pin, val, true); 557 } 558 559 int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid); 560 int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid, 561 unsigned int val); 562 563 /* 564 * get widget capabilities 565 */ 566 static inline u32 get_wcaps(struct hda_codec *codec, hda_nid_t nid) 567 { 568 if (nid < codec->start_nid || 569 nid >= codec->start_nid + codec->num_nodes) 570 return 0; 571 return codec->wcaps[nid - codec->start_nid]; 572 } 573 574 /* get the widget type from widget capability bits */ 575 static inline int get_wcaps_type(unsigned int wcaps) 576 { 577 if (!wcaps) 578 return -1; /* invalid type */ 579 return (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 580 } 581 582 static inline unsigned int get_wcaps_channels(u32 wcaps) 583 { 584 unsigned int chans; 585 586 chans = (wcaps & AC_WCAP_CHAN_CNT_EXT) >> 13; 587 chans = ((chans << 1) | 1) + 1; 588 589 return chans; 590 } 591 592 static inline void snd_hda_override_wcaps(struct hda_codec *codec, 593 hda_nid_t nid, u32 val) 594 { 595 if (nid >= codec->start_nid && 596 nid < codec->start_nid + codec->num_nodes) 597 codec->wcaps[nid - codec->start_nid] = val; 598 } 599 600 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction); 601 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, 602 unsigned int caps); 603 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid); 604 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid, 605 unsigned int caps); 606 bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid, 607 int dir, unsigned int bits); 608 609 #define nid_has_mute(codec, nid, dir) \ 610 snd_hda_check_amp_caps(codec, nid, dir, (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) 611 #define nid_has_volume(codec, nid, dir) \ 612 snd_hda_check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS) 613 614 615 /* flags for hda_nid_item */ 616 #define HDA_NID_ITEM_AMP (1<<0) 617 618 struct hda_nid_item { 619 struct snd_kcontrol *kctl; 620 unsigned int index; 621 hda_nid_t nid; 622 unsigned short flags; 623 }; 624 625 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid, 626 struct snd_kcontrol *kctl); 627 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl, 628 unsigned int index, hda_nid_t nid); 629 void snd_hda_ctls_clear(struct hda_codec *codec); 630 631 /* 632 * hwdep interface 633 */ 634 #ifdef CONFIG_SND_HDA_HWDEP 635 int snd_hda_create_hwdep(struct hda_codec *codec); 636 #else 637 static inline int snd_hda_create_hwdep(struct hda_codec *codec) { return 0; } 638 #endif 639 640 void snd_hda_sysfs_init(struct hda_codec *codec); 641 void snd_hda_sysfs_clear(struct hda_codec *codec); 642 643 extern const struct attribute_group *snd_hda_dev_attr_groups[]; 644 645 #ifdef CONFIG_SND_HDA_RECONFIG 646 const char *snd_hda_get_hint(struct hda_codec *codec, const char *key); 647 int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key); 648 int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp); 649 #else 650 static inline 651 const char *snd_hda_get_hint(struct hda_codec *codec, const char *key) 652 { 653 return NULL; 654 } 655 656 static inline 657 int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key) 658 { 659 return -ENOENT; 660 } 661 662 static inline 663 int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp) 664 { 665 return -ENOENT; 666 } 667 #endif 668 669 /* 670 * power-management 671 */ 672 673 void snd_hda_schedule_power_save(struct hda_codec *codec); 674 675 struct hda_amp_list { 676 hda_nid_t nid; 677 unsigned char dir; 678 unsigned char idx; 679 }; 680 681 struct hda_loopback_check { 682 const struct hda_amp_list *amplist; 683 int power_on; 684 }; 685 686 int snd_hda_check_amp_list_power(struct hda_codec *codec, 687 struct hda_loopback_check *check, 688 hda_nid_t nid); 689 690 /* check whether the actual power state matches with the target state */ 691 static inline bool 692 snd_hda_check_power_state(struct hda_codec *codec, hda_nid_t nid, 693 unsigned int target_state) 694 { 695 unsigned int state = snd_hda_codec_read(codec, nid, 0, 696 AC_VERB_GET_POWER_STATE, 0); 697 if (state & AC_PWRST_ERROR) 698 return true; 699 state = (state >> 4) & 0x0f; 700 return (state == target_state); 701 } 702 703 unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec, 704 hda_nid_t nid, 705 unsigned int power_state); 706 707 /* 708 * AMP control callbacks 709 */ 710 /* retrieve parameters from private_value */ 711 #define get_amp_nid_(pv) ((pv) & 0xffff) 712 #define get_amp_nid(kc) get_amp_nid_((kc)->private_value) 713 #define get_amp_channels(kc) (((kc)->private_value >> 16) & 0x3) 714 #define get_amp_direction_(pv) (((pv) >> 18) & 0x1) 715 #define get_amp_direction(kc) get_amp_direction_((kc)->private_value) 716 #define get_amp_index_(pv) (((pv) >> 19) & 0xf) 717 #define get_amp_index(kc) get_amp_index_((kc)->private_value) 718 #define get_amp_offset(kc) (((kc)->private_value >> 23) & 0x3f) 719 #define get_amp_min_mute(kc) (((kc)->private_value >> 29) & 0x1) 720 721 /* 722 * enum control helper 723 */ 724 int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol, 725 struct snd_ctl_elem_info *uinfo, 726 int num_entries, const char * const *texts); 727 #define snd_hda_enum_bool_helper_info(kcontrol, uinfo) \ 728 snd_hda_enum_helper_info(kcontrol, uinfo, 0, NULL) 729 730 /* 731 * CEA Short Audio Descriptor data 732 */ 733 struct cea_sad { 734 int channels; 735 int format; /* (format == 0) indicates invalid SAD */ 736 int rates; 737 int sample_bits; /* for LPCM */ 738 int max_bitrate; /* for AC3...ATRAC */ 739 int profile; /* for WMAPRO */ 740 }; 741 742 #define ELD_FIXED_BYTES 20 743 #define ELD_MAX_SIZE 256 744 #define ELD_MAX_MNL 16 745 #define ELD_MAX_SAD 16 746 747 /* 748 * ELD: EDID Like Data 749 */ 750 struct parsed_hdmi_eld { 751 /* 752 * all fields will be cleared before updating ELD 753 */ 754 int baseline_len; 755 int eld_ver; 756 int cea_edid_ver; 757 char monitor_name[ELD_MAX_MNL + 1]; 758 int manufacture_id; 759 int product_id; 760 u64 port_id; 761 int support_hdcp; 762 int support_ai; 763 int conn_type; 764 int aud_synch_delay; 765 int spk_alloc; 766 int sad_count; 767 struct cea_sad sad[ELD_MAX_SAD]; 768 }; 769 770 struct hdmi_eld { 771 bool monitor_present; 772 bool eld_valid; 773 int eld_size; 774 char eld_buffer[ELD_MAX_SIZE]; 775 struct parsed_hdmi_eld info; 776 }; 777 778 int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid); 779 int snd_hdmi_get_eld(struct hda_codec *codec, hda_nid_t nid, 780 unsigned char *buf, int *eld_size); 781 int snd_hdmi_parse_eld(struct hda_codec *codec, struct parsed_hdmi_eld *e, 782 const unsigned char *buf, int size); 783 void snd_hdmi_show_eld(struct hda_codec *codec, struct parsed_hdmi_eld *e); 784 void snd_hdmi_eld_update_pcm_info(struct parsed_hdmi_eld *e, 785 struct hda_pcm_stream *hinfo); 786 787 int snd_hdmi_get_eld_ati(struct hda_codec *codec, hda_nid_t nid, 788 unsigned char *buf, int *eld_size, 789 bool rev3_or_later); 790 791 #ifdef CONFIG_PROC_FS 792 void snd_hdmi_print_eld_info(struct hdmi_eld *eld, 793 struct snd_info_buffer *buffer); 794 void snd_hdmi_write_eld_info(struct hdmi_eld *eld, 795 struct snd_info_buffer *buffer); 796 #endif 797 798 #define SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE 80 799 void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen); 800 801 /* 802 */ 803 #define codec_err(codec, fmt, args...) dev_err(&(codec)->dev, fmt, ##args) 804 #define codec_warn(codec, fmt, args...) dev_warn(&(codec)->dev, fmt, ##args) 805 #define codec_info(codec, fmt, args...) dev_info(&(codec)->dev, fmt, ##args) 806 #define codec_dbg(codec, fmt, args...) dev_dbg(&(codec)->dev, fmt, ##args) 807 808 #endif /* __SOUND_HDA_LOCAL_H */ 809