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