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 #ifdef CONFIG_PM 137 void snd_hda_codec_resume_amp(struct hda_codec *codec); 138 #endif 139 140 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir, 141 unsigned int *tlv); 142 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec, 143 const char *name); 144 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name, 145 unsigned int *tlv, const char * const *slaves, 146 const char *suffix, bool init_slave_vol, 147 struct snd_kcontrol **ctl_ret); 148 #define snd_hda_add_vmaster(codec, name, tlv, slaves, suffix) \ 149 __snd_hda_add_vmaster(codec, name, tlv, slaves, suffix, true, NULL) 150 int snd_hda_codec_reset(struct hda_codec *codec); 151 152 enum { 153 HDA_VMUTE_OFF, 154 HDA_VMUTE_ON, 155 HDA_VMUTE_FOLLOW_MASTER, 156 }; 157 158 struct hda_vmaster_mute_hook { 159 /* below two fields must be filled by the caller of 160 * snd_hda_add_vmaster_hook() beforehand 161 */ 162 struct snd_kcontrol *sw_kctl; 163 void (*hook)(void *, int); 164 /* below are initialized automatically */ 165 unsigned int mute_mode; /* HDA_VMUTE_XXX */ 166 struct hda_codec *codec; 167 }; 168 169 int snd_hda_add_vmaster_hook(struct hda_codec *codec, 170 struct hda_vmaster_mute_hook *hook, 171 bool expose_enum_ctl); 172 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook); 173 174 /* amp value bits */ 175 #define HDA_AMP_MUTE 0x80 176 #define HDA_AMP_UNMUTE 0x00 177 #define HDA_AMP_VOLMASK 0x7f 178 179 /* mono switch binding multiple inputs */ 180 #define HDA_BIND_MUTE_MONO(xname, nid, channel, indices, direction) \ 181 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 182 .info = snd_hda_mixer_amp_switch_info, \ 183 .get = snd_hda_mixer_bind_switch_get, \ 184 .put = snd_hda_mixer_bind_switch_put, \ 185 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, indices, direction) } 186 187 /* stereo switch binding multiple inputs */ 188 #define HDA_BIND_MUTE(xname,nid,indices,dir) \ 189 HDA_BIND_MUTE_MONO(xname,nid,3,indices,dir) 190 191 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, 192 struct snd_ctl_elem_value *ucontrol); 193 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, 194 struct snd_ctl_elem_value *ucontrol); 195 196 /* more generic bound controls */ 197 struct hda_ctl_ops { 198 snd_kcontrol_info_t *info; 199 snd_kcontrol_get_t *get; 200 snd_kcontrol_put_t *put; 201 snd_kcontrol_tlv_rw_t *tlv; 202 }; 203 204 extern struct hda_ctl_ops snd_hda_bind_vol; /* for bind-volume with TLV */ 205 extern struct hda_ctl_ops snd_hda_bind_sw; /* for bind-switch */ 206 207 struct hda_bind_ctls { 208 struct hda_ctl_ops *ops; 209 unsigned long values[]; 210 }; 211 212 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol, 213 struct snd_ctl_elem_info *uinfo); 214 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol, 215 struct snd_ctl_elem_value *ucontrol); 216 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol, 217 struct snd_ctl_elem_value *ucontrol); 218 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag, 219 unsigned int size, unsigned int __user *tlv); 220 221 #define HDA_BIND_VOL(xname, bindrec) \ 222 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 223 .name = xname, \ 224 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |\ 225 SNDRV_CTL_ELEM_ACCESS_TLV_READ |\ 226 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK,\ 227 .info = snd_hda_mixer_bind_ctls_info,\ 228 .get = snd_hda_mixer_bind_ctls_get,\ 229 .put = snd_hda_mixer_bind_ctls_put,\ 230 .tlv = { .c = snd_hda_mixer_bind_tlv },\ 231 .private_value = (long) (bindrec) } 232 #define HDA_BIND_SW(xname, bindrec) \ 233 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\ 234 .name = xname, \ 235 .info = snd_hda_mixer_bind_ctls_info,\ 236 .get = snd_hda_mixer_bind_ctls_get,\ 237 .put = snd_hda_mixer_bind_ctls_put,\ 238 .private_value = (long) (bindrec) } 239 240 /* 241 * SPDIF I/O 242 */ 243 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, 244 hda_nid_t associated_nid, 245 hda_nid_t cvt_nid); 246 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid); 247 248 /* 249 * input MUX helper 250 */ 251 #define HDA_MAX_NUM_INPUTS 16 252 struct hda_input_mux_item { 253 char label[32]; 254 unsigned int index; 255 }; 256 struct hda_input_mux { 257 unsigned int num_items; 258 struct hda_input_mux_item items[HDA_MAX_NUM_INPUTS]; 259 }; 260 261 int snd_hda_input_mux_info(const struct hda_input_mux *imux, 262 struct snd_ctl_elem_info *uinfo); 263 int snd_hda_input_mux_put(struct hda_codec *codec, 264 const struct hda_input_mux *imux, 265 struct snd_ctl_elem_value *ucontrol, hda_nid_t nid, 266 unsigned int *cur_val); 267 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label, 268 int index, int *type_index_ret); 269 270 /* 271 * Channel mode helper 272 */ 273 struct hda_channel_mode { 274 int channels; 275 const struct hda_verb *sequence; 276 }; 277 278 int snd_hda_ch_mode_info(struct hda_codec *codec, 279 struct snd_ctl_elem_info *uinfo, 280 const struct hda_channel_mode *chmode, 281 int num_chmodes); 282 int snd_hda_ch_mode_get(struct hda_codec *codec, 283 struct snd_ctl_elem_value *ucontrol, 284 const struct hda_channel_mode *chmode, 285 int num_chmodes, 286 int max_channels); 287 int snd_hda_ch_mode_put(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_channelsp); 292 293 /* 294 * Multi-channel / digital-out PCM helper 295 */ 296 297 enum { HDA_FRONT, HDA_REAR, HDA_CLFE, HDA_SIDE }; /* index for dac_nidx */ 298 enum { HDA_DIG_NONE, HDA_DIG_EXCLUSIVE, HDA_DIG_ANALOG_DUP }; /* dig_out_used */ 299 300 #define HDA_MAX_OUTS 5 301 302 struct hda_multi_out { 303 int num_dacs; /* # of DACs, must be more than 1 */ 304 const hda_nid_t *dac_nids; /* DAC list */ 305 hda_nid_t hp_nid; /* optional DAC for HP, 0 when not exists */ 306 hda_nid_t hp_out_nid[HDA_MAX_OUTS]; /* DACs for multiple HPs */ 307 hda_nid_t extra_out_nid[HDA_MAX_OUTS]; /* other (e.g. speaker) DACs */ 308 hda_nid_t dig_out_nid; /* digital out audio widget */ 309 const hda_nid_t *slave_dig_outs; 310 int max_channels; /* currently supported analog channels */ 311 int dig_out_used; /* current usage of digital out (HDA_DIG_XXX) */ 312 int no_share_stream; /* don't share a stream with multiple pins */ 313 int share_spdif; /* share SPDIF pin */ 314 /* PCM information for both analog and SPDIF DACs */ 315 unsigned int analog_rates; 316 unsigned int analog_maxbps; 317 u64 analog_formats; 318 unsigned int spdif_rates; 319 unsigned int spdif_maxbps; 320 u64 spdif_formats; 321 }; 322 323 int snd_hda_create_spdif_share_sw(struct hda_codec *codec, 324 struct hda_multi_out *mout); 325 int snd_hda_multi_out_dig_open(struct hda_codec *codec, 326 struct hda_multi_out *mout); 327 int snd_hda_multi_out_dig_close(struct hda_codec *codec, 328 struct hda_multi_out *mout); 329 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, 330 struct hda_multi_out *mout, 331 unsigned int stream_tag, 332 unsigned int format, 333 struct snd_pcm_substream *substream); 334 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec, 335 struct hda_multi_out *mout); 336 int snd_hda_multi_out_analog_open(struct hda_codec *codec, 337 struct hda_multi_out *mout, 338 struct snd_pcm_substream *substream, 339 struct hda_pcm_stream *hinfo); 340 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, 341 struct hda_multi_out *mout, 342 unsigned int stream_tag, 343 unsigned int format, 344 struct snd_pcm_substream *substream); 345 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, 346 struct hda_multi_out *mout); 347 348 /* 349 * generic codec parser 350 */ 351 #ifdef CONFIG_SND_HDA_GENERIC 352 int snd_hda_parse_generic_codec(struct hda_codec *codec); 353 #else 354 static inline int snd_hda_parse_generic_codec(struct hda_codec *codec) 355 { 356 return -ENODEV; 357 } 358 #endif 359 360 /* 361 * generic proc interface 362 */ 363 #ifdef CONFIG_PROC_FS 364 int snd_hda_codec_proc_new(struct hda_codec *codec); 365 #else 366 static inline int snd_hda_codec_proc_new(struct hda_codec *codec) { return 0; } 367 #endif 368 369 #define SND_PRINT_BITS_ADVISED_BUFSIZE 16 370 void snd_print_pcm_bits(int pcm, char *buf, int buflen); 371 372 /* 373 * Misc 374 */ 375 int snd_hda_check_board_config(struct hda_codec *codec, int num_configs, 376 const char * const *modelnames, 377 const struct snd_pci_quirk *pci_list); 378 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec, 379 int num_configs, const char * const *models, 380 const struct snd_pci_quirk *tbl); 381 int snd_hda_add_new_ctls(struct hda_codec *codec, 382 const struct snd_kcontrol_new *knew); 383 384 /* 385 * unsolicited event handler 386 */ 387 388 #define HDA_UNSOL_QUEUE_SIZE 64 389 390 struct hda_bus_unsolicited { 391 /* ring buffer */ 392 u32 queue[HDA_UNSOL_QUEUE_SIZE * 2]; 393 unsigned int rp, wp; 394 395 /* workqueue */ 396 struct work_struct work; 397 struct hda_bus *bus; 398 }; 399 400 /* helper macros to retrieve pin default-config values */ 401 #define get_defcfg_connect(cfg) \ 402 ((cfg & AC_DEFCFG_PORT_CONN) >> AC_DEFCFG_PORT_CONN_SHIFT) 403 #define get_defcfg_association(cfg) \ 404 ((cfg & AC_DEFCFG_DEF_ASSOC) >> AC_DEFCFG_ASSOC_SHIFT) 405 #define get_defcfg_location(cfg) \ 406 ((cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT) 407 #define get_defcfg_sequence(cfg) \ 408 (cfg & AC_DEFCFG_SEQUENCE) 409 #define get_defcfg_device(cfg) \ 410 ((cfg & AC_DEFCFG_DEVICE) >> AC_DEFCFG_DEVICE_SHIFT) 411 #define get_defcfg_misc(cfg) \ 412 ((cfg & AC_DEFCFG_MISC) >> AC_DEFCFG_MISC_SHIFT) 413 414 /* amp values */ 415 #define AMP_IN_MUTE(idx) (0x7080 | ((idx)<<8)) 416 #define AMP_IN_UNMUTE(idx) (0x7000 | ((idx)<<8)) 417 #define AMP_OUT_MUTE 0xb080 418 #define AMP_OUT_UNMUTE 0xb000 419 #define AMP_OUT_ZERO 0xb000 420 /* pinctl values */ 421 #define PIN_IN (AC_PINCTL_IN_EN) 422 #define PIN_VREFHIZ (AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ) 423 #define PIN_VREF50 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_50) 424 #define PIN_VREFGRD (AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD) 425 #define PIN_VREF80 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_80) 426 #define PIN_VREF100 (AC_PINCTL_IN_EN | AC_PINCTL_VREF_100) 427 #define PIN_OUT (AC_PINCTL_OUT_EN) 428 #define PIN_HP (AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN) 429 #define PIN_HP_AMP (AC_PINCTL_HP_EN) 430 431 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin); 432 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin, 433 unsigned int val, bool cached); 434 435 /** 436 * _snd_hda_set_pin_ctl - Set a pin-control value safely 437 * @codec: the codec instance 438 * @pin: the pin NID to set the control 439 * @val: the pin-control value (AC_PINCTL_* bits) 440 * 441 * This function sets the pin-control value to the given pin, but 442 * filters out the invalid pin-control bits when the pin has no such 443 * capabilities. For example, when PIN_HP is passed but the pin has no 444 * HP-drive capability, the HP bit is omitted. 445 * 446 * The function doesn't check the input VREF capability bits, though. 447 * Use snd_hda_get_default_vref() to guess the right value. 448 * Also, this function is only for analog pins, not for HDMI pins. 449 */ 450 static inline int 451 snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin, unsigned int val) 452 { 453 return _snd_hda_set_pin_ctl(codec, pin, val, false); 454 } 455 456 /** 457 * snd_hda_set_pin_ctl_cache - Set a pin-control value safely 458 * @codec: the codec instance 459 * @pin: the pin NID to set the control 460 * @val: the pin-control value (AC_PINCTL_* bits) 461 * 462 * Just like snd_hda_set_pin_ctl() but write to cache as well. 463 */ 464 static inline int 465 snd_hda_set_pin_ctl_cache(struct hda_codec *codec, hda_nid_t pin, 466 unsigned int val) 467 { 468 return _snd_hda_set_pin_ctl(codec, pin, val, true); 469 } 470 471 /* 472 * get widget capabilities 473 */ 474 static inline u32 get_wcaps(struct hda_codec *codec, hda_nid_t nid) 475 { 476 if (nid < codec->start_nid || 477 nid >= codec->start_nid + codec->num_nodes) 478 return 0; 479 return codec->wcaps[nid - codec->start_nid]; 480 } 481 482 /* get the widget type from widget capability bits */ 483 static inline int get_wcaps_type(unsigned int wcaps) 484 { 485 if (!wcaps) 486 return -1; /* invalid type */ 487 return (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 488 } 489 490 static inline unsigned int get_wcaps_channels(u32 wcaps) 491 { 492 unsigned int chans; 493 494 chans = (wcaps & AC_WCAP_CHAN_CNT_EXT) >> 13; 495 chans = ((chans << 1) | 1) + 1; 496 497 return chans; 498 } 499 500 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction); 501 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, 502 unsigned int caps); 503 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid); 504 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid, 505 unsigned int caps); 506 507 /* flags for hda_nid_item */ 508 #define HDA_NID_ITEM_AMP (1<<0) 509 510 struct hda_nid_item { 511 struct snd_kcontrol *kctl; 512 unsigned int index; 513 hda_nid_t nid; 514 unsigned short flags; 515 }; 516 517 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid, 518 struct snd_kcontrol *kctl); 519 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl, 520 unsigned int index, hda_nid_t nid); 521 void snd_hda_ctls_clear(struct hda_codec *codec); 522 523 /* 524 * hwdep interface 525 */ 526 #ifdef CONFIG_SND_HDA_HWDEP 527 int snd_hda_create_hwdep(struct hda_codec *codec); 528 #else 529 static inline int snd_hda_create_hwdep(struct hda_codec *codec) { return 0; } 530 #endif 531 532 #if defined(CONFIG_SND_HDA_POWER_SAVE) && defined(CONFIG_SND_HDA_HWDEP) 533 int snd_hda_hwdep_add_power_sysfs(struct hda_codec *codec); 534 #else 535 static inline int snd_hda_hwdep_add_power_sysfs(struct hda_codec *codec) 536 { 537 return 0; 538 } 539 #endif 540 541 #ifdef CONFIG_SND_HDA_RECONFIG 542 int snd_hda_hwdep_add_sysfs(struct hda_codec *codec); 543 #else 544 static inline int snd_hda_hwdep_add_sysfs(struct hda_codec *codec) 545 { 546 return 0; 547 } 548 #endif 549 550 #ifdef CONFIG_SND_HDA_RECONFIG 551 const char *snd_hda_get_hint(struct hda_codec *codec, const char *key); 552 int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key); 553 #else 554 static inline 555 const char *snd_hda_get_hint(struct hda_codec *codec, const char *key) 556 { 557 return NULL; 558 } 559 560 static inline 561 int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key) 562 { 563 return -ENOENT; 564 } 565 #endif 566 567 /* 568 * power-management 569 */ 570 571 void snd_hda_schedule_power_save(struct hda_codec *codec); 572 573 struct hda_amp_list { 574 hda_nid_t nid; 575 unsigned char dir; 576 unsigned char idx; 577 }; 578 579 struct hda_loopback_check { 580 const struct hda_amp_list *amplist; 581 int power_on; 582 }; 583 584 int snd_hda_check_amp_list_power(struct hda_codec *codec, 585 struct hda_loopback_check *check, 586 hda_nid_t nid); 587 588 /* 589 * AMP control callbacks 590 */ 591 /* retrieve parameters from private_value */ 592 #define get_amp_nid_(pv) ((pv) & 0xffff) 593 #define get_amp_nid(kc) get_amp_nid_((kc)->private_value) 594 #define get_amp_channels(kc) (((kc)->private_value >> 16) & 0x3) 595 #define get_amp_direction_(pv) (((pv) >> 18) & 0x1) 596 #define get_amp_direction(kc) get_amp_direction_((kc)->private_value) 597 #define get_amp_index(kc) (((kc)->private_value >> 19) & 0xf) 598 #define get_amp_offset(kc) (((kc)->private_value >> 23) & 0x3f) 599 #define get_amp_min_mute(kc) (((kc)->private_value >> 29) & 0x1) 600 601 /* 602 * CEA Short Audio Descriptor data 603 */ 604 struct cea_sad { 605 int channels; 606 int format; /* (format == 0) indicates invalid SAD */ 607 int rates; 608 int sample_bits; /* for LPCM */ 609 int max_bitrate; /* for AC3...ATRAC */ 610 int profile; /* for WMAPRO */ 611 }; 612 613 #define ELD_FIXED_BYTES 20 614 #define ELD_MAX_SIZE 256 615 #define ELD_MAX_MNL 16 616 #define ELD_MAX_SAD 16 617 618 /* 619 * ELD: EDID Like Data 620 */ 621 struct hdmi_eld { 622 bool monitor_present; 623 bool eld_valid; 624 int eld_size; 625 int baseline_len; 626 int eld_ver; 627 int cea_edid_ver; 628 char monitor_name[ELD_MAX_MNL + 1]; 629 int manufacture_id; 630 int product_id; 631 u64 port_id; 632 int support_hdcp; 633 int support_ai; 634 int conn_type; 635 int aud_synch_delay; 636 int spk_alloc; 637 int sad_count; 638 struct cea_sad sad[ELD_MAX_SAD]; 639 /* 640 * all fields above eld_buffer will be cleared before updating ELD 641 */ 642 char eld_buffer[ELD_MAX_SIZE]; 643 #ifdef CONFIG_PROC_FS 644 struct snd_info_entry *proc_entry; 645 #endif 646 }; 647 648 int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid); 649 int snd_hdmi_get_eld(struct hdmi_eld *, struct hda_codec *, hda_nid_t); 650 void snd_hdmi_show_eld(struct hdmi_eld *eld); 651 void snd_hdmi_eld_update_pcm_info(struct hdmi_eld *eld, 652 struct hda_pcm_stream *hinfo); 653 654 #ifdef CONFIG_PROC_FS 655 int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld, 656 int index); 657 void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld); 658 #else 659 static inline int snd_hda_eld_proc_new(struct hda_codec *codec, 660 struct hdmi_eld *eld, 661 int index) 662 { 663 return 0; 664 } 665 static inline void snd_hda_eld_proc_free(struct hda_codec *codec, 666 struct hdmi_eld *eld) 667 { 668 } 669 #endif 670 671 #define SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE 80 672 void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen); 673 674 #endif /* __SOUND_HDA_LOCAL_H */ 675