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