1 /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 /* 3 * Universal Interface for Intel High Definition Audio Codec 4 * 5 * Local helper functions 6 * 7 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de> 8 */ 9 10 #ifndef __SOUND_HDA_LOCAL_H 11 #define __SOUND_HDA_LOCAL_H 12 13 /* We abuse kcontrol_new.subdev field to pass the NID corresponding to 14 * the given new control. If id.subdev has a bit flag HDA_SUBDEV_NID_FLAG, 15 * snd_hda_ctl_add() takes the lower-bit subdev value as a valid NID. 16 * 17 * Note that the subdevice field is cleared again before the real registration 18 * in snd_hda_ctl_add(), so that this value won't appear in the outside. 19 */ 20 #define HDA_SUBDEV_NID_FLAG (1U << 31) 21 #define HDA_SUBDEV_AMP_FLAG (1U << 30) 22 23 /* 24 * for mixer controls 25 */ 26 #define HDA_COMPOSE_AMP_VAL_OFS(nid,chs,idx,dir,ofs) \ 27 ((nid) | ((chs)<<16) | ((dir)<<18) | ((idx)<<19) | ((ofs)<<23)) 28 #define HDA_AMP_VAL_MIN_MUTE (1<<29) 29 #define HDA_COMPOSE_AMP_VAL(nid,chs,idx,dir) \ 30 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, idx, dir, 0) 31 /* mono volume with index (index=0,1,...) (channel=1,2) */ 32 #define HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, channel, xindex, dir, flags) \ 33 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \ 34 .subdevice = HDA_SUBDEV_AMP_FLAG, \ 35 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \ 36 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ 37 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \ 38 .info = snd_hda_mixer_amp_volume_info, \ 39 .get = snd_hda_mixer_amp_volume_get, \ 40 .put = snd_hda_mixer_amp_volume_put, \ 41 .tlv = { .c = snd_hda_mixer_amp_tlv }, \ 42 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, dir) | flags } 43 /* stereo volume with index */ 44 #define HDA_CODEC_VOLUME_IDX(xname, xcidx, nid, xindex, direction) \ 45 HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, 3, xindex, direction, 0) 46 /* mono volume */ 47 #define HDA_CODEC_VOLUME_MONO(xname, nid, channel, xindex, direction) \ 48 HDA_CODEC_VOLUME_MONO_IDX(xname, 0, nid, channel, xindex, direction, 0) 49 /* stereo volume */ 50 #define HDA_CODEC_VOLUME(xname, nid, xindex, direction) \ 51 HDA_CODEC_VOLUME_MONO(xname, nid, 3, xindex, direction) 52 /* stereo volume with min=mute */ 53 #define HDA_CODEC_VOLUME_MIN_MUTE(xname, nid, xindex, direction) \ 54 HDA_CODEC_VOLUME_MONO_IDX(xname, 0, nid, 3, xindex, direction, \ 55 HDA_AMP_VAL_MIN_MUTE) 56 /* mono mute switch with index (index=0,1,...) (channel=1,2) */ 57 #define HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \ 58 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \ 59 .subdevice = HDA_SUBDEV_AMP_FLAG, \ 60 .info = snd_hda_mixer_amp_switch_info, \ 61 .get = snd_hda_mixer_amp_switch_get, \ 62 .put = snd_hda_mixer_amp_switch_put, \ 63 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) } 64 /* stereo mute switch with index */ 65 #define HDA_CODEC_MUTE_IDX(xname, xcidx, nid, xindex, direction) \ 66 HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, 3, xindex, direction) 67 /* mono mute switch */ 68 #define HDA_CODEC_MUTE_MONO(xname, nid, channel, xindex, direction) \ 69 HDA_CODEC_MUTE_MONO_IDX(xname, 0, nid, channel, xindex, direction) 70 /* stereo mute switch */ 71 #define HDA_CODEC_MUTE(xname, nid, xindex, direction) \ 72 HDA_CODEC_MUTE_MONO(xname, nid, 3, xindex, direction) 73 #ifdef CONFIG_SND_HDA_INPUT_BEEP 74 /* special beep mono mute switch with index (index=0,1,...) (channel=1,2) */ 75 #define HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \ 76 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \ 77 .subdevice = HDA_SUBDEV_AMP_FLAG, \ 78 .info = snd_hda_mixer_amp_switch_info, \ 79 .get = snd_hda_mixer_amp_switch_get_beep, \ 80 .put = snd_hda_mixer_amp_switch_put_beep, \ 81 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) } 82 #else 83 /* no digital beep - just the standard one */ 84 #define HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, xcidx, nid, ch, xidx, dir) \ 85 HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, ch, xidx, dir) 86 #endif /* CONFIG_SND_HDA_INPUT_BEEP */ 87 /* special beep mono mute switch */ 88 #define HDA_CODEC_MUTE_BEEP_MONO(xname, nid, channel, xindex, direction) \ 89 HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, 0, nid, channel, xindex, direction) 90 /* special beep stereo mute switch */ 91 #define HDA_CODEC_MUTE_BEEP(xname, nid, xindex, direction) \ 92 HDA_CODEC_MUTE_BEEP_MONO(xname, nid, 3, xindex, direction) 93 94 extern const char *snd_hda_pcm_type_name[]; 95 96 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol, 97 struct snd_ctl_elem_info *uinfo); 98 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol, 99 struct snd_ctl_elem_value *ucontrol); 100 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol, 101 struct snd_ctl_elem_value *ucontrol); 102 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag, 103 unsigned int size, unsigned int __user *tlv); 104 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol, 105 struct snd_ctl_elem_info *uinfo); 106 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, 107 struct snd_ctl_elem_value *ucontrol); 108 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, 109 struct snd_ctl_elem_value *ucontrol); 110 #ifdef CONFIG_SND_HDA_INPUT_BEEP 111 int snd_hda_mixer_amp_switch_get_beep(struct snd_kcontrol *kcontrol, 112 struct snd_ctl_elem_value *ucontrol); 113 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol, 114 struct snd_ctl_elem_value *ucontrol); 115 #endif 116 /* lowlevel accessor with caching; use carefully */ 117 #define snd_hda_codec_amp_read(codec, nid, ch, dir, idx) \ 118 snd_hdac_regmap_get_amp(&(codec)->core, nid, ch, dir, idx) 119 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, 120 int ch, int dir, int idx, int mask, int val); 121 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid, 122 int dir, int idx, int mask, int val); 123 int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch, 124 int direction, int idx, int mask, int val); 125 int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid, 126 int dir, int idx, int mask, int val); 127 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir, 128 unsigned int *tlv); 129 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec, 130 const char *name); 131 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name, 132 unsigned int *tlv, const char * const *slaves, 133 const char *suffix, bool init_slave_vol, 134 struct snd_kcontrol **ctl_ret); 135 #define snd_hda_add_vmaster(codec, name, tlv, slaves, suffix) \ 136 __snd_hda_add_vmaster(codec, name, tlv, slaves, suffix, true, NULL) 137 int snd_hda_codec_reset(struct hda_codec *codec); 138 void snd_hda_codec_register(struct hda_codec *codec); 139 void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec); 140 141 enum { 142 HDA_VMUTE_OFF, 143 HDA_VMUTE_ON, 144 HDA_VMUTE_FOLLOW_MASTER, 145 }; 146 147 struct hda_vmaster_mute_hook { 148 /* below two fields must be filled by the caller of 149 * snd_hda_add_vmaster_hook() beforehand 150 */ 151 struct snd_kcontrol *sw_kctl; 152 void (*hook)(void *, int); 153 /* below are initialized automatically */ 154 unsigned int mute_mode; /* HDA_VMUTE_XXX */ 155 struct hda_codec *codec; 156 }; 157 158 int snd_hda_add_vmaster_hook(struct hda_codec *codec, 159 struct hda_vmaster_mute_hook *hook, 160 bool expose_enum_ctl); 161 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook); 162 163 /* amp value bits */ 164 #define HDA_AMP_MUTE 0x80 165 #define HDA_AMP_UNMUTE 0x00 166 #define HDA_AMP_VOLMASK 0x7f 167 168 /* 169 * SPDIF I/O 170 */ 171 int snd_hda_create_dig_out_ctls(struct hda_codec *codec, 172 hda_nid_t associated_nid, 173 hda_nid_t cvt_nid, int type); 174 #define snd_hda_create_spdif_out_ctls(codec, anid, cnid) \ 175 snd_hda_create_dig_out_ctls(codec, anid, cnid, HDA_PCM_TYPE_SPDIF) 176 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid); 177 178 /* 179 * input MUX helper 180 */ 181 #define HDA_MAX_NUM_INPUTS 16 182 struct hda_input_mux_item { 183 char label[32]; 184 unsigned int index; 185 }; 186 struct hda_input_mux { 187 unsigned int num_items; 188 struct hda_input_mux_item items[HDA_MAX_NUM_INPUTS]; 189 }; 190 191 int snd_hda_input_mux_info(const struct hda_input_mux *imux, 192 struct snd_ctl_elem_info *uinfo); 193 int snd_hda_input_mux_put(struct hda_codec *codec, 194 const struct hda_input_mux *imux, 195 struct snd_ctl_elem_value *ucontrol, hda_nid_t nid, 196 unsigned int *cur_val); 197 int snd_hda_add_imux_item(struct hda_codec *codec, 198 struct hda_input_mux *imux, const char *label, 199 int index, int *type_index_ret); 200 201 /* 202 * Multi-channel / digital-out PCM helper 203 */ 204 205 enum { HDA_FRONT, HDA_REAR, HDA_CLFE, HDA_SIDE }; /* index for dac_nidx */ 206 enum { HDA_DIG_NONE, HDA_DIG_EXCLUSIVE, HDA_DIG_ANALOG_DUP }; /* dig_out_used */ 207 208 #define HDA_MAX_OUTS 5 209 210 struct hda_multi_out { 211 int num_dacs; /* # of DACs, must be more than 1 */ 212 const hda_nid_t *dac_nids; /* DAC list */ 213 hda_nid_t hp_nid; /* optional DAC for HP, 0 when not exists */ 214 hda_nid_t hp_out_nid[HDA_MAX_OUTS]; /* DACs for multiple HPs */ 215 hda_nid_t extra_out_nid[HDA_MAX_OUTS]; /* other (e.g. speaker) DACs */ 216 hda_nid_t dig_out_nid; /* digital out audio widget */ 217 const hda_nid_t *slave_dig_outs; 218 int max_channels; /* currently supported analog channels */ 219 int dig_out_used; /* current usage of digital out (HDA_DIG_XXX) */ 220 int no_share_stream; /* don't share a stream with multiple pins */ 221 int share_spdif; /* share SPDIF pin */ 222 /* PCM information for both analog and SPDIF DACs */ 223 unsigned int analog_rates; 224 unsigned int analog_maxbps; 225 u64 analog_formats; 226 unsigned int spdif_rates; 227 unsigned int spdif_maxbps; 228 u64 spdif_formats; 229 }; 230 231 int snd_hda_create_spdif_share_sw(struct hda_codec *codec, 232 struct hda_multi_out *mout); 233 int snd_hda_multi_out_dig_open(struct hda_codec *codec, 234 struct hda_multi_out *mout); 235 int snd_hda_multi_out_dig_close(struct hda_codec *codec, 236 struct hda_multi_out *mout); 237 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, 238 struct hda_multi_out *mout, 239 unsigned int stream_tag, 240 unsigned int format, 241 struct snd_pcm_substream *substream); 242 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec, 243 struct hda_multi_out *mout); 244 int snd_hda_multi_out_analog_open(struct hda_codec *codec, 245 struct hda_multi_out *mout, 246 struct snd_pcm_substream *substream, 247 struct hda_pcm_stream *hinfo); 248 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, 249 struct hda_multi_out *mout, 250 unsigned int stream_tag, 251 unsigned int format, 252 struct snd_pcm_substream *substream); 253 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, 254 struct hda_multi_out *mout); 255 256 /* 257 * generic proc interface 258 */ 259 #ifdef CONFIG_SND_PROC_FS 260 int snd_hda_codec_proc_new(struct hda_codec *codec); 261 #else 262 static inline int snd_hda_codec_proc_new(struct hda_codec *codec) { return 0; } 263 #endif 264 265 #define SND_PRINT_BITS_ADVISED_BUFSIZE 16 266 void snd_print_pcm_bits(int pcm, char *buf, int buflen); 267 268 /* 269 * Misc 270 */ 271 int snd_hda_add_new_ctls(struct hda_codec *codec, 272 const struct snd_kcontrol_new *knew); 273 274 /* 275 * Fix-up pin default configurations and add default verbs 276 */ 277 278 struct hda_pintbl { 279 hda_nid_t nid; 280 u32 val; 281 }; 282 283 struct hda_model_fixup { 284 const int id; 285 const char *name; 286 }; 287 288 struct hda_fixup { 289 int type; 290 bool chained:1; /* call the chained fixup(s) after this */ 291 bool chained_before:1; /* call the chained fixup(s) before this */ 292 int chain_id; 293 union { 294 const struct hda_pintbl *pins; 295 const struct hda_verb *verbs; 296 void (*func)(struct hda_codec *codec, 297 const struct hda_fixup *fix, 298 int action); 299 } v; 300 }; 301 302 struct snd_hda_pin_quirk { 303 unsigned int codec; /* Codec vendor/device ID */ 304 unsigned short subvendor; /* PCI subvendor ID */ 305 const struct hda_pintbl *pins; /* list of matching pins */ 306 #ifdef CONFIG_SND_DEBUG_VERBOSE 307 const char *name; 308 #endif 309 int value; /* quirk value */ 310 }; 311 312 #ifdef CONFIG_SND_DEBUG_VERBOSE 313 314 #define SND_HDA_PIN_QUIRK(_codec, _subvendor, _name, _value, _pins...) \ 315 { .codec = _codec,\ 316 .subvendor = _subvendor,\ 317 .name = _name,\ 318 .value = _value,\ 319 .pins = (const struct hda_pintbl[]) { _pins, {0, 0}} \ 320 } 321 #else 322 323 #define SND_HDA_PIN_QUIRK(_codec, _subvendor, _name, _value, _pins...) \ 324 { .codec = _codec,\ 325 .subvendor = _subvendor,\ 326 .value = _value,\ 327 .pins = (const struct hda_pintbl[]) { _pins, {0, 0}} \ 328 } 329 330 #endif 331 332 #define HDA_FIXUP_ID_NOT_SET -1 333 #define HDA_FIXUP_ID_NO_FIXUP -2 334 335 /* fixup types */ 336 enum { 337 HDA_FIXUP_INVALID, 338 HDA_FIXUP_PINS, 339 HDA_FIXUP_VERBS, 340 HDA_FIXUP_FUNC, 341 HDA_FIXUP_PINCTLS, 342 }; 343 344 /* fixup action definitions */ 345 enum { 346 HDA_FIXUP_ACT_PRE_PROBE, 347 HDA_FIXUP_ACT_PROBE, 348 HDA_FIXUP_ACT_INIT, 349 HDA_FIXUP_ACT_BUILD, 350 HDA_FIXUP_ACT_FREE, 351 }; 352 353 int snd_hda_add_verbs(struct hda_codec *codec, const struct hda_verb *list); 354 void snd_hda_apply_verbs(struct hda_codec *codec); 355 void snd_hda_apply_pincfgs(struct hda_codec *codec, 356 const struct hda_pintbl *cfg); 357 void snd_hda_apply_fixup(struct hda_codec *codec, int action); 358 void snd_hda_pick_fixup(struct hda_codec *codec, 359 const struct hda_model_fixup *models, 360 const struct snd_pci_quirk *quirk, 361 const struct hda_fixup *fixlist); 362 void snd_hda_pick_pin_fixup(struct hda_codec *codec, 363 const struct snd_hda_pin_quirk *pin_quirk, 364 const struct hda_fixup *fixlist, 365 bool match_all_pins); 366 367 /* helper macros to retrieve pin default-config values */ 368 #define get_defcfg_connect(cfg) \ 369 ((cfg & AC_DEFCFG_PORT_CONN) >> AC_DEFCFG_PORT_CONN_SHIFT) 370 #define get_defcfg_association(cfg) \ 371 ((cfg & AC_DEFCFG_DEF_ASSOC) >> AC_DEFCFG_ASSOC_SHIFT) 372 #define get_defcfg_location(cfg) \ 373 ((cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT) 374 #define get_defcfg_sequence(cfg) \ 375 (cfg & AC_DEFCFG_SEQUENCE) 376 #define get_defcfg_device(cfg) \ 377 ((cfg & AC_DEFCFG_DEVICE) >> AC_DEFCFG_DEVICE_SHIFT) 378 #define get_defcfg_misc(cfg) \ 379 ((cfg & AC_DEFCFG_MISC) >> AC_DEFCFG_MISC_SHIFT) 380 381 /* amp values */ 382 #define AMP_IN_MUTE(idx) (0x7080 | ((idx)<<8)) 383 #define AMP_IN_UNMUTE(idx) (0x7000 | ((idx)<<8)) 384 #define AMP_OUT_MUTE 0xb080 385 #define AMP_OUT_UNMUTE 0xb000 386 #define AMP_OUT_ZERO 0xb000 387 /* pinctl values */ 388 #define PIN_IN (AC_PINCTL_IN_EN) 389 #define PIN_VREFHIZ (AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ) 390 #define PIN_VREF50 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_50) 391 #define PIN_VREFGRD (AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD) 392 #define PIN_VREF80 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_80) 393 #define PIN_VREF100 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_100) 394 #define PIN_OUT (AC_PINCTL_OUT_EN) 395 #define PIN_HP (AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN) 396 #define PIN_HP_AMP (AC_PINCTL_HP_EN) 397 398 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin); 399 unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec, 400 hda_nid_t pin, unsigned int val); 401 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin, 402 unsigned int val, bool cached); 403 404 /** 405 * _snd_hda_set_pin_ctl - Set a pin-control value safely 406 * @codec: the codec instance 407 * @pin: the pin NID to set the control 408 * @val: the pin-control value (AC_PINCTL_* bits) 409 * 410 * This function sets the pin-control value to the given pin, but 411 * filters out the invalid pin-control bits when the pin has no such 412 * capabilities. For example, when PIN_HP is passed but the pin has no 413 * HP-drive capability, the HP bit is omitted. 414 * 415 * The function doesn't check the input VREF capability bits, though. 416 * Use snd_hda_get_default_vref() to guess the right value. 417 * Also, this function is only for analog pins, not for HDMI pins. 418 */ 419 static inline int 420 snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin, unsigned int val) 421 { 422 return _snd_hda_set_pin_ctl(codec, pin, val, false); 423 } 424 425 /** 426 * snd_hda_set_pin_ctl_cache - Set a pin-control value safely 427 * @codec: the codec instance 428 * @pin: the pin NID to set the control 429 * @val: the pin-control value (AC_PINCTL_* bits) 430 * 431 * Just like snd_hda_set_pin_ctl() but write to cache as well. 432 */ 433 static inline int 434 snd_hda_set_pin_ctl_cache(struct hda_codec *codec, hda_nid_t pin, 435 unsigned int val) 436 { 437 return _snd_hda_set_pin_ctl(codec, pin, val, true); 438 } 439 440 int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid); 441 int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid, 442 unsigned int val); 443 444 #define for_each_hda_codec_node(nid, codec) \ 445 for ((nid) = (codec)->core.start_nid; (nid) < (codec)->core.end_nid; (nid)++) 446 447 /* 448 * get widget capabilities 449 */ 450 static inline u32 get_wcaps(struct hda_codec *codec, hda_nid_t nid) 451 { 452 if (nid < codec->core.start_nid || 453 nid >= codec->core.start_nid + codec->core.num_nodes) 454 return 0; 455 return codec->wcaps[nid - codec->core.start_nid]; 456 } 457 458 /* get the widget type from widget capability bits */ 459 static inline int get_wcaps_type(unsigned int wcaps) 460 { 461 if (!wcaps) 462 return -1; /* invalid type */ 463 return (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 464 } 465 466 static inline unsigned int get_wcaps_channels(u32 wcaps) 467 { 468 unsigned int chans; 469 470 chans = (wcaps & AC_WCAP_CHAN_CNT_EXT) >> 13; 471 chans = ((chans << 1) | 1) + 1; 472 473 return chans; 474 } 475 476 static inline void snd_hda_override_wcaps(struct hda_codec *codec, 477 hda_nid_t nid, u32 val) 478 { 479 if (nid >= codec->core.start_nid && 480 nid < codec->core.start_nid + codec->core.num_nodes) 481 codec->wcaps[nid - codec->core.start_nid] = val; 482 } 483 484 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction); 485 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, 486 unsigned int caps); 487 /** 488 * snd_hda_query_pin_caps - Query PIN capabilities 489 * @codec: the HD-auio codec 490 * @nid: the NID to query 491 * 492 * Query PIN capabilities for the given widget. 493 * Returns the obtained capability bits. 494 * 495 * When cap bits have been already read, this doesn't read again but 496 * returns the cached value. 497 */ 498 static inline u32 499 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid) 500 { 501 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP); 502 503 } 504 505 /** 506 * snd_hda_override_pin_caps - Override the pin capabilities 507 * @codec: the CODEC 508 * @nid: the NID to override 509 * @caps: the capability bits to set 510 * 511 * Override the cached PIN capabilitiy bits value by the given one. 512 * 513 * Returns zero if successful or a negative error code. 514 */ 515 static inline int 516 snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid, 517 unsigned int caps) 518 { 519 return snd_hdac_override_parm(&codec->core, nid, AC_PAR_PIN_CAP, caps); 520 } 521 522 bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid, 523 int dir, unsigned int bits); 524 525 #define nid_has_mute(codec, nid, dir) \ 526 snd_hda_check_amp_caps(codec, nid, dir, (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) 527 #define nid_has_volume(codec, nid, dir) \ 528 snd_hda_check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS) 529 530 531 /* flags for hda_nid_item */ 532 #define HDA_NID_ITEM_AMP (1<<0) 533 534 struct hda_nid_item { 535 struct snd_kcontrol *kctl; 536 unsigned int index; 537 hda_nid_t nid; 538 unsigned short flags; 539 }; 540 541 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid, 542 struct snd_kcontrol *kctl); 543 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl, 544 unsigned int index, hda_nid_t nid); 545 void snd_hda_ctls_clear(struct hda_codec *codec); 546 547 /* 548 * hwdep interface 549 */ 550 #ifdef CONFIG_SND_HDA_HWDEP 551 int snd_hda_create_hwdep(struct hda_codec *codec); 552 #else 553 static inline int snd_hda_create_hwdep(struct hda_codec *codec) { return 0; } 554 #endif 555 556 void snd_hda_sysfs_init(struct hda_codec *codec); 557 void snd_hda_sysfs_clear(struct hda_codec *codec); 558 559 extern const struct attribute_group *snd_hda_dev_attr_groups[]; 560 561 #ifdef CONFIG_SND_HDA_RECONFIG 562 const char *snd_hda_get_hint(struct hda_codec *codec, const char *key); 563 int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key); 564 int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp); 565 #else 566 static inline 567 const char *snd_hda_get_hint(struct hda_codec *codec, const char *key) 568 { 569 return NULL; 570 } 571 572 static inline 573 int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key) 574 { 575 return -ENOENT; 576 } 577 578 static inline 579 int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp) 580 { 581 return -ENOENT; 582 } 583 #endif 584 585 /* 586 * power-management 587 */ 588 589 void snd_hda_schedule_power_save(struct hda_codec *codec); 590 591 struct hda_amp_list { 592 hda_nid_t nid; 593 unsigned char dir; 594 unsigned char idx; 595 }; 596 597 struct hda_loopback_check { 598 const struct hda_amp_list *amplist; 599 int power_on; 600 }; 601 602 int snd_hda_check_amp_list_power(struct hda_codec *codec, 603 struct hda_loopback_check *check, 604 hda_nid_t nid); 605 606 /* check whether the actual power state matches with the target state */ 607 static inline bool 608 snd_hda_check_power_state(struct hda_codec *codec, hda_nid_t nid, 609 unsigned int target_state) 610 { 611 return snd_hdac_check_power_state(&codec->core, nid, target_state); 612 } 613 614 static inline unsigned int snd_hda_sync_power_state(struct hda_codec *codec, 615 hda_nid_t nid, 616 unsigned int target_state) 617 { 618 return snd_hdac_sync_power_state(&codec->core, nid, target_state); 619 } 620 unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec, 621 hda_nid_t nid, 622 unsigned int power_state); 623 624 /* 625 * AMP control callbacks 626 */ 627 /* retrieve parameters from private_value */ 628 #define get_amp_nid_(pv) ((pv) & 0xffff) 629 #define get_amp_nid(kc) get_amp_nid_((kc)->private_value) 630 #define get_amp_channels(kc) (((kc)->private_value >> 16) & 0x3) 631 #define get_amp_direction_(pv) (((pv) >> 18) & 0x1) 632 #define get_amp_direction(kc) get_amp_direction_((kc)->private_value) 633 #define get_amp_index_(pv) (((pv) >> 19) & 0xf) 634 #define get_amp_index(kc) get_amp_index_((kc)->private_value) 635 #define get_amp_offset(kc) (((kc)->private_value >> 23) & 0x3f) 636 #define get_amp_min_mute(kc) (((kc)->private_value >> 29) & 0x1) 637 638 /* 639 * enum control helper 640 */ 641 int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol, 642 struct snd_ctl_elem_info *uinfo, 643 int num_entries, const char * const *texts); 644 #define snd_hda_enum_bool_helper_info(kcontrol, uinfo) \ 645 snd_hda_enum_helper_info(kcontrol, uinfo, 0, NULL) 646 647 /* 648 * CEA Short Audio Descriptor data 649 */ 650 struct cea_sad { 651 int channels; 652 int format; /* (format == 0) indicates invalid SAD */ 653 int rates; 654 int sample_bits; /* for LPCM */ 655 int max_bitrate; /* for AC3...ATRAC */ 656 int profile; /* for WMAPRO */ 657 }; 658 659 #define ELD_FIXED_BYTES 20 660 #define ELD_MAX_SIZE 256 661 #define ELD_MAX_MNL 16 662 #define ELD_MAX_SAD 16 663 664 /* 665 * ELD: EDID Like Data 666 */ 667 struct parsed_hdmi_eld { 668 /* 669 * all fields will be cleared before updating ELD 670 */ 671 int baseline_len; 672 int eld_ver; 673 int cea_edid_ver; 674 char monitor_name[ELD_MAX_MNL + 1]; 675 int manufacture_id; 676 int product_id; 677 u64 port_id; 678 int support_hdcp; 679 int support_ai; 680 int conn_type; 681 int aud_synch_delay; 682 int spk_alloc; 683 int sad_count; 684 struct cea_sad sad[ELD_MAX_SAD]; 685 }; 686 687 struct hdmi_eld { 688 bool monitor_present; 689 bool eld_valid; 690 int eld_size; 691 char eld_buffer[ELD_MAX_SIZE]; 692 struct parsed_hdmi_eld info; 693 }; 694 695 int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid); 696 int snd_hdmi_get_eld(struct hda_codec *codec, hda_nid_t nid, 697 unsigned char *buf, int *eld_size); 698 int snd_hdmi_parse_eld(struct hda_codec *codec, struct parsed_hdmi_eld *e, 699 const unsigned char *buf, int size); 700 void snd_hdmi_show_eld(struct hda_codec *codec, struct parsed_hdmi_eld *e); 701 void snd_hdmi_eld_update_pcm_info(struct parsed_hdmi_eld *e, 702 struct hda_pcm_stream *hinfo); 703 704 int snd_hdmi_get_eld_ati(struct hda_codec *codec, hda_nid_t nid, 705 unsigned char *buf, int *eld_size, 706 bool rev3_or_later); 707 708 #ifdef CONFIG_SND_PROC_FS 709 void snd_hdmi_print_eld_info(struct hdmi_eld *eld, 710 struct snd_info_buffer *buffer); 711 void snd_hdmi_write_eld_info(struct hdmi_eld *eld, 712 struct snd_info_buffer *buffer); 713 #endif 714 715 #define SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE 80 716 void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen); 717 718 /* 719 */ 720 #define codec_err(codec, fmt, args...) \ 721 dev_err(hda_codec_dev(codec), fmt, ##args) 722 #define codec_warn(codec, fmt, args...) \ 723 dev_warn(hda_codec_dev(codec), fmt, ##args) 724 #define codec_info(codec, fmt, args...) \ 725 dev_info(hda_codec_dev(codec), fmt, ##args) 726 #define codec_dbg(codec, fmt, args...) \ 727 dev_dbg(hda_codec_dev(codec), fmt, ##args) 728 729 #endif /* __SOUND_HDA_LOCAL_H */ 730