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