Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * BIOS auto-parser helper functions for HD-audio
4 : : *
5 : : * Copyright (c) 2012 Takashi Iwai <tiwai@suse.de>
6 : : */
7 : :
8 : : #include <linux/slab.h>
9 : : #include <linux/export.h>
10 : : #include <linux/sort.h>
11 : : #include <sound/core.h>
12 : : #include <sound/hda_codec.h>
13 : : #include "hda_local.h"
14 : : #include "hda_auto_parser.h"
15 : :
16 : : /*
17 : : * Helper for automatic pin configuration
18 : : */
19 : :
20 : : static int is_in_nid_list(hda_nid_t nid, const hda_nid_t *list)
21 : : {
22 [ # # ]: 0 : for (; *list; list++)
23 [ # # ]: 0 : if (*list == nid)
24 : : return 1;
25 : : return 0;
26 : : }
27 : :
28 : : /* a pair of input pin and its sequence */
29 : : struct auto_out_pin {
30 : : hda_nid_t pin;
31 : : short seq;
32 : : };
33 : :
34 : 0 : static int compare_seq(const void *ap, const void *bp)
35 : : {
36 : 0 : const struct auto_out_pin *a = ap;
37 : 0 : const struct auto_out_pin *b = bp;
38 : 0 : return (int)(a->seq - b->seq);
39 : : }
40 : :
41 : : /*
42 : : * Sort an associated group of pins according to their sequence numbers.
43 : : * then store it to a pin array.
44 : : */
45 : 0 : static void sort_pins_by_sequence(hda_nid_t *pins, struct auto_out_pin *list,
46 : : int num_pins)
47 : : {
48 : 0 : int i;
49 : 0 : sort(list, num_pins, sizeof(list[0]), compare_seq, NULL);
50 [ # # ]: 0 : for (i = 0; i < num_pins; i++)
51 : 0 : pins[i] = list[i].pin;
52 : 0 : }
53 : :
54 : :
55 : : /* add the found input-pin to the cfg->inputs[] table */
56 : 0 : static void add_auto_cfg_input_pin(struct hda_codec *codec, struct auto_pin_cfg *cfg,
57 : : hda_nid_t nid, int type)
58 : : {
59 : 0 : if (cfg->num_inputs < AUTO_CFG_MAX_INS) {
60 : 0 : cfg->inputs[cfg->num_inputs].pin = nid;
61 : 0 : cfg->inputs[cfg->num_inputs].type = type;
62 : 0 : cfg->inputs[cfg->num_inputs].has_boost_on_pin =
63 : 0 : nid_has_volume(codec, nid, HDA_INPUT);
64 : 0 : cfg->num_inputs++;
65 : : }
66 : : }
67 : :
68 : 0 : static int compare_input_type(const void *ap, const void *bp)
69 : : {
70 : 0 : const struct auto_pin_cfg_item *a = ap;
71 : 0 : const struct auto_pin_cfg_item *b = bp;
72 [ # # ]: 0 : if (a->type != b->type)
73 : 0 : return (int)(a->type - b->type);
74 : :
75 : : /* In case one has boost and the other one has not,
76 : : pick the one with boost first. */
77 : 0 : return (int)(b->has_boost_on_pin - a->has_boost_on_pin);
78 : : }
79 : :
80 : : /* Reorder the surround channels
81 : : * ALSA sequence is front/surr/clfe/side
82 : : * HDA sequence is:
83 : : * 4-ch: front/surr => OK as it is
84 : : * 6-ch: front/clfe/surr
85 : : * 8-ch: front/clfe/rear/side|fc
86 : : */
87 : 0 : static void reorder_outputs(unsigned int nums, hda_nid_t *pins)
88 : : {
89 : 0 : hda_nid_t nid;
90 : :
91 : 0 : switch (nums) {
92 : 0 : case 3:
93 : : case 4:
94 : 0 : nid = pins[1];
95 : 0 : pins[1] = pins[2];
96 : 0 : pins[2] = nid;
97 : 0 : break;
98 : : }
99 : 0 : }
100 : :
101 : : /* check whether the given pin has a proper pin I/O capability bit */
102 : 0 : static bool check_pincap_validity(struct hda_codec *codec, hda_nid_t pin,
103 : : unsigned int dev)
104 : : {
105 : 0 : unsigned int pincap = snd_hda_query_pin_caps(codec, pin);
106 : :
107 : : /* some old hardware don't return the proper pincaps */
108 [ # # ]: 0 : if (!pincap)
109 : : return true;
110 : :
111 [ # # ]: 0 : switch (dev) {
112 : 0 : case AC_JACK_LINE_OUT:
113 : : case AC_JACK_SPEAKER:
114 : : case AC_JACK_HP_OUT:
115 : : case AC_JACK_SPDIF_OUT:
116 : : case AC_JACK_DIG_OTHER_OUT:
117 : 0 : return !!(pincap & AC_PINCAP_OUT);
118 : 0 : default:
119 : 0 : return !!(pincap & AC_PINCAP_IN);
120 : : }
121 : : }
122 : :
123 : 0 : static bool can_be_headset_mic(struct hda_codec *codec,
124 : : struct auto_pin_cfg_item *item,
125 : : int seq_number)
126 : : {
127 : 0 : int attr;
128 : 0 : unsigned int def_conf;
129 [ # # ]: 0 : if (item->type != AUTO_PIN_MIC)
130 : : return false;
131 : :
132 [ # # ]: 0 : if (item->is_headset_mic || item->is_headphone_mic)
133 : : return false; /* Already assigned */
134 : :
135 : 0 : def_conf = snd_hda_codec_get_pincfg(codec, item->pin);
136 : 0 : attr = snd_hda_get_input_pin_attr(def_conf);
137 : : if (attr <= INPUT_PIN_ATTR_DOCK)
138 : : return false;
139 : :
140 : 0 : if (seq_number >= 0) {
141 : 0 : int seq = get_defcfg_sequence(def_conf);
142 [ # # ]: 0 : if (seq != seq_number)
143 : 0 : return false;
144 : : }
145 : :
146 : : return true;
147 : : }
148 : :
149 : : /*
150 : : * Parse all pin widgets and store the useful pin nids to cfg
151 : : *
152 : : * The number of line-outs or any primary output is stored in line_outs,
153 : : * and the corresponding output pins are assigned to line_out_pins[],
154 : : * in the order of front, rear, CLFE, side, ...
155 : : *
156 : : * If more extra outputs (speaker and headphone) are found, the pins are
157 : : * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
158 : : * is detected, one of speaker of HP pins is assigned as the primary
159 : : * output, i.e. to line_out_pins[0]. So, line_outs is always positive
160 : : * if any analog output exists.
161 : : *
162 : : * The analog input pins are assigned to inputs array.
163 : : * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
164 : : * respectively.
165 : : */
166 : 0 : int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
167 : : struct auto_pin_cfg *cfg,
168 : : const hda_nid_t *ignore_nids,
169 : : unsigned int cond_flags)
170 : : {
171 : 0 : hda_nid_t nid;
172 : 0 : short seq, assoc_line_out;
173 : 0 : struct auto_out_pin line_out[ARRAY_SIZE(cfg->line_out_pins)];
174 : 0 : struct auto_out_pin speaker_out[ARRAY_SIZE(cfg->speaker_pins)];
175 : 0 : struct auto_out_pin hp_out[ARRAY_SIZE(cfg->hp_pins)];
176 : 0 : int i;
177 : :
178 : 0 : if (!snd_hda_get_int_hint(codec, "parser_flags", &i))
179 : : cond_flags = i;
180 : :
181 : 0 : memset(cfg, 0, sizeof(*cfg));
182 : :
183 : 0 : memset(line_out, 0, sizeof(line_out));
184 : 0 : memset(speaker_out, 0, sizeof(speaker_out));
185 : 0 : memset(hp_out, 0, sizeof(hp_out));
186 : 0 : assoc_line_out = 0;
187 : :
188 [ # # ]: 0 : for_each_hda_codec_node(nid, codec) {
189 [ # # ]: 0 : unsigned int wid_caps = get_wcaps(codec, nid);
190 [ # # ]: 0 : unsigned int wid_type = get_wcaps_type(wid_caps);
191 : 0 : unsigned int def_conf;
192 : 0 : short assoc, loc, conn, dev;
193 : :
194 : : /* read all default configuration for pin complex */
195 [ # # ]: 0 : if (wid_type != AC_WID_PIN)
196 : 0 : continue;
197 : : /* ignore the given nids (e.g. pc-beep returns error) */
198 [ # # # # ]: 0 : if (ignore_nids && is_in_nid_list(nid, ignore_nids))
199 : 0 : continue;
200 : :
201 : 0 : def_conf = snd_hda_codec_get_pincfg(codec, nid);
202 : 0 : conn = get_defcfg_connect(def_conf);
203 [ # # ]: 0 : if (conn == AC_JACK_PORT_NONE)
204 : 0 : continue;
205 : 0 : loc = get_defcfg_location(def_conf);
206 : 0 : dev = get_defcfg_device(def_conf);
207 : :
208 : : /* workaround for buggy BIOS setups */
209 [ # # ]: 0 : if (dev == AC_JACK_LINE_OUT) {
210 [ # # ]: 0 : if (conn == AC_JACK_PORT_FIXED ||
211 : : conn == AC_JACK_PORT_BOTH)
212 : 0 : dev = AC_JACK_SPEAKER;
213 : : }
214 : :
215 [ # # ]: 0 : if (!check_pincap_validity(codec, nid, dev))
216 : 0 : continue;
217 : :
218 [ # # # # : 0 : switch (dev) {
# # # # #
# ]
219 : 0 : case AC_JACK_LINE_OUT:
220 : 0 : seq = get_defcfg_sequence(def_conf);
221 : 0 : assoc = get_defcfg_association(def_conf);
222 : :
223 [ # # ]: 0 : if (!(wid_caps & AC_WCAP_STEREO))
224 [ # # ]: 0 : if (!cfg->mono_out_pin)
225 : 0 : cfg->mono_out_pin = nid;
226 [ # # ]: 0 : if (!assoc)
227 : 0 : continue;
228 [ # # ]: 0 : if (!assoc_line_out)
229 : : assoc_line_out = assoc;
230 [ # # ]: 0 : else if (assoc_line_out != assoc) {
231 : 0 : codec_info(codec,
232 : : "ignore pin 0x%x with mismatching assoc# 0x%x vs 0x%x\n",
233 : : nid, assoc, assoc_line_out);
234 : 0 : continue;
235 : : }
236 [ # # ]: 0 : if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins)) {
237 : 0 : codec_info(codec,
238 : : "ignore pin 0x%x, too many assigned pins\n",
239 : : nid);
240 : 0 : continue;
241 : : }
242 : 0 : line_out[cfg->line_outs].pin = nid;
243 : 0 : line_out[cfg->line_outs].seq = seq;
244 : 0 : cfg->line_outs++;
245 : 0 : break;
246 : 0 : case AC_JACK_SPEAKER:
247 : 0 : seq = get_defcfg_sequence(def_conf);
248 : 0 : assoc = get_defcfg_association(def_conf);
249 [ # # ]: 0 : if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins)) {
250 : 0 : codec_info(codec,
251 : : "ignore pin 0x%x, too many assigned pins\n",
252 : : nid);
253 : 0 : continue;
254 : : }
255 : 0 : speaker_out[cfg->speaker_outs].pin = nid;
256 : 0 : speaker_out[cfg->speaker_outs].seq = (assoc << 4) | seq;
257 : 0 : cfg->speaker_outs++;
258 : 0 : break;
259 : 0 : case AC_JACK_HP_OUT:
260 : 0 : seq = get_defcfg_sequence(def_conf);
261 : 0 : assoc = get_defcfg_association(def_conf);
262 [ # # ]: 0 : if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins)) {
263 : 0 : codec_info(codec,
264 : : "ignore pin 0x%x, too many assigned pins\n",
265 : : nid);
266 : 0 : continue;
267 : : }
268 : 0 : hp_out[cfg->hp_outs].pin = nid;
269 : 0 : hp_out[cfg->hp_outs].seq = (assoc << 4) | seq;
270 : 0 : cfg->hp_outs++;
271 : 0 : break;
272 : 0 : case AC_JACK_MIC_IN:
273 [ # # ]: 0 : add_auto_cfg_input_pin(codec, cfg, nid, AUTO_PIN_MIC);
274 : : break;
275 : 0 : case AC_JACK_LINE_IN:
276 [ # # ]: 0 : add_auto_cfg_input_pin(codec, cfg, nid, AUTO_PIN_LINE_IN);
277 : : break;
278 : 0 : case AC_JACK_CD:
279 [ # # ]: 0 : add_auto_cfg_input_pin(codec, cfg, nid, AUTO_PIN_CD);
280 : : break;
281 : 0 : case AC_JACK_AUX:
282 [ # # ]: 0 : add_auto_cfg_input_pin(codec, cfg, nid, AUTO_PIN_AUX);
283 : : break;
284 : 0 : case AC_JACK_SPDIF_OUT:
285 : : case AC_JACK_DIG_OTHER_OUT:
286 [ # # ]: 0 : if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins)) {
287 : 0 : codec_info(codec,
288 : : "ignore pin 0x%x, too many assigned pins\n",
289 : : nid);
290 : 0 : continue;
291 : : }
292 : 0 : cfg->dig_out_pins[cfg->dig_outs] = nid;
293 : 0 : cfg->dig_out_type[cfg->dig_outs] =
294 : : (loc == AC_JACK_LOC_HDMI) ?
295 [ # # ]: 0 : HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
296 : 0 : cfg->dig_outs++;
297 : 0 : break;
298 : 0 : case AC_JACK_SPDIF_IN:
299 : : case AC_JACK_DIG_OTHER_IN:
300 : 0 : cfg->dig_in_pin = nid;
301 [ # # ]: 0 : if (loc == AC_JACK_LOC_HDMI)
302 : 0 : cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
303 : : else
304 : 0 : cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
305 : : break;
306 : : }
307 : 0 : }
308 : :
309 : : /* Find a pin that could be a headset or headphone mic */
310 [ # # ]: 0 : if (cond_flags & HDA_PINCFG_HEADSET_MIC || cond_flags & HDA_PINCFG_HEADPHONE_MIC) {
311 : 0 : bool hsmic = !!(cond_flags & HDA_PINCFG_HEADSET_MIC);
312 : 0 : bool hpmic = !!(cond_flags & HDA_PINCFG_HEADPHONE_MIC);
313 [ # # # # ]: 0 : for (i = 0; (hsmic || hpmic) && (i < cfg->num_inputs); i++)
314 [ # # # # ]: 0 : if (hsmic && can_be_headset_mic(codec, &cfg->inputs[i], 0xc)) {
315 : 0 : cfg->inputs[i].is_headset_mic = 1;
316 : 0 : hsmic = false;
317 [ # # # # ]: 0 : } else if (hpmic && can_be_headset_mic(codec, &cfg->inputs[i], 0xd)) {
318 : 0 : cfg->inputs[i].is_headphone_mic = 1;
319 : 0 : hpmic = false;
320 : : }
321 : :
322 : : /* If we didn't find our sequence number mark, fall back to any sequence number */
323 [ # # # # ]: 0 : for (i = 0; (hsmic || hpmic) && (i < cfg->num_inputs); i++) {
324 [ # # ]: 0 : if (!can_be_headset_mic(codec, &cfg->inputs[i], -1))
325 : 0 : continue;
326 [ # # ]: 0 : if (hsmic) {
327 : 0 : cfg->inputs[i].is_headset_mic = 1;
328 : 0 : hsmic = false;
329 [ # # ]: 0 : } else if (hpmic) {
330 : 0 : cfg->inputs[i].is_headphone_mic = 1;
331 : 0 : hpmic = false;
332 : : }
333 : : }
334 : :
335 : : if (hsmic)
336 : : codec_dbg(codec, "Told to look for a headset mic, but didn't find any.\n");
337 : : if (hpmic)
338 : : codec_dbg(codec, "Told to look for a headphone mic, but didn't find any.\n");
339 : : }
340 : :
341 : : /* FIX-UP:
342 : : * If no line-out is defined but multiple HPs are found,
343 : : * some of them might be the real line-outs.
344 : : */
345 [ # # # # ]: 0 : if (!cfg->line_outs && cfg->hp_outs > 1 &&
346 [ # # ]: 0 : !(cond_flags & HDA_PINCFG_NO_HP_FIXUP)) {
347 : : int i = 0;
348 [ # # ]: 0 : while (i < cfg->hp_outs) {
349 : : /* The real HPs should have the sequence 0x0f */
350 [ # # ]: 0 : if ((hp_out[i].seq & 0x0f) == 0x0f) {
351 : 0 : i++;
352 : 0 : continue;
353 : : }
354 : : /* Move it to the line-out table */
355 : 0 : line_out[cfg->line_outs++] = hp_out[i];
356 : 0 : cfg->hp_outs--;
357 : 0 : memmove(hp_out + i, hp_out + i + 1,
358 : 0 : sizeof(hp_out[0]) * (cfg->hp_outs - i));
359 : : }
360 : 0 : memset(hp_out + cfg->hp_outs, 0,
361 : 0 : sizeof(hp_out[0]) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs));
362 [ # # ]: 0 : if (!cfg->hp_outs)
363 : 0 : cfg->line_out_type = AUTO_PIN_HP_OUT;
364 : :
365 : : }
366 : :
367 : : /* sort by sequence */
368 : 0 : sort_pins_by_sequence(cfg->line_out_pins, line_out, cfg->line_outs);
369 : 0 : sort_pins_by_sequence(cfg->speaker_pins, speaker_out,
370 : : cfg->speaker_outs);
371 : 0 : sort_pins_by_sequence(cfg->hp_pins, hp_out, cfg->hp_outs);
372 : :
373 : : /*
374 : : * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
375 : : * as a primary output
376 : : */
377 [ # # ]: 0 : if (!cfg->line_outs &&
378 [ # # ]: 0 : !(cond_flags & HDA_PINCFG_NO_LO_FIXUP)) {
379 [ # # ]: 0 : if (cfg->speaker_outs) {
380 : 0 : cfg->line_outs = cfg->speaker_outs;
381 : 0 : memcpy(cfg->line_out_pins, cfg->speaker_pins,
382 : : sizeof(cfg->speaker_pins));
383 : 0 : cfg->speaker_outs = 0;
384 : 0 : memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
385 : 0 : cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
386 [ # # ]: 0 : } else if (cfg->hp_outs) {
387 : 0 : cfg->line_outs = cfg->hp_outs;
388 : 0 : memcpy(cfg->line_out_pins, cfg->hp_pins,
389 : : sizeof(cfg->hp_pins));
390 : 0 : cfg->hp_outs = 0;
391 : 0 : memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
392 : 0 : cfg->line_out_type = AUTO_PIN_HP_OUT;
393 : : }
394 : : }
395 : :
396 [ # # ]: 0 : reorder_outputs(cfg->line_outs, cfg->line_out_pins);
397 [ # # ]: 0 : reorder_outputs(cfg->hp_outs, cfg->hp_pins);
398 [ # # ]: 0 : reorder_outputs(cfg->speaker_outs, cfg->speaker_pins);
399 : :
400 : : /* sort inputs in the order of AUTO_PIN_* type */
401 : 0 : sort(cfg->inputs, cfg->num_inputs, sizeof(cfg->inputs[0]),
402 : : compare_input_type, NULL);
403 : :
404 : : /*
405 : : * debug prints of the parsed results
406 : : */
407 [ # # # # ]: 0 : codec_info(codec, "autoconfig for %s: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
408 : : codec->core.chip_name, cfg->line_outs, cfg->line_out_pins[0],
409 : : cfg->line_out_pins[1], cfg->line_out_pins[2],
410 : : cfg->line_out_pins[3], cfg->line_out_pins[4],
411 : : cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
412 : : (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT ?
413 : : "speaker" : "line"));
414 : 0 : codec_info(codec, " speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
415 : : cfg->speaker_outs, cfg->speaker_pins[0],
416 : : cfg->speaker_pins[1], cfg->speaker_pins[2],
417 : : cfg->speaker_pins[3], cfg->speaker_pins[4]);
418 : 0 : codec_info(codec, " hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
419 : : cfg->hp_outs, cfg->hp_pins[0],
420 : : cfg->hp_pins[1], cfg->hp_pins[2],
421 : : cfg->hp_pins[3], cfg->hp_pins[4]);
422 : 0 : codec_info(codec, " mono: mono_out=0x%x\n", cfg->mono_out_pin);
423 [ # # ]: 0 : if (cfg->dig_outs)
424 : 0 : codec_info(codec, " dig-out=0x%x/0x%x\n",
425 : : cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
426 : 0 : codec_info(codec, " inputs:\n");
427 [ # # ]: 0 : for (i = 0; i < cfg->num_inputs; i++) {
428 : 0 : codec_info(codec, " %s=0x%x\n",
429 : : hda_get_autocfg_input_label(codec, cfg, i),
430 : : cfg->inputs[i].pin);
431 : : }
432 [ # # ]: 0 : if (cfg->dig_in_pin)
433 : 0 : codec_info(codec, " dig-in=0x%x\n", cfg->dig_in_pin);
434 : :
435 : 0 : return 0;
436 : : }
437 : : EXPORT_SYMBOL_GPL(snd_hda_parse_pin_defcfg);
438 : :
439 : : /**
440 : : * snd_hda_get_input_pin_attr - Get the input pin attribute from pin config
441 : : * @def_conf: pin configuration value
442 : : *
443 : : * Guess the input pin attribute (INPUT_PIN_ATTR_XXX) from the given
444 : : * default pin configuration value.
445 : : */
446 : 0 : int snd_hda_get_input_pin_attr(unsigned int def_conf)
447 : : {
448 : 0 : unsigned int loc = get_defcfg_location(def_conf);
449 : 0 : unsigned int conn = get_defcfg_connect(def_conf);
450 [ # # # # ]: 0 : if (conn == AC_JACK_PORT_NONE)
451 : : return INPUT_PIN_ATTR_UNUSED;
452 : : /* Windows may claim the internal mic to be BOTH, too */
453 [ # # # # : 0 : if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH)
# # # # #
# # # # #
# # ]
454 : : return INPUT_PIN_ATTR_INT;
455 [ # # # # : 0 : if ((loc & 0x30) == AC_JACK_LOC_INTERNAL)
# # # # #
# # # # #
# # ]
456 : : return INPUT_PIN_ATTR_INT;
457 [ # # # # : 0 : if ((loc & 0x30) == AC_JACK_LOC_SEPARATE)
# # # # #
# # # # #
# # ]
458 : : return INPUT_PIN_ATTR_DOCK;
459 [ # # # # : 0 : if (loc == AC_JACK_LOC_REAR)
# # # # #
# # # # #
# # ]
460 : : return INPUT_PIN_ATTR_REAR;
461 [ # # # # : 0 : if (loc == AC_JACK_LOC_FRONT)
# # # # #
# # # #
# ]
462 : 0 : return INPUT_PIN_ATTR_FRONT;
463 : : return INPUT_PIN_ATTR_NORMAL;
464 : : }
465 : : EXPORT_SYMBOL_GPL(snd_hda_get_input_pin_attr);
466 : :
467 : : /**
468 : : * hda_get_input_pin_label - Give a label for the given input pin
469 : : * @codec: the HDA codec
470 : : * @item: ping config item to refer
471 : : * @pin: the pin NID
472 : : * @check_location: flag to add the jack location prefix
473 : : *
474 : : * When @check_location is true, the function checks the pin location
475 : : * for mic and line-in pins, and set an appropriate prefix like "Front",
476 : : * "Rear", "Internal".
477 : : */
478 : 0 : static const char *hda_get_input_pin_label(struct hda_codec *codec,
479 : : const struct auto_pin_cfg_item *item,
480 : : hda_nid_t pin, bool check_location)
481 : : {
482 : 0 : unsigned int def_conf;
483 : 0 : static const char * const mic_names[] = {
484 : : "Internal Mic", "Dock Mic", "Mic", "Rear Mic", "Front Mic"
485 : : };
486 : 0 : int attr;
487 : :
488 : 0 : def_conf = snd_hda_codec_get_pincfg(codec, pin);
489 : :
490 [ # # # # : 0 : switch (get_defcfg_device(def_conf)) {
# # # # ]
491 : 0 : case AC_JACK_MIC_IN:
492 [ # # # # ]: 0 : if (item && item->is_headset_mic)
493 : : return "Headset Mic";
494 [ # # # # ]: 0 : if (item && item->is_headphone_mic)
495 : : return "Headphone Mic";
496 [ # # ]: 0 : if (!check_location)
497 : : return "Mic";
498 [ # # ]: 0 : attr = snd_hda_get_input_pin_attr(def_conf);
499 : 0 : if (!attr)
500 : : return "None";
501 : 0 : return mic_names[attr - 1];
502 : 0 : case AC_JACK_LINE_IN:
503 [ # # ]: 0 : if (!check_location)
504 : : return "Line";
505 [ # # ]: 0 : attr = snd_hda_get_input_pin_attr(def_conf);
506 : 0 : if (!attr)
507 : : return "None";
508 [ # # ]: 0 : if (attr == INPUT_PIN_ATTR_DOCK)
509 : 0 : return "Dock Line";
510 : : return "Line";
511 : : case AC_JACK_AUX:
512 : : return "Aux";
513 : 0 : case AC_JACK_CD:
514 : 0 : return "CD";
515 : 0 : case AC_JACK_SPDIF_IN:
516 : 0 : return "SPDIF In";
517 : 0 : case AC_JACK_DIG_OTHER_IN:
518 : 0 : return "Digital In";
519 : 0 : case AC_JACK_HP_OUT:
520 : 0 : return "Headphone Mic";
521 : 0 : default:
522 : 0 : return "Misc";
523 : : }
524 : : }
525 : :
526 : : /* Check whether the location prefix needs to be added to the label.
527 : : * If all mic-jacks are in the same location (e.g. rear panel), we don't
528 : : * have to put "Front" prefix to each label. In such a case, returns false.
529 : : */
530 : 0 : static int check_mic_location_need(struct hda_codec *codec,
531 : : const struct auto_pin_cfg *cfg,
532 : : int input)
533 : : {
534 : 0 : unsigned int defc;
535 : 0 : int i, attr, attr2;
536 : :
537 : 0 : defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin);
538 [ # # ]: 0 : attr = snd_hda_get_input_pin_attr(defc);
539 : : /* for internal or docking mics, we need locations */
540 : : if (attr <= INPUT_PIN_ATTR_NORMAL)
541 : : return 1;
542 : :
543 : : attr = 0;
544 [ # # ]: 0 : for (i = 0; i < cfg->num_inputs; i++) {
545 : 0 : defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin);
546 [ # # ]: 0 : attr2 = snd_hda_get_input_pin_attr(defc);
547 : 0 : if (attr2 >= INPUT_PIN_ATTR_NORMAL) {
548 [ # # ]: 0 : if (attr && attr != attr2)
549 : : return 1; /* different locations found */
550 : : attr = attr2;
551 : : }
552 : : }
553 : : return 0;
554 : : }
555 : :
556 : : /**
557 : : * hda_get_autocfg_input_label - Get a label for the given input
558 : : * @codec: the HDA codec
559 : : * @cfg: the parsed pin configuration
560 : : * @input: the input index number
561 : : *
562 : : * Get a label for the given input pin defined by the autocfg item.
563 : : * Unlike hda_get_input_pin_label(), this function checks all inputs
564 : : * defined in autocfg and avoids the redundant mic/line prefix as much as
565 : : * possible.
566 : : */
567 : 0 : const char *hda_get_autocfg_input_label(struct hda_codec *codec,
568 : : const struct auto_pin_cfg *cfg,
569 : : int input)
570 : : {
571 : 0 : int type = cfg->inputs[input].type;
572 : 0 : int has_multiple_pins = 0;
573 : :
574 [ # # # # ]: 0 : if ((input > 0 && cfg->inputs[input - 1].type == type) ||
575 [ # # # # ]: 0 : (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type))
576 : 0 : has_multiple_pins = 1;
577 [ # # ]: 0 : if (has_multiple_pins && type == AUTO_PIN_MIC)
578 : 0 : has_multiple_pins &= check_mic_location_need(codec, cfg, input);
579 : 0 : has_multiple_pins |= codec->force_pin_prefix;
580 : 0 : return hda_get_input_pin_label(codec, &cfg->inputs[input],
581 : 0 : cfg->inputs[input].pin,
582 : : has_multiple_pins);
583 : : }
584 : : EXPORT_SYMBOL_GPL(hda_get_autocfg_input_label);
585 : :
586 : : /* return the position of NID in the list, or -1 if not found */
587 : 0 : static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
588 : : {
589 : 0 : int i;
590 [ # # # # : 0 : for (i = 0; i < nums; i++)
# # ]
591 [ # # # # : 0 : if (list[i] == nid)
# # ]
592 : : return i;
593 : : return -1;
594 : : }
595 : :
596 : : /* get a unique suffix or an index number */
597 : 0 : static const char *check_output_sfx(hda_nid_t nid, const hda_nid_t *pins,
598 : : int num_pins, int *indexp)
599 : : {
600 : 0 : static const char * const channel_sfx[] = {
601 : : " Front", " Surround", " CLFE", " Side"
602 : : };
603 : 0 : int i;
604 : :
605 : 0 : i = find_idx_in_nid_list(nid, pins, num_pins);
606 [ # # # # ]: 0 : if (i < 0)
607 : : return NULL;
608 [ # # # # ]: 0 : if (num_pins == 1)
609 : : return "";
610 [ # # # # ]: 0 : if (num_pins > ARRAY_SIZE(channel_sfx)) {
611 [ # # # # ]: 0 : if (indexp)
612 : 0 : *indexp = i;
613 : : return "";
614 : : }
615 : 0 : return channel_sfx[i];
616 : : }
617 : :
618 : 0 : static const char *check_output_pfx(struct hda_codec *codec, hda_nid_t nid)
619 : : {
620 : 0 : unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
621 [ # # ]: 0 : int attr = snd_hda_get_input_pin_attr(def_conf);
622 : :
623 : : /* check the location */
624 [ # # # ]: 0 : switch (attr) {
625 : : case INPUT_PIN_ATTR_DOCK:
626 : : return "Dock ";
627 : 0 : case INPUT_PIN_ATTR_FRONT:
628 : 0 : return "Front ";
629 : : }
630 : 0 : return "";
631 : : }
632 : :
633 : 0 : static int get_hp_label_index(struct hda_codec *codec, hda_nid_t nid,
634 : : const hda_nid_t *pins, int num_pins)
635 : : {
636 : 0 : int i, j, idx = 0;
637 : :
638 : 0 : const char *pfx = check_output_pfx(codec, nid);
639 : :
640 : 0 : i = find_idx_in_nid_list(nid, pins, num_pins);
641 [ # # ]: 0 : if (i < 0)
642 : : return -1;
643 [ # # ]: 0 : for (j = 0; j < i; j++)
644 [ # # ]: 0 : if (pfx == check_output_pfx(codec, pins[j]))
645 : 0 : idx++;
646 : :
647 : : return idx;
648 : : }
649 : :
650 : 0 : static int fill_audio_out_name(struct hda_codec *codec, hda_nid_t nid,
651 : : const struct auto_pin_cfg *cfg,
652 : : const char *name, char *label, int maxlen,
653 : : int *indexp)
654 : : {
655 : 0 : unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
656 [ # # ]: 0 : int attr = snd_hda_get_input_pin_attr(def_conf);
657 : 0 : const char *pfx, *sfx = "";
658 : :
659 : : /* handle as a speaker if it's a fixed line-out */
660 [ # # # # ]: 0 : if (!strcmp(name, "Line Out") && attr == INPUT_PIN_ATTR_INT)
661 : 0 : name = "Speaker";
662 : 0 : pfx = check_output_pfx(codec, nid);
663 : :
664 [ # # ]: 0 : if (cfg) {
665 : : /* try to give a unique suffix if needed */
666 : 0 : sfx = check_output_sfx(nid, cfg->line_out_pins, cfg->line_outs,
667 : : indexp);
668 [ # # ]: 0 : if (!sfx)
669 : 0 : sfx = check_output_sfx(nid, cfg->speaker_pins, cfg->speaker_outs,
670 : : indexp);
671 [ # # ]: 0 : if (!sfx) {
672 : : /* don't add channel suffix for Headphone controls */
673 : 0 : int idx = get_hp_label_index(codec, nid, cfg->hp_pins,
674 : : cfg->hp_outs);
675 [ # # ]: 0 : if (idx >= 0 && indexp)
676 : 0 : *indexp = idx;
677 : : sfx = "";
678 : : }
679 : : }
680 : 0 : snprintf(label, maxlen, "%s%s%s", pfx, name, sfx);
681 : 0 : return 1;
682 : : }
683 : :
684 : : #define is_hdmi_cfg(conf) \
685 : : (get_defcfg_location(conf) == AC_JACK_LOC_HDMI)
686 : :
687 : : /**
688 : : * snd_hda_get_pin_label - Get a label for the given I/O pin
689 : : * @codec: the HDA codec
690 : : * @nid: pin NID
691 : : * @cfg: the parsed pin configuration
692 : : * @label: the string buffer to store
693 : : * @maxlen: the max length of string buffer (including termination)
694 : : * @indexp: the pointer to return the index number (for multiple ctls)
695 : : *
696 : : * Get a label for the given pin. This function works for both input and
697 : : * output pins. When @cfg is given as non-NULL, the function tries to get
698 : : * an optimized label using hda_get_autocfg_input_label().
699 : : *
700 : : * This function tries to give a unique label string for the pin as much as
701 : : * possible. For example, when the multiple line-outs are present, it adds
702 : : * the channel suffix like "Front", "Surround", etc (only when @cfg is given).
703 : : * If no unique name with a suffix is available and @indexp is non-NULL, the
704 : : * index number is stored in the pointer.
705 : : */
706 : 0 : int snd_hda_get_pin_label(struct hda_codec *codec, hda_nid_t nid,
707 : : const struct auto_pin_cfg *cfg,
708 : : char *label, int maxlen, int *indexp)
709 : : {
710 : 0 : unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
711 : 0 : const char *name = NULL;
712 : 0 : int i;
713 : 0 : bool hdmi;
714 : :
715 [ # # ]: 0 : if (indexp)
716 : 0 : *indexp = 0;
717 [ # # ]: 0 : if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
718 : : return 0;
719 : :
720 [ # # # # : 0 : switch (get_defcfg_device(def_conf)) {
# ]
721 : 0 : case AC_JACK_LINE_OUT:
722 : 0 : return fill_audio_out_name(codec, nid, cfg, "Line Out",
723 : : label, maxlen, indexp);
724 : 0 : case AC_JACK_SPEAKER:
725 : 0 : return fill_audio_out_name(codec, nid, cfg, "Speaker",
726 : : label, maxlen, indexp);
727 : 0 : case AC_JACK_HP_OUT:
728 : 0 : return fill_audio_out_name(codec, nid, cfg, "Headphone",
729 : : label, maxlen, indexp);
730 : 0 : case AC_JACK_SPDIF_OUT:
731 : : case AC_JACK_DIG_OTHER_OUT:
732 : 0 : hdmi = is_hdmi_cfg(def_conf);
733 [ # # ]: 0 : name = hdmi ? "HDMI" : "SPDIF";
734 [ # # ]: 0 : if (cfg && indexp)
735 [ # # ]: 0 : for (i = 0; i < cfg->dig_outs; i++) {
736 : 0 : hda_nid_t pin = cfg->dig_out_pins[i];
737 : 0 : unsigned int c;
738 [ # # ]: 0 : if (pin == nid)
739 : : break;
740 : 0 : c = snd_hda_codec_get_pincfg(codec, pin);
741 [ # # ]: 0 : if (hdmi == is_hdmi_cfg(c))
742 : 0 : (*indexp)++;
743 : : }
744 : : break;
745 : 0 : default:
746 [ # # ]: 0 : if (cfg) {
747 [ # # ]: 0 : for (i = 0; i < cfg->num_inputs; i++) {
748 [ # # ]: 0 : if (cfg->inputs[i].pin != nid)
749 : 0 : continue;
750 : 0 : name = hda_get_autocfg_input_label(codec, cfg, i);
751 [ # # ]: 0 : if (name)
752 : : break;
753 : : }
754 : : }
755 [ # # ]: 0 : if (!name)
756 : 0 : name = hda_get_input_pin_label(codec, NULL, nid, true);
757 : : break;
758 : : }
759 [ # # ]: 0 : if (!name)
760 : : return 0;
761 : 0 : strlcpy(label, name, maxlen);
762 : 0 : return 1;
763 : : }
764 : : EXPORT_SYMBOL_GPL(snd_hda_get_pin_label);
765 : :
766 : : /**
767 : : * snd_hda_add_verbs - Add verbs to the init list
768 : : * @codec: the HDA codec
769 : : * @list: zero-terminated verb list to add
770 : : *
771 : : * Append the given verb list to the execution list. The verbs will be
772 : : * performed at init and resume time via snd_hda_apply_verbs().
773 : : */
774 : 0 : int snd_hda_add_verbs(struct hda_codec *codec,
775 : : const struct hda_verb *list)
776 : : {
777 : 0 : const struct hda_verb **v;
778 : 0 : v = snd_array_new(&codec->verbs);
779 [ # # # # ]: 0 : if (!v)
780 : : return -ENOMEM;
781 : 0 : *v = list;
782 : 0 : return 0;
783 : : }
784 : : EXPORT_SYMBOL_GPL(snd_hda_add_verbs);
785 : :
786 : : /**
787 : : * snd_hda_apply_verbs - Execute the init verb lists
788 : : * @codec: the HDA codec
789 : : */
790 : 0 : void snd_hda_apply_verbs(struct hda_codec *codec)
791 : : {
792 : 0 : const struct hda_verb **v;
793 : 0 : int i;
794 : :
795 [ # # ]: 0 : snd_array_for_each(&codec->verbs, i, v)
796 : 0 : snd_hda_sequence_write(codec, *v);
797 : 0 : }
798 : : EXPORT_SYMBOL_GPL(snd_hda_apply_verbs);
799 : :
800 : : /**
801 : : * snd_hda_apply_pincfgs - Set each pin config in the given list
802 : : * @codec: the HDA codec
803 : : * @cfg: NULL-terminated pin config table
804 : : */
805 : 0 : void snd_hda_apply_pincfgs(struct hda_codec *codec,
806 : : const struct hda_pintbl *cfg)
807 : : {
808 [ # # # # ]: 0 : for (; cfg->nid; cfg++)
809 : 0 : snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
810 : 0 : }
811 : : EXPORT_SYMBOL_GPL(snd_hda_apply_pincfgs);
812 : :
813 : : static void set_pin_targets(struct hda_codec *codec,
814 : : const struct hda_pintbl *cfg)
815 : : {
816 [ # # ]: 0 : for (; cfg->nid; cfg++)
817 : 0 : snd_hda_set_pin_ctl_cache(codec, cfg->nid, cfg->val);
818 : : }
819 : :
820 : 0 : static void apply_fixup(struct hda_codec *codec, int id, int action, int depth)
821 : : {
822 : 0 : const char *modelname = codec->fixup_name;
823 : :
824 [ # # ]: 0 : while (id >= 0) {
825 : 0 : const struct hda_fixup *fix = codec->fixup_list + id;
826 : :
827 [ # # ]: 0 : if (++depth > 10)
828 : : break;
829 [ # # ]: 0 : if (fix->chained_before)
830 : 0 : apply_fixup(codec, fix->chain_id, action, depth + 1);
831 : :
832 [ # # # # : 0 : switch (fix->type) {
# ]
833 : 0 : case HDA_FIXUP_PINS:
834 [ # # # # ]: 0 : if (action != HDA_FIXUP_ACT_PRE_PROBE || !fix->v.pins)
835 : : break;
836 : : codec_dbg(codec, "%s: Apply pincfg for %s\n",
837 : : codec->core.chip_name, modelname);
838 : : snd_hda_apply_pincfgs(codec, fix->v.pins);
839 : : break;
840 : 0 : case HDA_FIXUP_VERBS:
841 [ # # # # ]: 0 : if (action != HDA_FIXUP_ACT_PROBE || !fix->v.verbs)
842 : : break;
843 : 0 : codec_dbg(codec, "%s: Apply fix-verbs for %s\n",
844 : : codec->core.chip_name, modelname);
845 : 0 : snd_hda_add_verbs(codec, fix->v.verbs);
846 : : break;
847 : 0 : case HDA_FIXUP_FUNC:
848 [ # # ]: 0 : if (!fix->v.func)
849 : : break;
850 : 0 : codec_dbg(codec, "%s: Apply fix-func for %s\n",
851 : : codec->core.chip_name, modelname);
852 : 0 : fix->v.func(codec, fix, action);
853 : 0 : break;
854 : 0 : case HDA_FIXUP_PINCTLS:
855 [ # # # # ]: 0 : if (action != HDA_FIXUP_ACT_PROBE || !fix->v.pins)
856 : : break;
857 : : codec_dbg(codec, "%s: Apply pinctl for %s\n",
858 : : codec->core.chip_name, modelname);
859 : : set_pin_targets(codec, fix->v.pins);
860 : : break;
861 : 0 : default:
862 : 0 : codec_err(codec, "%s: Invalid fixup type %d\n",
863 : : codec->core.chip_name, fix->type);
864 : 0 : break;
865 : : }
866 [ # # # # ]: 0 : if (!fix->chained || fix->chained_before)
867 : : break;
868 : 0 : id = fix->chain_id;
869 : : }
870 : 0 : }
871 : :
872 : : /**
873 : : * snd_hda_apply_fixup - Apply the fixup chain with the given action
874 : : * @codec: the HDA codec
875 : : * @action: fixup action (HDA_FIXUP_ACT_XXX)
876 : : */
877 : 0 : void snd_hda_apply_fixup(struct hda_codec *codec, int action)
878 : : {
879 [ # # ]: 0 : if (codec->fixup_list)
880 : 0 : apply_fixup(codec, codec->fixup_id, action, 0);
881 : 0 : }
882 : : EXPORT_SYMBOL_GPL(snd_hda_apply_fixup);
883 : :
884 : : #define IGNORE_SEQ_ASSOC (~(AC_DEFCFG_SEQUENCE | AC_DEFCFG_DEF_ASSOC))
885 : :
886 : 0 : static bool pin_config_match(struct hda_codec *codec,
887 : : const struct hda_pintbl *pins,
888 : : bool match_all_pins)
889 : : {
890 : 0 : const struct hda_pincfg *pin;
891 : 0 : int i;
892 : :
893 [ # # ]: 0 : snd_array_for_each(&codec->init_pins, i, pin) {
894 : 0 : hda_nid_t nid = pin->nid;
895 : 0 : u32 cfg = pin->cfg;
896 : 0 : const struct hda_pintbl *t_pins;
897 : 0 : int found;
898 : :
899 : 0 : t_pins = pins;
900 : 0 : found = 0;
901 [ # # ]: 0 : for (; t_pins->nid; t_pins++) {
902 [ # # ]: 0 : if (t_pins->nid == nid) {
903 : 0 : found = 1;
904 [ # # ]: 0 : if ((t_pins->val & IGNORE_SEQ_ASSOC) == (cfg & IGNORE_SEQ_ASSOC))
905 : : break;
906 [ # # # # ]: 0 : else if ((cfg & 0xf0000000) == 0x40000000 && (t_pins->val & 0xf0000000) == 0x40000000)
907 : : break;
908 : : else
909 : : return false;
910 : : }
911 : : }
912 : 0 : if (match_all_pins &&
913 [ # # # # ]: 0 : !found && (cfg & 0xf0000000) != 0x40000000)
914 : : return false;
915 : : }
916 : :
917 : : return true;
918 : : }
919 : :
920 : : /**
921 : : * snd_hda_pick_pin_fixup - Pick up a fixup matching with the pin quirk list
922 : : * @codec: the HDA codec
923 : : * @pin_quirk: zero-terminated pin quirk list
924 : : * @fixlist: the fixup list
925 : : * @match_all_pins: all valid pins must match with the table entries
926 : : */
927 : 0 : void snd_hda_pick_pin_fixup(struct hda_codec *codec,
928 : : const struct snd_hda_pin_quirk *pin_quirk,
929 : : const struct hda_fixup *fixlist,
930 : : bool match_all_pins)
931 : : {
932 : 0 : const struct snd_hda_pin_quirk *pq;
933 : :
934 [ # # ]: 0 : if (codec->fixup_id != HDA_FIXUP_ID_NOT_SET)
935 : : return;
936 : :
937 [ # # ]: 0 : for (pq = pin_quirk; pq->subvendor; pq++) {
938 [ # # ]: 0 : if ((codec->core.subsystem_id & 0xffff0000) != (pq->subvendor << 16))
939 : 0 : continue;
940 [ # # ]: 0 : if (codec->core.vendor_id != pq->codec)
941 : 0 : continue;
942 [ # # ]: 0 : if (pin_config_match(codec, pq->pins, match_all_pins)) {
943 : 0 : codec->fixup_id = pq->value;
944 : : #ifdef CONFIG_SND_DEBUG_VERBOSE
945 : : codec->fixup_name = pq->name;
946 : : codec_dbg(codec, "%s: picked fixup %s (pin match)\n",
947 : : codec->core.chip_name, codec->fixup_name);
948 : : #endif
949 : 0 : codec->fixup_list = fixlist;
950 : 0 : return;
951 : : }
952 : : }
953 : : }
954 : : EXPORT_SYMBOL_GPL(snd_hda_pick_pin_fixup);
955 : :
956 : : /**
957 : : * snd_hda_pick_fixup - Pick up a fixup matching with PCI/codec SSID or model string
958 : : * @codec: the HDA codec
959 : : * @models: NULL-terminated model string list
960 : : * @quirk: zero-terminated PCI/codec SSID quirk list
961 : : * @fixlist: the fixup list
962 : : *
963 : : * Pick up a fixup entry matching with the given model string or SSID.
964 : : * If a fixup was already set beforehand, the function doesn't do anything.
965 : : * When a special model string "nofixup" is given, also no fixup is applied.
966 : : *
967 : : * The function tries to find the matching model name at first, if given.
968 : : * If nothing matched, try to look up the PCI SSID.
969 : : * If still nothing matched, try to look up the codec SSID.
970 : : */
971 : 0 : void snd_hda_pick_fixup(struct hda_codec *codec,
972 : : const struct hda_model_fixup *models,
973 : : const struct snd_pci_quirk *quirk,
974 : : const struct hda_fixup *fixlist)
975 : : {
976 : 0 : const struct snd_pci_quirk *q;
977 : 0 : int id = HDA_FIXUP_ID_NOT_SET;
978 : 0 : const char *name = NULL;
979 : :
980 [ # # ]: 0 : if (codec->fixup_id != HDA_FIXUP_ID_NOT_SET)
981 : : return;
982 : :
983 : : /* when model=nofixup is given, don't pick up any fixups */
984 [ # # # # ]: 0 : if (codec->modelname && !strcmp(codec->modelname, "nofixup")) {
985 : 0 : codec->fixup_list = NULL;
986 : 0 : codec->fixup_name = NULL;
987 : 0 : codec->fixup_id = HDA_FIXUP_ID_NO_FIXUP;
988 : 0 : codec_dbg(codec, "%s: picked no fixup (nofixup specified)\n",
989 : : codec->core.chip_name);
990 : 0 : return;
991 : : }
992 : :
993 [ # # # # ]: 0 : if (codec->modelname && models) {
994 [ # # ]: 0 : while (models->name) {
995 [ # # ]: 0 : if (!strcmp(codec->modelname, models->name)) {
996 : 0 : codec->fixup_id = models->id;
997 : 0 : codec->fixup_name = models->name;
998 : 0 : codec->fixup_list = fixlist;
999 : 0 : codec_dbg(codec, "%s: picked fixup %s (model specified)\n",
1000 : : codec->core.chip_name, codec->fixup_name);
1001 : 0 : return;
1002 : : }
1003 : 0 : models++;
1004 : : }
1005 : : }
1006 [ # # ]: 0 : if (quirk) {
1007 : 0 : q = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1008 [ # # ]: 0 : if (q) {
1009 : 0 : id = q->value;
1010 : : #ifdef CONFIG_SND_DEBUG_VERBOSE
1011 : : name = q->name;
1012 : : codec_dbg(codec, "%s: picked fixup %s (PCI SSID%s)\n",
1013 : : codec->core.chip_name, name, q->subdevice_mask ? "" : " - vendor generic");
1014 : : #endif
1015 : : }
1016 : : }
1017 [ # # ]: 0 : if (id < 0 && quirk) {
1018 [ # # ]: 0 : for (q = quirk; q->subvendor || q->subdevice; q++) {
1019 : 0 : unsigned int vendorid =
1020 : 0 : q->subdevice | (q->subvendor << 16);
1021 : 0 : unsigned int mask = 0xffff0000 | q->subdevice_mask;
1022 [ # # ]: 0 : if ((codec->core.subsystem_id & mask) == (vendorid & mask)) {
1023 : 0 : id = q->value;
1024 : : #ifdef CONFIG_SND_DEBUG_VERBOSE
1025 : : name = q->name;
1026 : : codec_dbg(codec, "%s: picked fixup %s (codec SSID)\n",
1027 : : codec->core.chip_name, name);
1028 : : #endif
1029 : 0 : break;
1030 : : }
1031 : : }
1032 : : }
1033 : :
1034 : 0 : codec->fixup_id = id;
1035 [ # # ]: 0 : if (id >= 0) {
1036 : 0 : codec->fixup_list = fixlist;
1037 : 0 : codec->fixup_name = name;
1038 : : }
1039 : : }
1040 : : EXPORT_SYMBOL_GPL(snd_hda_pick_fixup);
|
