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