Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * Universal Interface for Intel High Definition Audio Codec
4 : : *
5 : : * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
6 : : */
7 : :
8 : : #include <linux/init.h>
9 : : #include <linux/delay.h>
10 : : #include <linux/slab.h>
11 : : #include <linux/mutex.h>
12 : : #include <linux/module.h>
13 : : #include <linux/pm.h>
14 : : #include <linux/pm_runtime.h>
15 : : #include <sound/core.h>
16 : : #include <sound/hda_codec.h>
17 : : #include <sound/asoundef.h>
18 : : #include <sound/tlv.h>
19 : : #include <sound/initval.h>
20 : : #include <sound/jack.h>
21 : : #include "hda_local.h"
22 : : #include "hda_beep.h"
23 : : #include "hda_jack.h"
24 : : #include <sound/hda_hwdep.h>
25 : : #include <sound/hda_component.h>
26 : :
27 : : #define codec_in_pm(codec) snd_hdac_is_in_pm(&codec->core)
28 : : #define hda_codec_is_power_on(codec) snd_hdac_is_power_on(&codec->core)
29 : : #define codec_has_epss(codec) \
30 : : ((codec)->core.power_caps & AC_PWRST_EPSS)
31 : : #define codec_has_clkstop(codec) \
32 : : ((codec)->core.power_caps & AC_PWRST_CLKSTOP)
33 : :
34 : : /*
35 : : * Send and receive a verb - passed to exec_verb override for hdac_device
36 : : */
37 : 0 : static int codec_exec_verb(struct hdac_device *dev, unsigned int cmd,
38 : : unsigned int flags, unsigned int *res)
39 : : {
40 : 0 : struct hda_codec *codec = container_of(dev, struct hda_codec, core);
41 : 0 : struct hda_bus *bus = codec->bus;
42 : 0 : int err;
43 : :
44 [ # # ]: 0 : if (cmd == ~0)
45 : : return -1;
46 : :
47 : 0 : again:
48 : 0 : snd_hda_power_up_pm(codec);
49 : 0 : mutex_lock(&bus->core.cmd_mutex);
50 [ # # ]: 0 : if (flags & HDA_RW_NO_RESPONSE_FALLBACK)
51 : 0 : bus->no_response_fallback = 1;
52 : 0 : err = snd_hdac_bus_exec_verb_unlocked(&bus->core, codec->core.addr,
53 : : cmd, res);
54 : 0 : bus->no_response_fallback = 0;
55 : 0 : mutex_unlock(&bus->core.cmd_mutex);
56 : 0 : snd_hda_power_down_pm(codec);
57 [ # # # # ]: 0 : if (!codec_in_pm(codec) && res && err == -EAGAIN) {
58 [ # # ]: 0 : if (bus->response_reset) {
59 : 0 : codec_dbg(codec,
60 : : "resetting BUS due to fatal communication error\n");
61 : 0 : snd_hda_bus_reset(bus);
62 : : }
63 : 0 : goto again;
64 : : }
65 : : /* clear reset-flag when the communication gets recovered */
66 [ # # # # ]: 0 : if (!err || codec_in_pm(codec))
67 : 0 : bus->response_reset = 0;
68 : : return err;
69 : : }
70 : :
71 : : /**
72 : : * snd_hda_sequence_write - sequence writes
73 : : * @codec: the HDA codec
74 : : * @seq: VERB array to send
75 : : *
76 : : * Send the commands sequentially from the given array.
77 : : * The array must be terminated with NID=0.
78 : : */
79 : 0 : void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
80 : : {
81 [ # # ]: 0 : for (; seq->nid; seq++)
82 : 0 : snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
83 : 0 : }
84 : : EXPORT_SYMBOL_GPL(snd_hda_sequence_write);
85 : :
86 : : /* connection list element */
87 : : struct hda_conn_list {
88 : : struct list_head list;
89 : : int len;
90 : : hda_nid_t nid;
91 : : hda_nid_t conns[0];
92 : : };
93 : :
94 : : /* look up the cached results */
95 : : static struct hda_conn_list *
96 : 0 : lookup_conn_list(struct hda_codec *codec, hda_nid_t nid)
97 : : {
98 : 0 : struct hda_conn_list *p;
99 [ # # # # ]: 0 : list_for_each_entry(p, &codec->conn_list, list) {
100 [ # # # # ]: 0 : if (p->nid == nid)
101 : : return p;
102 : : }
103 : : return NULL;
104 : : }
105 : :
106 : 0 : static int add_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
107 : : const hda_nid_t *list)
108 : : {
109 : 0 : struct hda_conn_list *p;
110 : :
111 [ # # ]: 0 : p = kmalloc(struct_size(p, conns, len), GFP_KERNEL);
112 [ # # ]: 0 : if (!p)
113 : : return -ENOMEM;
114 : 0 : p->len = len;
115 : 0 : p->nid = nid;
116 : 0 : memcpy(p->conns, list, len * sizeof(hda_nid_t));
117 : 0 : list_add(&p->list, &codec->conn_list);
118 : 0 : return 0;
119 : : }
120 : :
121 : 0 : static void remove_conn_list(struct hda_codec *codec)
122 : : {
123 [ # # ]: 0 : while (!list_empty(&codec->conn_list)) {
124 : 0 : struct hda_conn_list *p;
125 : 0 : p = list_first_entry(&codec->conn_list, typeof(*p), list);
126 : 0 : list_del(&p->list);
127 : 0 : kfree(p);
128 : : }
129 : 0 : }
130 : :
131 : : /* read the connection and add to the cache */
132 : 0 : static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
133 : : {
134 : 0 : hda_nid_t list[32];
135 : 0 : hda_nid_t *result = list;
136 : 0 : int len;
137 : :
138 : 0 : len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
139 [ # # ]: 0 : if (len == -ENOSPC) {
140 : 0 : len = snd_hda_get_num_raw_conns(codec, nid);
141 : 0 : result = kmalloc_array(len, sizeof(hda_nid_t), GFP_KERNEL);
142 [ # # ]: 0 : if (!result)
143 : : return -ENOMEM;
144 : 0 : len = snd_hda_get_raw_connections(codec, nid, result, len);
145 : : }
146 [ # # ]: 0 : if (len >= 0)
147 : 0 : len = snd_hda_override_conn_list(codec, nid, len, result);
148 [ # # ]: 0 : if (result != list)
149 : 0 : kfree(result);
150 : : return len;
151 : : }
152 : :
153 : : /**
154 : : * snd_hda_get_conn_list - get connection list
155 : : * @codec: the HDA codec
156 : : * @nid: NID to parse
157 : : * @listp: the pointer to store NID list
158 : : *
159 : : * Parses the connection list of the given widget and stores the pointer
160 : : * to the list of NIDs.
161 : : *
162 : : * Returns the number of connections, or a negative error code.
163 : : *
164 : : * Note that the returned pointer isn't protected against the list
165 : : * modification. If snd_hda_override_conn_list() might be called
166 : : * concurrently, protect with a mutex appropriately.
167 : : */
168 : 0 : int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
169 : : const hda_nid_t **listp)
170 : : {
171 : 0 : bool added = false;
172 : :
173 : 0 : for (;;) {
174 : 0 : int err;
175 : 0 : const struct hda_conn_list *p;
176 : :
177 : : /* if the connection-list is already cached, read it */
178 : 0 : p = lookup_conn_list(codec, nid);
179 [ # # ]: 0 : if (p) {
180 [ # # ]: 0 : if (listp)
181 : 0 : *listp = p->conns;
182 : 0 : return p->len;
183 : : }
184 [ # # ]: 0 : if (snd_BUG_ON(added))
185 : : return -EINVAL;
186 : :
187 : 0 : err = read_and_add_raw_conns(codec, nid);
188 [ # # ]: 0 : if (err < 0)
189 : 0 : return err;
190 : : added = true;
191 : : }
192 : : }
193 : : EXPORT_SYMBOL_GPL(snd_hda_get_conn_list);
194 : :
195 : : /**
196 : : * snd_hda_get_connections - copy connection list
197 : : * @codec: the HDA codec
198 : : * @nid: NID to parse
199 : : * @conn_list: connection list array; when NULL, checks only the size
200 : : * @max_conns: max. number of connections to store
201 : : *
202 : : * Parses the connection list of the given widget and stores the list
203 : : * of NIDs.
204 : : *
205 : : * Returns the number of connections, or a negative error code.
206 : : */
207 : 0 : int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
208 : : hda_nid_t *conn_list, int max_conns)
209 : : {
210 : 0 : const hda_nid_t *list;
211 : 0 : int len = snd_hda_get_conn_list(codec, nid, &list);
212 : :
213 [ # # ]: 0 : if (len > 0 && conn_list) {
214 [ # # ]: 0 : if (len > max_conns) {
215 : 0 : codec_err(codec, "Too many connections %d for NID 0x%x\n",
216 : : len, nid);
217 : 0 : return -EINVAL;
218 : : }
219 : 0 : memcpy(conn_list, list, len * sizeof(hda_nid_t));
220 : : }
221 : :
222 : : return len;
223 : : }
224 : : EXPORT_SYMBOL_GPL(snd_hda_get_connections);
225 : :
226 : : /**
227 : : * snd_hda_override_conn_list - add/modify the connection-list to cache
228 : : * @codec: the HDA codec
229 : : * @nid: NID to parse
230 : : * @len: number of connection list entries
231 : : * @list: the list of connection entries
232 : : *
233 : : * Add or modify the given connection-list to the cache. If the corresponding
234 : : * cache already exists, invalidate it and append a new one.
235 : : *
236 : : * Returns zero or a negative error code.
237 : : */
238 : 0 : int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
239 : : const hda_nid_t *list)
240 : : {
241 : 0 : struct hda_conn_list *p;
242 : :
243 : 0 : p = lookup_conn_list(codec, nid);
244 [ # # ]: 0 : if (p) {
245 : 0 : list_del(&p->list);
246 : 0 : kfree(p);
247 : : }
248 : :
249 : 0 : return add_conn_list(codec, nid, len, list);
250 : : }
251 : : EXPORT_SYMBOL_GPL(snd_hda_override_conn_list);
252 : :
253 : : /**
254 : : * snd_hda_get_conn_index - get the connection index of the given NID
255 : : * @codec: the HDA codec
256 : : * @mux: NID containing the list
257 : : * @nid: NID to select
258 : : * @recursive: 1 when searching NID recursively, otherwise 0
259 : : *
260 : : * Parses the connection list of the widget @mux and checks whether the
261 : : * widget @nid is present. If it is, return the connection index.
262 : : * Otherwise it returns -1.
263 : : */
264 : 0 : int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
265 : : hda_nid_t nid, int recursive)
266 : : {
267 : 0 : const hda_nid_t *conn;
268 : 0 : int i, nums;
269 : :
270 : 0 : nums = snd_hda_get_conn_list(codec, mux, &conn);
271 [ # # ]: 0 : for (i = 0; i < nums; i++)
272 [ # # ]: 0 : if (conn[i] == nid)
273 : 0 : return i;
274 [ # # ]: 0 : if (!recursive)
275 : : return -1;
276 [ # # ]: 0 : if (recursive > 10) {
277 : : codec_dbg(codec, "too deep connection for 0x%x\n", nid);
278 : : return -1;
279 : : }
280 : 0 : recursive++;
281 [ # # ]: 0 : for (i = 0; i < nums; i++) {
282 [ # # ]: 0 : unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
283 [ # # ]: 0 : if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
284 : 0 : continue;
285 [ # # ]: 0 : if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
286 : 0 : return i;
287 : : }
288 : : return -1;
289 : : }
290 : : EXPORT_SYMBOL_GPL(snd_hda_get_conn_index);
291 : :
292 : : /**
293 : : * snd_hda_get_num_devices - get DEVLIST_LEN parameter of the given widget
294 : : * @codec: the HDA codec
295 : : * @nid: NID of the pin to parse
296 : : *
297 : : * Get the device entry number on the given widget. This is a feature of
298 : : * DP MST audio. Each pin can have several device entries in it.
299 : : */
300 : 0 : unsigned int snd_hda_get_num_devices(struct hda_codec *codec, hda_nid_t nid)
301 : : {
302 [ # # ]: 0 : unsigned int wcaps = get_wcaps(codec, nid);
303 : 0 : unsigned int parm;
304 : :
305 [ # # # # : 0 : if (!codec->dp_mst || !(wcaps & AC_WCAP_DIGITAL) ||
# # ]
306 : : get_wcaps_type(wcaps) != AC_WID_PIN)
307 : : return 0;
308 : :
309 : 0 : parm = snd_hdac_read_parm_uncached(&codec->core, nid, AC_PAR_DEVLIST_LEN);
310 [ # # ]: 0 : if (parm == -1)
311 : 0 : parm = 0;
312 : 0 : return parm & AC_DEV_LIST_LEN_MASK;
313 : : }
314 : : EXPORT_SYMBOL_GPL(snd_hda_get_num_devices);
315 : :
316 : : /**
317 : : * snd_hda_get_devices - copy device list without cache
318 : : * @codec: the HDA codec
319 : : * @nid: NID of the pin to parse
320 : : * @dev_list: device list array
321 : : * @max_devices: max. number of devices to store
322 : : *
323 : : * Copy the device list. This info is dynamic and so not cached.
324 : : * Currently called only from hda_proc.c, so not exported.
325 : : */
326 : 0 : int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
327 : : u8 *dev_list, int max_devices)
328 : : {
329 : 0 : unsigned int parm;
330 : 0 : int i, dev_len, devices;
331 : :
332 : 0 : parm = snd_hda_get_num_devices(codec, nid);
333 [ # # ]: 0 : if (!parm) /* not multi-stream capable */
334 : : return 0;
335 : :
336 : 0 : dev_len = parm + 1;
337 : 0 : dev_len = dev_len < max_devices ? dev_len : max_devices;
338 : :
339 : 0 : devices = 0;
340 [ # # ]: 0 : while (devices < dev_len) {
341 [ # # ]: 0 : if (snd_hdac_read(&codec->core, nid,
342 : : AC_VERB_GET_DEVICE_LIST, devices, &parm))
343 : : break; /* error */
344 : :
345 [ # # ]: 0 : for (i = 0; i < 8; i++) {
346 : 0 : dev_list[devices] = (u8)parm;
347 : 0 : parm >>= 4;
348 : 0 : devices++;
349 [ # # ]: 0 : if (devices >= dev_len)
350 : : break;
351 : : }
352 : : }
353 : : return devices;
354 : : }
355 : :
356 : : /**
357 : : * snd_hda_get_dev_select - get device entry select on the pin
358 : : * @codec: the HDA codec
359 : : * @nid: NID of the pin to get device entry select
360 : : *
361 : : * Get the devcie entry select on the pin. Return the device entry
362 : : * id selected on the pin. Return 0 means the first device entry
363 : : * is selected or MST is not supported.
364 : : */
365 : 0 : int snd_hda_get_dev_select(struct hda_codec *codec, hda_nid_t nid)
366 : : {
367 : : /* not support dp_mst will always return 0, using first dev_entry */
368 [ # # ]: 0 : if (!codec->dp_mst)
369 : : return 0;
370 : :
371 : 0 : return snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DEVICE_SEL, 0);
372 : : }
373 : : EXPORT_SYMBOL_GPL(snd_hda_get_dev_select);
374 : :
375 : : /**
376 : : * snd_hda_set_dev_select - set device entry select on the pin
377 : : * @codec: the HDA codec
378 : : * @nid: NID of the pin to set device entry select
379 : : * @dev_id: device entry id to be set
380 : : *
381 : : * Set the device entry select on the pin nid.
382 : : */
383 : 0 : int snd_hda_set_dev_select(struct hda_codec *codec, hda_nid_t nid, int dev_id)
384 : : {
385 : 0 : int ret, num_devices;
386 : :
387 : : /* not support dp_mst will always return 0, using first dev_entry */
388 [ # # ]: 0 : if (!codec->dp_mst)
389 : : return 0;
390 : :
391 : : /* AC_PAR_DEVLIST_LEN is 0 based. */
392 : 0 : num_devices = snd_hda_get_num_devices(codec, nid) + 1;
393 : : /* If Device List Length is 0 (num_device = 1),
394 : : * the pin is not multi stream capable.
395 : : * Do nothing in this case.
396 : : */
397 [ # # ]: 0 : if (num_devices == 1)
398 : : return 0;
399 : :
400 : : /* Behavior of setting index being equal to or greater than
401 : : * Device List Length is not predictable
402 : : */
403 [ # # ]: 0 : if (num_devices <= dev_id)
404 : : return -EINVAL;
405 : :
406 : 0 : ret = snd_hda_codec_write(codec, nid, 0,
407 : : AC_VERB_SET_DEVICE_SEL, dev_id);
408 : :
409 : 0 : return ret;
410 : : }
411 : : EXPORT_SYMBOL_GPL(snd_hda_set_dev_select);
412 : :
413 : : /*
414 : : * read widget caps for each widget and store in cache
415 : : */
416 : 0 : static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
417 : : {
418 : 0 : int i;
419 : 0 : hda_nid_t nid;
420 : :
421 : 0 : codec->wcaps = kmalloc_array(codec->core.num_nodes, 4, GFP_KERNEL);
422 [ # # ]: 0 : if (!codec->wcaps)
423 : : return -ENOMEM;
424 : 0 : nid = codec->core.start_nid;
425 [ # # ]: 0 : for (i = 0; i < codec->core.num_nodes; i++, nid++)
426 : 0 : codec->wcaps[i] = snd_hdac_read_parm_uncached(&codec->core,
427 : : nid, AC_PAR_AUDIO_WIDGET_CAP);
428 : : return 0;
429 : : }
430 : :
431 : : /* read all pin default configurations and save codec->init_pins */
432 : 0 : static int read_pin_defaults(struct hda_codec *codec)
433 : : {
434 : 0 : hda_nid_t nid;
435 : :
436 [ # # ]: 0 : for_each_hda_codec_node(nid, codec) {
437 : 0 : struct hda_pincfg *pin;
438 [ # # ]: 0 : unsigned int wcaps = get_wcaps(codec, nid);
439 [ # # ]: 0 : unsigned int wid_type = get_wcaps_type(wcaps);
440 [ # # ]: 0 : if (wid_type != AC_WID_PIN)
441 : 0 : continue;
442 : 0 : pin = snd_array_new(&codec->init_pins);
443 [ # # ]: 0 : if (!pin)
444 : : return -ENOMEM;
445 : 0 : pin->nid = nid;
446 : 0 : pin->cfg = snd_hda_codec_read(codec, nid, 0,
447 : : AC_VERB_GET_CONFIG_DEFAULT, 0);
448 : : /*
449 : : * all device entries are the same widget control so far
450 : : * fixme: if any codec is different, need fix here
451 : : */
452 : 0 : pin->ctrl = snd_hda_codec_read(codec, nid, 0,
453 : : AC_VERB_GET_PIN_WIDGET_CONTROL,
454 : : 0);
455 : : }
456 : : return 0;
457 : : }
458 : :
459 : : /* look up the given pin config list and return the item matching with NID */
460 : 0 : static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
461 : : struct snd_array *array,
462 : : hda_nid_t nid)
463 : : {
464 : 0 : struct hda_pincfg *pin;
465 : 0 : int i;
466 : :
467 [ # # # # : 0 : snd_array_for_each(array, i, pin) {
# # # # #
# # # ]
468 [ # # # # : 0 : if (pin->nid == nid)
# # # # #
# # # ]
469 : : return pin;
470 : : }
471 : : return NULL;
472 : : }
473 : :
474 : : /* set the current pin config value for the given NID.
475 : : * the value is cached, and read via snd_hda_codec_get_pincfg()
476 : : */
477 : 0 : int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
478 : : hda_nid_t nid, unsigned int cfg)
479 : : {
480 : 0 : struct hda_pincfg *pin;
481 : :
482 : : /* the check below may be invalid when pins are added by a fixup
483 : : * dynamically (e.g. via snd_hda_codec_update_widgets()), so disabled
484 : : * for now
485 : : */
486 : : /*
487 : : if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
488 : : return -EINVAL;
489 : : */
490 : :
491 : 0 : pin = look_up_pincfg(codec, list, nid);
492 [ # # ]: 0 : if (!pin) {
493 : 0 : pin = snd_array_new(list);
494 [ # # ]: 0 : if (!pin)
495 : : return -ENOMEM;
496 : 0 : pin->nid = nid;
497 : : }
498 : 0 : pin->cfg = cfg;
499 : 0 : return 0;
500 : : }
501 : :
502 : : /**
503 : : * snd_hda_codec_set_pincfg - Override a pin default configuration
504 : : * @codec: the HDA codec
505 : : * @nid: NID to set the pin config
506 : : * @cfg: the pin default config value
507 : : *
508 : : * Override a pin default configuration value in the cache.
509 : : * This value can be read by snd_hda_codec_get_pincfg() in a higher
510 : : * priority than the real hardware value.
511 : : */
512 : 0 : int snd_hda_codec_set_pincfg(struct hda_codec *codec,
513 : : hda_nid_t nid, unsigned int cfg)
514 : : {
515 : 0 : return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
516 : : }
517 : : EXPORT_SYMBOL_GPL(snd_hda_codec_set_pincfg);
518 : :
519 : : /**
520 : : * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
521 : : * @codec: the HDA codec
522 : : * @nid: NID to get the pin config
523 : : *
524 : : * Get the current pin config value of the given pin NID.
525 : : * If the pincfg value is cached or overridden via sysfs or driver,
526 : : * returns the cached value.
527 : : */
528 : 0 : unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
529 : : {
530 : 0 : struct hda_pincfg *pin;
531 : :
532 : : #ifdef CONFIG_SND_HDA_RECONFIG
533 : : {
534 : : unsigned int cfg = 0;
535 : : mutex_lock(&codec->user_mutex);
536 : : pin = look_up_pincfg(codec, &codec->user_pins, nid);
537 : : if (pin)
538 : : cfg = pin->cfg;
539 : : mutex_unlock(&codec->user_mutex);
540 : : if (cfg)
541 : : return cfg;
542 : : }
543 : : #endif
544 : 0 : pin = look_up_pincfg(codec, &codec->driver_pins, nid);
545 [ # # ]: 0 : if (pin)
546 : 0 : return pin->cfg;
547 : 0 : pin = look_up_pincfg(codec, &codec->init_pins, nid);
548 [ # # ]: 0 : if (pin)
549 : 0 : return pin->cfg;
550 : : return 0;
551 : : }
552 : : EXPORT_SYMBOL_GPL(snd_hda_codec_get_pincfg);
553 : :
554 : : /**
555 : : * snd_hda_codec_set_pin_target - remember the current pinctl target value
556 : : * @codec: the HDA codec
557 : : * @nid: pin NID
558 : : * @val: assigned pinctl value
559 : : *
560 : : * This function stores the given value to a pinctl target value in the
561 : : * pincfg table. This isn't always as same as the actually written value
562 : : * but can be referred at any time via snd_hda_codec_get_pin_target().
563 : : */
564 : 0 : int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
565 : : unsigned int val)
566 : : {
567 : 0 : struct hda_pincfg *pin;
568 : :
569 : 0 : pin = look_up_pincfg(codec, &codec->init_pins, nid);
570 [ # # # # ]: 0 : if (!pin)
571 : : return -EINVAL;
572 : 0 : pin->target = val;
573 : 0 : return 0;
574 : : }
575 : : EXPORT_SYMBOL_GPL(snd_hda_codec_set_pin_target);
576 : :
577 : : /**
578 : : * snd_hda_codec_get_pin_target - return the current pinctl target value
579 : : * @codec: the HDA codec
580 : : * @nid: pin NID
581 : : */
582 : 0 : int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
583 : : {
584 : 0 : struct hda_pincfg *pin;
585 : :
586 : 0 : pin = look_up_pincfg(codec, &codec->init_pins, nid);
587 [ # # ]: 0 : if (!pin)
588 : : return 0;
589 : 0 : return pin->target;
590 : : }
591 : : EXPORT_SYMBOL_GPL(snd_hda_codec_get_pin_target);
592 : :
593 : : /**
594 : : * snd_hda_shutup_pins - Shut up all pins
595 : : * @codec: the HDA codec
596 : : *
597 : : * Clear all pin controls to shup up before suspend for avoiding click noise.
598 : : * The controls aren't cached so that they can be resumed properly.
599 : : */
600 : 0 : void snd_hda_shutup_pins(struct hda_codec *codec)
601 : : {
602 : 0 : const struct hda_pincfg *pin;
603 : 0 : int i;
604 : :
605 : : /* don't shut up pins when unloading the driver; otherwise it breaks
606 : : * the default pin setup at the next load of the driver
607 : : */
608 [ # # ]: 0 : if (codec->bus->shutdown)
609 : : return;
610 [ # # ]: 0 : snd_array_for_each(&codec->init_pins, i, pin) {
611 : : /* use read here for syncing after issuing each verb */
612 : 0 : snd_hda_codec_read(codec, pin->nid, 0,
613 : : AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
614 : : }
615 : 0 : codec->pins_shutup = 1;
616 : : }
617 : : EXPORT_SYMBOL_GPL(snd_hda_shutup_pins);
618 : :
619 : : #ifdef CONFIG_PM
620 : : /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
621 : 0 : static void restore_shutup_pins(struct hda_codec *codec)
622 : : {
623 : 0 : const struct hda_pincfg *pin;
624 : 0 : int i;
625 : :
626 [ # # ]: 0 : if (!codec->pins_shutup)
627 : : return;
628 [ # # ]: 0 : if (codec->bus->shutdown)
629 : : return;
630 [ # # ]: 0 : snd_array_for_each(&codec->init_pins, i, pin) {
631 : 0 : snd_hda_codec_write(codec, pin->nid, 0,
632 : : AC_VERB_SET_PIN_WIDGET_CONTROL,
633 : 0 : pin->ctrl);
634 : : }
635 : 0 : codec->pins_shutup = 0;
636 : : }
637 : : #endif
638 : :
639 : 0 : static void hda_jackpoll_work(struct work_struct *work)
640 : : {
641 : 0 : struct hda_codec *codec =
642 : 0 : container_of(work, struct hda_codec, jackpoll_work.work);
643 : :
644 : 0 : snd_hda_jack_set_dirty_all(codec);
645 : 0 : snd_hda_jack_poll_all(codec);
646 : :
647 [ # # ]: 0 : if (!codec->jackpoll_interval)
648 : : return;
649 : :
650 : 0 : schedule_delayed_work(&codec->jackpoll_work,
651 : : codec->jackpoll_interval);
652 : : }
653 : :
654 : : /* release all pincfg lists */
655 : 0 : static void free_init_pincfgs(struct hda_codec *codec)
656 : : {
657 : 0 : snd_array_free(&codec->driver_pins);
658 : : #ifdef CONFIG_SND_HDA_RECONFIG
659 : : snd_array_free(&codec->user_pins);
660 : : #endif
661 : 0 : snd_array_free(&codec->init_pins);
662 : : }
663 : :
664 : : /*
665 : : * audio-converter setup caches
666 : : */
667 : : struct hda_cvt_setup {
668 : : hda_nid_t nid;
669 : : u8 stream_tag;
670 : : u8 channel_id;
671 : : u16 format_id;
672 : : unsigned char active; /* cvt is currently used */
673 : : unsigned char dirty; /* setups should be cleared */
674 : : };
675 : :
676 : : /* get or create a cache entry for the given audio converter NID */
677 : : static struct hda_cvt_setup *
678 : 0 : get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
679 : : {
680 : 0 : struct hda_cvt_setup *p;
681 : 0 : int i;
682 : :
683 [ # # ]: 0 : snd_array_for_each(&codec->cvt_setups, i, p) {
684 [ # # ]: 0 : if (p->nid == nid)
685 : 0 : return p;
686 : : }
687 : 0 : p = snd_array_new(&codec->cvt_setups);
688 [ # # ]: 0 : if (p)
689 : 0 : p->nid = nid;
690 : : return p;
691 : : }
692 : :
693 : : /*
694 : : * PCM device
695 : : */
696 : 0 : static void release_pcm(struct kref *kref)
697 : : {
698 : 0 : struct hda_pcm *pcm = container_of(kref, struct hda_pcm, kref);
699 : :
700 [ # # ]: 0 : if (pcm->pcm)
701 : 0 : snd_device_free(pcm->codec->card, pcm->pcm);
702 : 0 : clear_bit(pcm->device, pcm->codec->bus->pcm_dev_bits);
703 : 0 : kfree(pcm->name);
704 : 0 : kfree(pcm);
705 : 0 : }
706 : :
707 : 0 : void snd_hda_codec_pcm_put(struct hda_pcm *pcm)
708 : : {
709 : 0 : kref_put(&pcm->kref, release_pcm);
710 : 0 : }
711 : : EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_put);
712 : :
713 : 0 : struct hda_pcm *snd_hda_codec_pcm_new(struct hda_codec *codec,
714 : : const char *fmt, ...)
715 : : {
716 : 0 : struct hda_pcm *pcm;
717 : 0 : va_list args;
718 : :
719 : 0 : pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
720 [ # # ]: 0 : if (!pcm)
721 : : return NULL;
722 : :
723 : 0 : pcm->codec = codec;
724 : 0 : kref_init(&pcm->kref);
725 : 0 : va_start(args, fmt);
726 : 0 : pcm->name = kvasprintf(GFP_KERNEL, fmt, args);
727 : 0 : va_end(args);
728 [ # # ]: 0 : if (!pcm->name) {
729 : 0 : kfree(pcm);
730 : 0 : return NULL;
731 : : }
732 : :
733 : 0 : list_add_tail(&pcm->list, &codec->pcm_list_head);
734 : 0 : return pcm;
735 : : }
736 : : EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_new);
737 : :
738 : : /*
739 : : * codec destructor
740 : : */
741 : 0 : static void codec_release_pcms(struct hda_codec *codec)
742 : : {
743 : 0 : struct hda_pcm *pcm, *n;
744 : :
745 [ # # ]: 0 : list_for_each_entry_safe(pcm, n, &codec->pcm_list_head, list) {
746 [ # # ]: 0 : list_del_init(&pcm->list);
747 [ # # ]: 0 : if (pcm->pcm)
748 : 0 : snd_device_disconnect(codec->card, pcm->pcm);
749 : 0 : snd_hda_codec_pcm_put(pcm);
750 : : }
751 : 0 : }
752 : :
753 : 0 : void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec)
754 : : {
755 [ # # ]: 0 : if (codec->registered) {
756 : : /* pm_runtime_put() is called in snd_hdac_device_exit() */
757 : 0 : pm_runtime_get_noresume(hda_codec_dev(codec));
758 : 0 : pm_runtime_disable(hda_codec_dev(codec));
759 : 0 : codec->registered = 0;
760 : : }
761 : :
762 : 0 : cancel_delayed_work_sync(&codec->jackpoll_work);
763 [ # # ]: 0 : if (!codec->in_freeing)
764 : 0 : snd_hda_ctls_clear(codec);
765 : 0 : codec_release_pcms(codec);
766 : 0 : snd_hda_detach_beep_device(codec);
767 : 0 : memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
768 : 0 : snd_hda_jack_tbl_clear(codec);
769 : 0 : codec->proc_widget_hook = NULL;
770 : 0 : codec->spec = NULL;
771 : :
772 : : /* free only driver_pins so that init_pins + user_pins are restored */
773 : 0 : snd_array_free(&codec->driver_pins);
774 : 0 : snd_array_free(&codec->cvt_setups);
775 : 0 : snd_array_free(&codec->spdif_out);
776 : 0 : snd_array_free(&codec->verbs);
777 : 0 : codec->preset = NULL;
778 : 0 : codec->slave_dig_outs = NULL;
779 : 0 : codec->spdif_status_reset = 0;
780 : 0 : snd_array_free(&codec->mixers);
781 : 0 : snd_array_free(&codec->nids);
782 : 0 : remove_conn_list(codec);
783 : 0 : snd_hdac_regmap_exit(&codec->core);
784 : 0 : }
785 : :
786 : : static unsigned int hda_set_power_state(struct hda_codec *codec,
787 : : unsigned int power_state);
788 : :
789 : : /* enable/disable display power per codec */
790 : 0 : static void codec_display_power(struct hda_codec *codec, bool enable)
791 : : {
792 : 0 : if (codec->display_power_control)
793 : 0 : snd_hdac_display_power(&codec->bus->core, codec->addr, enable);
794 : : }
795 : :
796 : : /* also called from hda_bind.c */
797 : 0 : void snd_hda_codec_register(struct hda_codec *codec)
798 : : {
799 [ # # ]: 0 : if (codec->registered)
800 : : return;
801 [ # # ]: 0 : if (device_is_registered(hda_codec_dev(codec))) {
802 [ # # ]: 0 : codec_display_power(codec, true);
803 : 0 : pm_runtime_enable(hda_codec_dev(codec));
804 : : /* it was powered up in snd_hda_codec_new(), now all done */
805 : 0 : snd_hda_power_down(codec);
806 : 0 : codec->registered = 1;
807 : : }
808 : : }
809 : :
810 : 0 : static int snd_hda_codec_dev_register(struct snd_device *device)
811 : : {
812 : 0 : snd_hda_codec_register(device->device_data);
813 : 0 : return 0;
814 : : }
815 : :
816 : 0 : static int snd_hda_codec_dev_free(struct snd_device *device)
817 : : {
818 : 0 : struct hda_codec *codec = device->device_data;
819 : :
820 : 0 : codec->in_freeing = 1;
821 : : /*
822 : : * snd_hda_codec_device_new() is used by legacy HDA and ASoC driver.
823 : : * We can't unregister ASoC device since it will be unregistered in
824 : : * snd_hdac_ext_bus_device_remove().
825 : : */
826 [ # # ]: 0 : if (codec->core.type == HDA_DEV_LEGACY)
827 : 0 : snd_hdac_device_unregister(&codec->core);
828 [ # # ]: 0 : codec_display_power(codec, false);
829 : :
830 : : /*
831 : : * In the case of ASoC HD-audio bus, the device refcount is released in
832 : : * snd_hdac_ext_bus_device_remove() explicitly.
833 : : */
834 [ # # ]: 0 : if (codec->core.type == HDA_DEV_LEGACY)
835 : 0 : put_device(hda_codec_dev(codec));
836 : :
837 : 0 : return 0;
838 : : }
839 : :
840 : 0 : static void snd_hda_codec_dev_release(struct device *dev)
841 : : {
842 : 0 : struct hda_codec *codec = dev_to_hda_codec(dev);
843 : :
844 : 0 : free_init_pincfgs(codec);
845 : 0 : snd_hdac_device_exit(&codec->core);
846 : 0 : snd_hda_sysfs_clear(codec);
847 : 0 : kfree(codec->modelname);
848 : 0 : kfree(codec->wcaps);
849 : :
850 : : /*
851 : : * In the case of ASoC HD-audio, hda_codec is device managed.
852 : : * It will be freed when the ASoC device is removed.
853 : : */
854 [ # # ]: 0 : if (codec->core.type == HDA_DEV_LEGACY)
855 : 0 : kfree(codec);
856 : 0 : }
857 : :
858 : : #define DEV_NAME_LEN 31
859 : :
860 : : static int snd_hda_codec_device_init(struct hda_bus *bus, struct snd_card *card,
861 : : unsigned int codec_addr, struct hda_codec **codecp)
862 : : {
863 : : char name[DEV_NAME_LEN];
864 : : struct hda_codec *codec;
865 : : int err;
866 : :
867 : : dev_dbg(card->dev, "%s: entry\n", __func__);
868 : :
869 : : if (snd_BUG_ON(!bus))
870 : : return -EINVAL;
871 : : if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
872 : : return -EINVAL;
873 : :
874 : : codec = kzalloc(sizeof(*codec), GFP_KERNEL);
875 : : if (!codec)
876 : : return -ENOMEM;
877 : :
878 : : sprintf(name, "hdaudioC%dD%d", card->number, codec_addr);
879 : : err = snd_hdac_device_init(&codec->core, &bus->core, name, codec_addr);
880 : : if (err < 0) {
881 : : kfree(codec);
882 : : return err;
883 : : }
884 : :
885 : : codec->core.type = HDA_DEV_LEGACY;
886 : : *codecp = codec;
887 : :
888 : : return err;
889 : : }
890 : :
891 : : /**
892 : : * snd_hda_codec_new - create a HDA codec
893 : : * @bus: the bus to assign
894 : : * @card: card for this codec
895 : : * @codec_addr: the codec address
896 : : * @codecp: the pointer to store the generated codec
897 : : *
898 : : * Returns 0 if successful, or a negative error code.
899 : : */
900 : 0 : int snd_hda_codec_new(struct hda_bus *bus, struct snd_card *card,
901 : : unsigned int codec_addr, struct hda_codec **codecp)
902 : : {
903 : 0 : int ret;
904 : :
905 : 0 : ret = snd_hda_codec_device_init(bus, card, codec_addr, codecp);
906 [ # # ]: 0 : if (ret < 0)
907 : : return ret;
908 : :
909 : 0 : return snd_hda_codec_device_new(bus, card, codec_addr, *codecp);
910 : : }
911 : : EXPORT_SYMBOL_GPL(snd_hda_codec_new);
912 : :
913 : 0 : int snd_hda_codec_device_new(struct hda_bus *bus, struct snd_card *card,
914 : : unsigned int codec_addr, struct hda_codec *codec)
915 : : {
916 : 0 : char component[31];
917 : 0 : hda_nid_t fg;
918 : 0 : int err;
919 : 0 : static const struct snd_device_ops dev_ops = {
920 : : .dev_register = snd_hda_codec_dev_register,
921 : : .dev_free = snd_hda_codec_dev_free,
922 : : };
923 : :
924 : 0 : dev_dbg(card->dev, "%s: entry\n", __func__);
925 : :
926 [ # # ]: 0 : if (snd_BUG_ON(!bus))
927 : : return -EINVAL;
928 [ # # ]: 0 : if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
929 : : return -EINVAL;
930 : :
931 : 0 : codec->core.dev.release = snd_hda_codec_dev_release;
932 : 0 : codec->core.exec_verb = codec_exec_verb;
933 : :
934 : 0 : codec->bus = bus;
935 : 0 : codec->card = card;
936 : 0 : codec->addr = codec_addr;
937 : 0 : mutex_init(&codec->spdif_mutex);
938 : 0 : mutex_init(&codec->control_mutex);
939 : 0 : snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
940 : 0 : snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
941 : 0 : snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
942 : 0 : snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
943 : 0 : snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
944 : 0 : snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
945 : 0 : snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
946 : 0 : snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
947 : 0 : INIT_LIST_HEAD(&codec->conn_list);
948 : 0 : INIT_LIST_HEAD(&codec->pcm_list_head);
949 : :
950 : 0 : INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
951 : 0 : codec->depop_delay = -1;
952 : 0 : codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
953 : :
954 : : #ifdef CONFIG_PM
955 : 0 : codec->power_jiffies = jiffies;
956 : : #endif
957 : :
958 : 0 : snd_hda_sysfs_init(codec);
959 : :
960 [ # # ]: 0 : if (codec->bus->modelname) {
961 : 0 : codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
962 [ # # ]: 0 : if (!codec->modelname) {
963 : 0 : err = -ENOMEM;
964 : 0 : goto error;
965 : : }
966 : : }
967 : :
968 [ # # ]: 0 : fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
969 : 0 : err = read_widget_caps(codec, fg);
970 [ # # ]: 0 : if (err < 0)
971 : 0 : goto error;
972 : 0 : err = read_pin_defaults(codec);
973 [ # # ]: 0 : if (err < 0)
974 : 0 : goto error;
975 : :
976 : : /* power-up all before initialization */
977 : 0 : hda_set_power_state(codec, AC_PWRST_D0);
978 : 0 : codec->core.dev.power.power_state = PMSG_ON;
979 : :
980 : 0 : snd_hda_codec_proc_new(codec);
981 : :
982 : 0 : snd_hda_create_hwdep(codec);
983 : :
984 : 0 : sprintf(component, "HDA:%08x,%08x,%08x", codec->core.vendor_id,
985 : : codec->core.subsystem_id, codec->core.revision_id);
986 : 0 : snd_component_add(card, component);
987 : :
988 : 0 : err = snd_device_new(card, SNDRV_DEV_CODEC, codec, &dev_ops);
989 [ # # ]: 0 : if (err < 0)
990 : 0 : goto error;
991 : :
992 : : return 0;
993 : :
994 : 0 : error:
995 : 0 : put_device(hda_codec_dev(codec));
996 : 0 : return err;
997 : : }
998 : : EXPORT_SYMBOL_GPL(snd_hda_codec_device_new);
999 : :
1000 : : /**
1001 : : * snd_hda_codec_update_widgets - Refresh widget caps and pin defaults
1002 : : * @codec: the HDA codec
1003 : : *
1004 : : * Forcibly refresh the all widget caps and the init pin configurations of
1005 : : * the given codec.
1006 : : */
1007 : 0 : int snd_hda_codec_update_widgets(struct hda_codec *codec)
1008 : : {
1009 : 0 : hda_nid_t fg;
1010 : 0 : int err;
1011 : :
1012 : 0 : err = snd_hdac_refresh_widgets(&codec->core);
1013 [ # # ]: 0 : if (err < 0)
1014 : : return err;
1015 : :
1016 : : /* Assume the function group node does not change,
1017 : : * only the widget nodes may change.
1018 : : */
1019 : 0 : kfree(codec->wcaps);
1020 [ # # ]: 0 : fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
1021 : 0 : err = read_widget_caps(codec, fg);
1022 [ # # ]: 0 : if (err < 0)
1023 : : return err;
1024 : :
1025 : 0 : snd_array_free(&codec->init_pins);
1026 : 0 : err = read_pin_defaults(codec);
1027 : :
1028 : 0 : return err;
1029 : : }
1030 : : EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets);
1031 : :
1032 : : /* update the stream-id if changed */
1033 : 0 : static void update_pcm_stream_id(struct hda_codec *codec,
1034 : : struct hda_cvt_setup *p, hda_nid_t nid,
1035 : : u32 stream_tag, int channel_id)
1036 : : {
1037 : 0 : unsigned int oldval, newval;
1038 : :
1039 [ # # # # ]: 0 : if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1040 : 0 : oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1041 : 0 : newval = (stream_tag << 4) | channel_id;
1042 [ # # ]: 0 : if (oldval != newval)
1043 : 0 : snd_hda_codec_write(codec, nid, 0,
1044 : : AC_VERB_SET_CHANNEL_STREAMID,
1045 : : newval);
1046 : 0 : p->stream_tag = stream_tag;
1047 : 0 : p->channel_id = channel_id;
1048 : : }
1049 : 0 : }
1050 : :
1051 : : /* update the format-id if changed */
1052 : 0 : static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1053 : : hda_nid_t nid, int format)
1054 : : {
1055 : 0 : unsigned int oldval;
1056 : :
1057 [ # # ]: 0 : if (p->format_id != format) {
1058 : 0 : oldval = snd_hda_codec_read(codec, nid, 0,
1059 : : AC_VERB_GET_STREAM_FORMAT, 0);
1060 [ # # ]: 0 : if (oldval != format) {
1061 : 0 : msleep(1);
1062 : 0 : snd_hda_codec_write(codec, nid, 0,
1063 : : AC_VERB_SET_STREAM_FORMAT,
1064 : : format);
1065 : : }
1066 : 0 : p->format_id = format;
1067 : : }
1068 : 0 : }
1069 : :
1070 : : /**
1071 : : * snd_hda_codec_setup_stream - set up the codec for streaming
1072 : : * @codec: the CODEC to set up
1073 : : * @nid: the NID to set up
1074 : : * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1075 : : * @channel_id: channel id to pass, zero based.
1076 : : * @format: stream format.
1077 : : */
1078 : 0 : void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1079 : : u32 stream_tag,
1080 : : int channel_id, int format)
1081 : : {
1082 : 0 : struct hda_codec *c;
1083 : 0 : struct hda_cvt_setup *p;
1084 : 0 : int type;
1085 : 0 : int i;
1086 : :
1087 [ # # ]: 0 : if (!nid)
1088 : : return;
1089 : :
1090 : 0 : codec_dbg(codec,
1091 : : "hda_codec_setup_stream: NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1092 : : nid, stream_tag, channel_id, format);
1093 : 0 : p = get_hda_cvt_setup(codec, nid);
1094 [ # # ]: 0 : if (!p)
1095 : : return;
1096 : :
1097 [ # # ]: 0 : if (codec->patch_ops.stream_pm)
1098 : 0 : codec->patch_ops.stream_pm(codec, nid, true);
1099 [ # # ]: 0 : if (codec->pcm_format_first)
1100 : 0 : update_pcm_format(codec, p, nid, format);
1101 : 0 : update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1102 [ # # ]: 0 : if (!codec->pcm_format_first)
1103 : 0 : update_pcm_format(codec, p, nid, format);
1104 : :
1105 : 0 : p->active = 1;
1106 : 0 : p->dirty = 0;
1107 : :
1108 : : /* make other inactive cvts with the same stream-tag dirty */
1109 [ # # ]: 0 : type = get_wcaps_type(get_wcaps(codec, nid));
1110 [ # # ]: 0 : list_for_each_codec(c, codec->bus) {
1111 [ # # ]: 0 : snd_array_for_each(&c->cvt_setups, i, p) {
1112 [ # # # # : 0 : if (!p->active && p->stream_tag == stream_tag &&
# # ]
1113 [ # # ]: 0 : get_wcaps_type(get_wcaps(c, p->nid)) == type)
1114 : 0 : p->dirty = 1;
1115 : : }
1116 : : }
1117 : : }
1118 : : EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream);
1119 : :
1120 : : static void really_cleanup_stream(struct hda_codec *codec,
1121 : : struct hda_cvt_setup *q);
1122 : :
1123 : : /**
1124 : : * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1125 : : * @codec: the CODEC to clean up
1126 : : * @nid: the NID to clean up
1127 : : * @do_now: really clean up the stream instead of clearing the active flag
1128 : : */
1129 : 0 : void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1130 : : int do_now)
1131 : : {
1132 : 0 : struct hda_cvt_setup *p;
1133 : :
1134 [ # # ]: 0 : if (!nid)
1135 : : return;
1136 : :
1137 [ # # ]: 0 : if (codec->no_sticky_stream)
1138 : 0 : do_now = 1;
1139 : :
1140 : 0 : codec_dbg(codec, "hda_codec_cleanup_stream: NID=0x%x\n", nid);
1141 : 0 : p = get_hda_cvt_setup(codec, nid);
1142 [ # # ]: 0 : if (p) {
1143 : : /* here we just clear the active flag when do_now isn't set;
1144 : : * actual clean-ups will be done later in
1145 : : * purify_inactive_streams() called from snd_hda_codec_prpapre()
1146 : : */
1147 [ # # ]: 0 : if (do_now)
1148 : 0 : really_cleanup_stream(codec, p);
1149 : : else
1150 : 0 : p->active = 0;
1151 : : }
1152 : : }
1153 : : EXPORT_SYMBOL_GPL(__snd_hda_codec_cleanup_stream);
1154 : :
1155 : 0 : static void really_cleanup_stream(struct hda_codec *codec,
1156 : : struct hda_cvt_setup *q)
1157 : : {
1158 : 0 : hda_nid_t nid = q->nid;
1159 [ # # ]: 0 : if (q->stream_tag || q->channel_id)
1160 : 0 : snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1161 [ # # ]: 0 : if (q->format_id)
1162 : 0 : snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1163 : : );
1164 : 0 : memset(q, 0, sizeof(*q));
1165 : 0 : q->nid = nid;
1166 [ # # ]: 0 : if (codec->patch_ops.stream_pm)
1167 : 0 : codec->patch_ops.stream_pm(codec, nid, false);
1168 : 0 : }
1169 : :
1170 : : /* clean up the all conflicting obsolete streams */
1171 : : static void purify_inactive_streams(struct hda_codec *codec)
1172 : : {
1173 : : struct hda_codec *c;
1174 : : struct hda_cvt_setup *p;
1175 : : int i;
1176 : :
1177 : : list_for_each_codec(c, codec->bus) {
1178 : : snd_array_for_each(&c->cvt_setups, i, p) {
1179 : : if (p->dirty)
1180 : : really_cleanup_stream(c, p);
1181 : : }
1182 : : }
1183 : : }
1184 : :
1185 : : #ifdef CONFIG_PM
1186 : : /* clean up all streams; called from suspend */
1187 : 0 : static void hda_cleanup_all_streams(struct hda_codec *codec)
1188 : : {
1189 : 0 : struct hda_cvt_setup *p;
1190 : 0 : int i;
1191 : :
1192 [ # # ]: 0 : snd_array_for_each(&codec->cvt_setups, i, p) {
1193 [ # # ]: 0 : if (p->stream_tag)
1194 : 0 : really_cleanup_stream(codec, p);
1195 : : }
1196 : 0 : }
1197 : : #endif
1198 : :
1199 : : /*
1200 : : * amp access functions
1201 : : */
1202 : :
1203 : : /**
1204 : : * query_amp_caps - query AMP capabilities
1205 : : * @codec: the HD-auio codec
1206 : : * @nid: the NID to query
1207 : : * @direction: either #HDA_INPUT or #HDA_OUTPUT
1208 : : *
1209 : : * Query AMP capabilities for the given widget and direction.
1210 : : * Returns the obtained capability bits.
1211 : : *
1212 : : * When cap bits have been already read, this doesn't read again but
1213 : : * returns the cached value.
1214 : : */
1215 : 0 : u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1216 : : {
1217 [ # # # # ]: 0 : if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1218 : 0 : nid = codec->core.afg;
1219 [ # # ]: 0 : return snd_hda_param_read(codec, nid,
1220 : : direction == HDA_OUTPUT ?
1221 : : AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1222 : : }
1223 : : EXPORT_SYMBOL_GPL(query_amp_caps);
1224 : :
1225 : : /**
1226 : : * snd_hda_check_amp_caps - query AMP capabilities
1227 : : * @codec: the HD-audio codec
1228 : : * @nid: the NID to query
1229 : : * @dir: either #HDA_INPUT or #HDA_OUTPUT
1230 : : * @bits: bit mask to check the result
1231 : : *
1232 : : * Check whether the widget has the given amp capability for the direction.
1233 : : */
1234 : 0 : bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
1235 : : int dir, unsigned int bits)
1236 : : {
1237 [ # # ]: 0 : if (!nid)
1238 : : return false;
1239 [ # # # # ]: 0 : if (get_wcaps(codec, nid) & (1 << (dir + 1)))
1240 [ # # ]: 0 : if (query_amp_caps(codec, nid, dir) & bits)
1241 : 0 : return true;
1242 : : return false;
1243 : : }
1244 : : EXPORT_SYMBOL_GPL(snd_hda_check_amp_caps);
1245 : :
1246 : : /**
1247 : : * snd_hda_override_amp_caps - Override the AMP capabilities
1248 : : * @codec: the CODEC to clean up
1249 : : * @nid: the NID to clean up
1250 : : * @dir: either #HDA_INPUT or #HDA_OUTPUT
1251 : : * @caps: the capability bits to set
1252 : : *
1253 : : * Override the cached AMP caps bits value by the given one.
1254 : : * This function is useful if the driver needs to adjust the AMP ranges,
1255 : : * e.g. limit to 0dB, etc.
1256 : : *
1257 : : * Returns zero if successful or a negative error code.
1258 : : */
1259 : 0 : int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1260 : : unsigned int caps)
1261 : : {
1262 : 0 : unsigned int parm;
1263 : :
1264 [ # # ]: 0 : snd_hda_override_wcaps(codec, nid,
1265 [ # # ]: 0 : get_wcaps(codec, nid) | AC_WCAP_AMP_OVRD);
1266 [ # # ]: 0 : parm = dir == HDA_OUTPUT ? AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP;
1267 : 0 : return snd_hdac_override_parm(&codec->core, nid, parm, caps);
1268 : : }
1269 : : EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
1270 : :
1271 : 0 : static unsigned int encode_amp(struct hda_codec *codec, hda_nid_t nid,
1272 : : int ch, int dir, int idx)
1273 : : {
1274 [ # # # # ]: 0 : unsigned int cmd = snd_hdac_regmap_encode_amp(nid, ch, dir, idx);
1275 : :
1276 : : /* enable fake mute if no h/w mute but min=mute */
1277 [ # # ]: 0 : if ((query_amp_caps(codec, nid, dir) &
1278 : : (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) == AC_AMPCAP_MIN_MUTE)
1279 : 0 : cmd |= AC_AMP_FAKE_MUTE;
1280 : 0 : return cmd;
1281 : : }
1282 : :
1283 : : /**
1284 : : * snd_hda_codec_amp_update - update the AMP mono value
1285 : : * @codec: HD-audio codec
1286 : : * @nid: NID to read the AMP value
1287 : : * @ch: channel to update (0 or 1)
1288 : : * @dir: #HDA_INPUT or #HDA_OUTPUT
1289 : : * @idx: the index value (only for input direction)
1290 : : * @mask: bit mask to set
1291 : : * @val: the bits value to set
1292 : : *
1293 : : * Update the AMP values for the given channel, direction and index.
1294 : : */
1295 : 0 : int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid,
1296 : : int ch, int dir, int idx, int mask, int val)
1297 : : {
1298 : 0 : unsigned int cmd = encode_amp(codec, nid, ch, dir, idx);
1299 : :
1300 : 0 : return snd_hdac_regmap_update_raw(&codec->core, cmd, mask, val);
1301 : : }
1302 : : EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update);
1303 : :
1304 : : /**
1305 : : * snd_hda_codec_amp_stereo - update the AMP stereo values
1306 : : * @codec: HD-audio codec
1307 : : * @nid: NID to read the AMP value
1308 : : * @direction: #HDA_INPUT or #HDA_OUTPUT
1309 : : * @idx: the index value (only for input direction)
1310 : : * @mask: bit mask to set
1311 : : * @val: the bits value to set
1312 : : *
1313 : : * Update the AMP values like snd_hda_codec_amp_update(), but for a
1314 : : * stereo widget with the same mask and value.
1315 : : */
1316 : 0 : int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1317 : : int direction, int idx, int mask, int val)
1318 : : {
1319 : 0 : int ch, ret = 0;
1320 : :
1321 [ # # ]: 0 : if (snd_BUG_ON(mask & ~0xff))
1322 : 0 : mask &= 0xff;
1323 [ # # ]: 0 : for (ch = 0; ch < 2; ch++)
1324 : 0 : ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1325 : : idx, mask, val);
1326 : 0 : return ret;
1327 : : }
1328 : : EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
1329 : :
1330 : : /**
1331 : : * snd_hda_codec_amp_init - initialize the AMP value
1332 : : * @codec: the HDA codec
1333 : : * @nid: NID to read the AMP value
1334 : : * @ch: channel (left=0 or right=1)
1335 : : * @dir: #HDA_INPUT or #HDA_OUTPUT
1336 : : * @idx: the index value (only for input direction)
1337 : : * @mask: bit mask to set
1338 : : * @val: the bits value to set
1339 : : *
1340 : : * Works like snd_hda_codec_amp_update() but it writes the value only at
1341 : : * the first access. If the amp was already initialized / updated beforehand,
1342 : : * this does nothing.
1343 : : */
1344 : 0 : int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
1345 : : int dir, int idx, int mask, int val)
1346 : : {
1347 : 0 : unsigned int cmd = encode_amp(codec, nid, ch, dir, idx);
1348 : :
1349 [ # # ]: 0 : if (!codec->core.regmap)
1350 : : return -EINVAL;
1351 : 0 : return snd_hdac_regmap_update_raw_once(&codec->core, cmd, mask, val);
1352 : : }
1353 : : EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init);
1354 : :
1355 : : /**
1356 : : * snd_hda_codec_amp_init_stereo - initialize the stereo AMP value
1357 : : * @codec: the HDA codec
1358 : : * @nid: NID to read the AMP value
1359 : : * @dir: #HDA_INPUT or #HDA_OUTPUT
1360 : : * @idx: the index value (only for input direction)
1361 : : * @mask: bit mask to set
1362 : : * @val: the bits value to set
1363 : : *
1364 : : * Call snd_hda_codec_amp_init() for both stereo channels.
1365 : : */
1366 : 0 : int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
1367 : : int dir, int idx, int mask, int val)
1368 : : {
1369 : 0 : int ch, ret = 0;
1370 : :
1371 [ # # ]: 0 : if (snd_BUG_ON(mask & ~0xff))
1372 : 0 : mask &= 0xff;
1373 [ # # ]: 0 : for (ch = 0; ch < 2; ch++)
1374 : 0 : ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
1375 : : idx, mask, val);
1376 : 0 : return ret;
1377 : : }
1378 : : EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo);
1379 : :
1380 : 0 : static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1381 : : unsigned int ofs)
1382 : : {
1383 : 0 : u32 caps = query_amp_caps(codec, nid, dir);
1384 : : /* get num steps */
1385 : 0 : caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1386 [ # # ]: 0 : if (ofs < caps)
1387 : 0 : caps -= ofs;
1388 : 0 : return caps;
1389 : : }
1390 : :
1391 : : /**
1392 : : * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1393 : : * @kcontrol: referred ctl element
1394 : : * @uinfo: pointer to get/store the data
1395 : : *
1396 : : * The control element is supposed to have the private_value field
1397 : : * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1398 : : */
1399 : 0 : int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1400 : : struct snd_ctl_elem_info *uinfo)
1401 : : {
1402 : 0 : struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1403 : 0 : u16 nid = get_amp_nid(kcontrol);
1404 : 0 : u8 chs = get_amp_channels(kcontrol);
1405 : 0 : int dir = get_amp_direction(kcontrol);
1406 : 0 : unsigned int ofs = get_amp_offset(kcontrol);
1407 : :
1408 : 0 : uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1409 [ # # ]: 0 : uinfo->count = chs == 3 ? 2 : 1;
1410 : 0 : uinfo->value.integer.min = 0;
1411 : 0 : uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1412 [ # # ]: 0 : if (!uinfo->value.integer.max) {
1413 : 0 : codec_warn(codec,
1414 : : "num_steps = 0 for NID=0x%x (ctl = %s)\n",
1415 : : nid, kcontrol->id.name);
1416 : 0 : return -EINVAL;
1417 : : }
1418 : : return 0;
1419 : : }
1420 : : EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
1421 : :
1422 : :
1423 : : static inline unsigned int
1424 : 0 : read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1425 : : int ch, int dir, int idx, unsigned int ofs)
1426 : : {
1427 : 0 : unsigned int val;
1428 : 0 : val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1429 : 0 : val &= HDA_AMP_VOLMASK;
1430 [ # # # # ]: 0 : if (val >= ofs)
1431 : 0 : val -= ofs;
1432 : : else
1433 : : val = 0;
1434 : 0 : return val;
1435 : : }
1436 : :
1437 : : static inline int
1438 : 0 : update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1439 : : int ch, int dir, int idx, unsigned int ofs,
1440 : : unsigned int val)
1441 : : {
1442 : 0 : unsigned int maxval;
1443 : :
1444 [ # # ]: 0 : if (val > 0)
1445 : 0 : val += ofs;
1446 : : /* ofs = 0: raw max value */
1447 : 0 : maxval = get_amp_max_value(codec, nid, dir, 0);
1448 : 0 : if (val > maxval)
1449 : : val = maxval;
1450 : 0 : return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1451 : : HDA_AMP_VOLMASK, val);
1452 : : }
1453 : :
1454 : : /**
1455 : : * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1456 : : * @kcontrol: ctl element
1457 : : * @ucontrol: pointer to get/store the data
1458 : : *
1459 : : * The control element is supposed to have the private_value field
1460 : : * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1461 : : */
1462 : 0 : int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1463 : : struct snd_ctl_elem_value *ucontrol)
1464 : : {
1465 : 0 : struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1466 : 0 : hda_nid_t nid = get_amp_nid(kcontrol);
1467 : 0 : int chs = get_amp_channels(kcontrol);
1468 : 0 : int dir = get_amp_direction(kcontrol);
1469 : 0 : int idx = get_amp_index(kcontrol);
1470 : 0 : unsigned int ofs = get_amp_offset(kcontrol);
1471 : 0 : long *valp = ucontrol->value.integer.value;
1472 : :
1473 [ # # ]: 0 : if (chs & 1)
1474 : 0 : *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1475 [ # # ]: 0 : if (chs & 2)
1476 : 0 : *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1477 : 0 : return 0;
1478 : : }
1479 : : EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
1480 : :
1481 : : /**
1482 : : * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1483 : : * @kcontrol: ctl element
1484 : : * @ucontrol: pointer to get/store the data
1485 : : *
1486 : : * The control element is supposed to have the private_value field
1487 : : * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1488 : : */
1489 : 0 : int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1490 : : struct snd_ctl_elem_value *ucontrol)
1491 : : {
1492 : 0 : struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1493 : 0 : hda_nid_t nid = get_amp_nid(kcontrol);
1494 : 0 : int chs = get_amp_channels(kcontrol);
1495 : 0 : int dir = get_amp_direction(kcontrol);
1496 : 0 : int idx = get_amp_index(kcontrol);
1497 : 0 : unsigned int ofs = get_amp_offset(kcontrol);
1498 : 0 : long *valp = ucontrol->value.integer.value;
1499 : 0 : int change = 0;
1500 : :
1501 [ # # ]: 0 : if (chs & 1) {
1502 : 0 : change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1503 : 0 : valp++;
1504 : : }
1505 [ # # ]: 0 : if (chs & 2)
1506 : 0 : change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1507 : 0 : return change;
1508 : : }
1509 : : EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
1510 : :
1511 : : /* inquiry the amp caps and convert to TLV */
1512 : : static void get_ctl_amp_tlv(struct snd_kcontrol *kcontrol, unsigned int *tlv)
1513 : : {
1514 : : struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1515 : : hda_nid_t nid = get_amp_nid(kcontrol);
1516 : : int dir = get_amp_direction(kcontrol);
1517 : : unsigned int ofs = get_amp_offset(kcontrol);
1518 : : bool min_mute = get_amp_min_mute(kcontrol);
1519 : : u32 caps, val1, val2;
1520 : :
1521 : : caps = query_amp_caps(codec, nid, dir);
1522 : : val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1523 : : val2 = (val2 + 1) * 25;
1524 : : val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1525 : : val1 += ofs;
1526 : : val1 = ((int)val1) * ((int)val2);
1527 : : if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
1528 : : val2 |= TLV_DB_SCALE_MUTE;
1529 : : tlv[SNDRV_CTL_TLVO_TYPE] = SNDRV_CTL_TLVT_DB_SCALE;
1530 : : tlv[SNDRV_CTL_TLVO_LEN] = 2 * sizeof(unsigned int);
1531 : : tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN] = val1;
1532 : : tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] = val2;
1533 : : }
1534 : :
1535 : : /**
1536 : : * snd_hda_mixer_amp_tlv - TLV callback for a standard AMP mixer volume
1537 : : * @kcontrol: ctl element
1538 : : * @op_flag: operation flag
1539 : : * @size: byte size of input TLV
1540 : : * @_tlv: TLV data
1541 : : *
1542 : : * The control element is supposed to have the private_value field
1543 : : * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1544 : : */
1545 : 0 : int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1546 : : unsigned int size, unsigned int __user *_tlv)
1547 : : {
1548 : 0 : unsigned int tlv[4];
1549 : :
1550 [ # # ]: 0 : if (size < 4 * sizeof(unsigned int))
1551 : : return -ENOMEM;
1552 : 0 : get_ctl_amp_tlv(kcontrol, tlv);
1553 [ # # ]: 0 : if (copy_to_user(_tlv, tlv, sizeof(tlv)))
1554 : 0 : return -EFAULT;
1555 : : return 0;
1556 : : }
1557 : : EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
1558 : :
1559 : : /**
1560 : : * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1561 : : * @codec: HD-audio codec
1562 : : * @nid: NID of a reference widget
1563 : : * @dir: #HDA_INPUT or #HDA_OUTPUT
1564 : : * @tlv: TLV data to be stored, at least 4 elements
1565 : : *
1566 : : * Set (static) TLV data for a virtual master volume using the AMP caps
1567 : : * obtained from the reference NID.
1568 : : * The volume range is recalculated as if the max volume is 0dB.
1569 : : */
1570 : 0 : void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1571 : : unsigned int *tlv)
1572 : : {
1573 : 0 : u32 caps;
1574 : 0 : int nums, step;
1575 : :
1576 : 0 : caps = query_amp_caps(codec, nid, dir);
1577 : 0 : nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1578 : 0 : step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1579 : 0 : step = (step + 1) * 25;
1580 : 0 : tlv[SNDRV_CTL_TLVO_TYPE] = SNDRV_CTL_TLVT_DB_SCALE;
1581 : 0 : tlv[SNDRV_CTL_TLVO_LEN] = 2 * sizeof(unsigned int);
1582 : 0 : tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN] = -nums * step;
1583 : 0 : tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] = step;
1584 : 0 : }
1585 : : EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
1586 : :
1587 : : /* find a mixer control element with the given name */
1588 : : static struct snd_kcontrol *
1589 : : find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
1590 : : {
1591 : : struct snd_ctl_elem_id id;
1592 : : memset(&id, 0, sizeof(id));
1593 : : id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1594 : : id.device = dev;
1595 : : id.index = idx;
1596 : : if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1597 : : return NULL;
1598 : : strcpy(id.name, name);
1599 : : return snd_ctl_find_id(codec->card, &id);
1600 : : }
1601 : :
1602 : : /**
1603 : : * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1604 : : * @codec: HD-audio codec
1605 : : * @name: ctl id name string
1606 : : *
1607 : : * Get the control element with the given id string and IFACE_MIXER.
1608 : : */
1609 : 0 : struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1610 : : const char *name)
1611 : : {
1612 : 0 : return find_mixer_ctl(codec, name, 0, 0);
1613 : : }
1614 : : EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
1615 : :
1616 : 0 : static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
1617 : : int start_idx)
1618 : : {
1619 : 0 : int i, idx;
1620 : : /* 16 ctlrs should be large enough */
1621 [ # # # # : 0 : for (i = 0, idx = start_idx; i < 16; i++, idx++) {
# # ]
1622 [ # # # # : 0 : if (!find_mixer_ctl(codec, name, 0, idx))
# # ]
1623 : : return idx;
1624 : : }
1625 : : return -EBUSY;
1626 : : }
1627 : :
1628 : : /**
1629 : : * snd_hda_ctl_add - Add a control element and assign to the codec
1630 : : * @codec: HD-audio codec
1631 : : * @nid: corresponding NID (optional)
1632 : : * @kctl: the control element to assign
1633 : : *
1634 : : * Add the given control element to an array inside the codec instance.
1635 : : * All control elements belonging to a codec are supposed to be added
1636 : : * by this function so that a proper clean-up works at the free or
1637 : : * reconfiguration time.
1638 : : *
1639 : : * If non-zero @nid is passed, the NID is assigned to the control element.
1640 : : * The assignment is shown in the codec proc file.
1641 : : *
1642 : : * snd_hda_ctl_add() checks the control subdev id field whether
1643 : : * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
1644 : : * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
1645 : : * specifies if kctl->private_value is a HDA amplifier value.
1646 : : */
1647 : 0 : int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
1648 : : struct snd_kcontrol *kctl)
1649 : : {
1650 : 0 : int err;
1651 : 0 : unsigned short flags = 0;
1652 : 0 : struct hda_nid_item *item;
1653 : :
1654 [ # # ]: 0 : if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
1655 : 0 : flags |= HDA_NID_ITEM_AMP;
1656 [ # # ]: 0 : if (nid == 0)
1657 : 0 : nid = get_amp_nid_(kctl->private_value);
1658 : : }
1659 [ # # # # ]: 0 : if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
1660 : 0 : nid = kctl->id.subdevice & 0xffff;
1661 [ # # ]: 0 : if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
1662 : 0 : kctl->id.subdevice = 0;
1663 : 0 : err = snd_ctl_add(codec->card, kctl);
1664 [ # # ]: 0 : if (err < 0)
1665 : : return err;
1666 : 0 : item = snd_array_new(&codec->mixers);
1667 [ # # ]: 0 : if (!item)
1668 : : return -ENOMEM;
1669 : 0 : item->kctl = kctl;
1670 : 0 : item->nid = nid;
1671 : 0 : item->flags = flags;
1672 : 0 : return 0;
1673 : : }
1674 : : EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
1675 : :
1676 : : /**
1677 : : * snd_hda_add_nid - Assign a NID to a control element
1678 : : * @codec: HD-audio codec
1679 : : * @nid: corresponding NID (optional)
1680 : : * @kctl: the control element to assign
1681 : : * @index: index to kctl
1682 : : *
1683 : : * Add the given control element to an array inside the codec instance.
1684 : : * This function is used when #snd_hda_ctl_add cannot be used for 1:1
1685 : : * NID:KCTL mapping - for example "Capture Source" selector.
1686 : : */
1687 : 0 : int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
1688 : : unsigned int index, hda_nid_t nid)
1689 : : {
1690 : 0 : struct hda_nid_item *item;
1691 : :
1692 [ # # ]: 0 : if (nid > 0) {
1693 : 0 : item = snd_array_new(&codec->nids);
1694 [ # # ]: 0 : if (!item)
1695 : : return -ENOMEM;
1696 : 0 : item->kctl = kctl;
1697 : 0 : item->index = index;
1698 : 0 : item->nid = nid;
1699 : 0 : return 0;
1700 : : }
1701 : 0 : codec_err(codec, "no NID for mapping control %s:%d:%d\n",
1702 : : kctl->id.name, kctl->id.index, index);
1703 : 0 : return -EINVAL;
1704 : : }
1705 : : EXPORT_SYMBOL_GPL(snd_hda_add_nid);
1706 : :
1707 : : /**
1708 : : * snd_hda_ctls_clear - Clear all controls assigned to the given codec
1709 : : * @codec: HD-audio codec
1710 : : */
1711 : 0 : void snd_hda_ctls_clear(struct hda_codec *codec)
1712 : : {
1713 : 0 : int i;
1714 : 0 : struct hda_nid_item *items = codec->mixers.list;
1715 [ # # ]: 0 : for (i = 0; i < codec->mixers.used; i++)
1716 : 0 : snd_ctl_remove(codec->card, items[i].kctl);
1717 : 0 : snd_array_free(&codec->mixers);
1718 : 0 : snd_array_free(&codec->nids);
1719 : 0 : }
1720 : :
1721 : : /**
1722 : : * snd_hda_lock_devices - pseudo device locking
1723 : : * @bus: the BUS
1724 : : *
1725 : : * toggle card->shutdown to allow/disallow the device access (as a hack)
1726 : : */
1727 : 0 : int snd_hda_lock_devices(struct hda_bus *bus)
1728 : : {
1729 : 0 : struct snd_card *card = bus->card;
1730 : 0 : struct hda_codec *codec;
1731 : :
1732 : 0 : spin_lock(&card->files_lock);
1733 [ # # ]: 0 : if (card->shutdown)
1734 : 0 : goto err_unlock;
1735 : 0 : card->shutdown = 1;
1736 [ # # ]: 0 : if (!list_empty(&card->ctl_files))
1737 : 0 : goto err_clear;
1738 : :
1739 [ # # ]: 0 : list_for_each_codec(codec, bus) {
1740 : 0 : struct hda_pcm *cpcm;
1741 [ # # ]: 0 : list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
1742 [ # # ]: 0 : if (!cpcm->pcm)
1743 : 0 : continue;
1744 [ # # ]: 0 : if (cpcm->pcm->streams[0].substream_opened ||
1745 [ # # ]: 0 : cpcm->pcm->streams[1].substream_opened)
1746 : 0 : goto err_clear;
1747 : : }
1748 : : }
1749 : 0 : spin_unlock(&card->files_lock);
1750 : 0 : return 0;
1751 : :
1752 : 0 : err_clear:
1753 : 0 : card->shutdown = 0;
1754 : 0 : err_unlock:
1755 : 0 : spin_unlock(&card->files_lock);
1756 : 0 : return -EINVAL;
1757 : : }
1758 : : EXPORT_SYMBOL_GPL(snd_hda_lock_devices);
1759 : :
1760 : : /**
1761 : : * snd_hda_unlock_devices - pseudo device unlocking
1762 : : * @bus: the BUS
1763 : : */
1764 : 0 : void snd_hda_unlock_devices(struct hda_bus *bus)
1765 : : {
1766 : 0 : struct snd_card *card = bus->card;
1767 : :
1768 : 0 : spin_lock(&card->files_lock);
1769 : 0 : card->shutdown = 0;
1770 : 0 : spin_unlock(&card->files_lock);
1771 : 0 : }
1772 : : EXPORT_SYMBOL_GPL(snd_hda_unlock_devices);
1773 : :
1774 : : /**
1775 : : * snd_hda_codec_reset - Clear all objects assigned to the codec
1776 : : * @codec: HD-audio codec
1777 : : *
1778 : : * This frees the all PCM and control elements assigned to the codec, and
1779 : : * clears the caches and restores the pin default configurations.
1780 : : *
1781 : : * When a device is being used, it returns -EBSY. If successfully freed,
1782 : : * returns zero.
1783 : : */
1784 : 0 : int snd_hda_codec_reset(struct hda_codec *codec)
1785 : : {
1786 : 0 : struct hda_bus *bus = codec->bus;
1787 : :
1788 [ # # ]: 0 : if (snd_hda_lock_devices(bus) < 0)
1789 : : return -EBUSY;
1790 : :
1791 : : /* OK, let it free */
1792 : 0 : snd_hdac_device_unregister(&codec->core);
1793 : :
1794 : : /* allow device access again */
1795 : 0 : snd_hda_unlock_devices(bus);
1796 : 0 : return 0;
1797 : : }
1798 : :
1799 : : typedef int (*map_slave_func_t)(struct hda_codec *, void *, struct snd_kcontrol *);
1800 : :
1801 : : /* apply the function to all matching slave ctls in the mixer list */
1802 : 0 : static int map_slaves(struct hda_codec *codec, const char * const *slaves,
1803 : : const char *suffix, map_slave_func_t func, void *data)
1804 : : {
1805 : 0 : struct hda_nid_item *items;
1806 : 0 : const char * const *s;
1807 : 0 : int i, err;
1808 : :
1809 : 0 : items = codec->mixers.list;
1810 [ # # ]: 0 : for (i = 0; i < codec->mixers.used; i++) {
1811 : 0 : struct snd_kcontrol *sctl = items[i].kctl;
1812 [ # # # # ]: 0 : if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
1813 : 0 : continue;
1814 [ # # ]: 0 : for (s = slaves; *s; s++) {
1815 : 0 : char tmpname[sizeof(sctl->id.name)];
1816 : 0 : const char *name = *s;
1817 [ # # ]: 0 : if (suffix) {
1818 : 0 : snprintf(tmpname, sizeof(tmpname), "%s %s",
1819 : : name, suffix);
1820 : 0 : name = tmpname;
1821 : : }
1822 [ # # ]: 0 : if (!strcmp(sctl->id.name, name)) {
1823 : 0 : err = func(codec, data, sctl);
1824 [ # # ]: 0 : if (err)
1825 : 0 : return err;
1826 : 0 : break;
1827 : : }
1828 : : }
1829 : : }
1830 : : return 0;
1831 : : }
1832 : :
1833 : 0 : static int check_slave_present(struct hda_codec *codec,
1834 : : void *data, struct snd_kcontrol *sctl)
1835 : : {
1836 : 0 : return 1;
1837 : : }
1838 : :
1839 : : /* call kctl->put with the given value(s) */
1840 : 0 : static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
1841 : : {
1842 : 0 : struct snd_ctl_elem_value *ucontrol;
1843 : 0 : ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
1844 [ # # ]: 0 : if (!ucontrol)
1845 : : return -ENOMEM;
1846 : 0 : ucontrol->value.integer.value[0] = val;
1847 : 0 : ucontrol->value.integer.value[1] = val;
1848 : 0 : kctl->put(kctl, ucontrol);
1849 : 0 : kfree(ucontrol);
1850 : 0 : return 0;
1851 : : }
1852 : :
1853 : : struct slave_init_arg {
1854 : : struct hda_codec *codec;
1855 : : int step;
1856 : : };
1857 : :
1858 : : /* initialize the slave volume with 0dB via snd_ctl_apply_vmaster_slaves() */
1859 : 0 : static int init_slave_0dB(struct snd_kcontrol *slave,
1860 : : struct snd_kcontrol *kctl,
1861 : : void *_arg)
1862 : : {
1863 : 0 : struct slave_init_arg *arg = _arg;
1864 : 0 : int _tlv[4];
1865 : 0 : const int *tlv = NULL;
1866 : 0 : int step;
1867 : 0 : int val;
1868 : :
1869 [ # # ]: 0 : if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1870 [ # # ]: 0 : if (kctl->tlv.c != snd_hda_mixer_amp_tlv) {
1871 : 0 : codec_err(arg->codec,
1872 : : "Unexpected TLV callback for slave %s:%d\n",
1873 : : kctl->id.name, kctl->id.index);
1874 : 0 : return 0; /* ignore */
1875 : : }
1876 : 0 : get_ctl_amp_tlv(kctl, _tlv);
1877 : 0 : tlv = _tlv;
1878 [ # # ]: 0 : } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
1879 : 0 : tlv = kctl->tlv.p;
1880 : :
1881 [ # # # # ]: 0 : if (!tlv || tlv[SNDRV_CTL_TLVO_TYPE] != SNDRV_CTL_TLVT_DB_SCALE)
1882 : 0 : return 0;
1883 : :
1884 : 0 : step = tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP];
1885 : 0 : step &= ~TLV_DB_SCALE_MUTE;
1886 [ # # ]: 0 : if (!step)
1887 : : return 0;
1888 [ # # # # ]: 0 : if (arg->step && arg->step != step) {
1889 : 0 : codec_err(arg->codec,
1890 : : "Mismatching dB step for vmaster slave (%d!=%d)\n",
1891 : : arg->step, step);
1892 : 0 : return 0;
1893 : : }
1894 : :
1895 : 0 : arg->step = step;
1896 : 0 : val = -tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN] / step;
1897 [ # # ]: 0 : if (val > 0) {
1898 : 0 : put_kctl_with_value(slave, val);
1899 : 0 : return val;
1900 : : }
1901 : :
1902 : : return 0;
1903 : : }
1904 : :
1905 : : /* unmute the slave via snd_ctl_apply_vmaster_slaves() */
1906 : 0 : static int init_slave_unmute(struct snd_kcontrol *slave,
1907 : : struct snd_kcontrol *kctl,
1908 : : void *_arg)
1909 : : {
1910 : 0 : return put_kctl_with_value(slave, 1);
1911 : : }
1912 : :
1913 : 0 : static int add_slave(struct hda_codec *codec,
1914 : : void *data, struct snd_kcontrol *slave)
1915 : : {
1916 : 0 : return snd_ctl_add_slave(data, slave);
1917 : : }
1918 : :
1919 : : /**
1920 : : * __snd_hda_add_vmaster - create a virtual master control and add slaves
1921 : : * @codec: HD-audio codec
1922 : : * @name: vmaster control name
1923 : : * @tlv: TLV data (optional)
1924 : : * @slaves: slave control names (optional)
1925 : : * @suffix: suffix string to each slave name (optional)
1926 : : * @init_slave_vol: initialize slaves to unmute/0dB
1927 : : * @ctl_ret: store the vmaster kcontrol in return
1928 : : *
1929 : : * Create a virtual master control with the given name. The TLV data
1930 : : * must be either NULL or a valid data.
1931 : : *
1932 : : * @slaves is a NULL-terminated array of strings, each of which is a
1933 : : * slave control name. All controls with these names are assigned to
1934 : : * the new virtual master control.
1935 : : *
1936 : : * This function returns zero if successful or a negative error code.
1937 : : */
1938 : 0 : int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1939 : : unsigned int *tlv, const char * const *slaves,
1940 : : const char *suffix, bool init_slave_vol,
1941 : : struct snd_kcontrol **ctl_ret)
1942 : : {
1943 : 0 : struct snd_kcontrol *kctl;
1944 : 0 : int err;
1945 : :
1946 [ # # ]: 0 : if (ctl_ret)
1947 : 0 : *ctl_ret = NULL;
1948 : :
1949 : 0 : err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
1950 [ # # ]: 0 : if (err != 1) {
1951 : : codec_dbg(codec, "No slave found for %s\n", name);
1952 : : return 0;
1953 : : }
1954 : 0 : kctl = snd_ctl_make_virtual_master(name, tlv);
1955 [ # # ]: 0 : if (!kctl)
1956 : : return -ENOMEM;
1957 : 0 : err = snd_hda_ctl_add(codec, 0, kctl);
1958 [ # # ]: 0 : if (err < 0)
1959 : : return err;
1960 : :
1961 : 0 : err = map_slaves(codec, slaves, suffix, add_slave, kctl);
1962 [ # # ]: 0 : if (err < 0)
1963 : : return err;
1964 : :
1965 : : /* init with master mute & zero volume */
1966 : 0 : put_kctl_with_value(kctl, 0);
1967 [ # # ]: 0 : if (init_slave_vol) {
1968 : 0 : struct slave_init_arg arg = {
1969 : : .codec = codec,
1970 : : .step = 0,
1971 : : };
1972 [ # # ]: 0 : snd_ctl_apply_vmaster_slaves(kctl,
1973 : : tlv ? init_slave_0dB : init_slave_unmute,
1974 : : &arg);
1975 : : }
1976 : :
1977 [ # # ]: 0 : if (ctl_ret)
1978 : 0 : *ctl_ret = kctl;
1979 : : return 0;
1980 : : }
1981 : : EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster);
1982 : :
1983 : : /*
1984 : : * mute-LED control using vmaster
1985 : : */
1986 : 0 : static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
1987 : : struct snd_ctl_elem_info *uinfo)
1988 : : {
1989 : 0 : static const char * const texts[] = {
1990 : : "On", "Off", "Follow Master"
1991 : : };
1992 : :
1993 : 0 : return snd_ctl_enum_info(uinfo, 1, 3, texts);
1994 : : }
1995 : :
1996 : 0 : static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
1997 : : struct snd_ctl_elem_value *ucontrol)
1998 : : {
1999 : 0 : struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2000 : 0 : ucontrol->value.enumerated.item[0] = hook->mute_mode;
2001 : 0 : return 0;
2002 : : }
2003 : :
2004 : 0 : static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2005 : : struct snd_ctl_elem_value *ucontrol)
2006 : : {
2007 : 0 : struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2008 : 0 : unsigned int old_mode = hook->mute_mode;
2009 : :
2010 : 0 : hook->mute_mode = ucontrol->value.enumerated.item[0];
2011 [ # # ]: 0 : if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2012 : 0 : hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2013 [ # # ]: 0 : if (old_mode == hook->mute_mode)
2014 : : return 0;
2015 : 0 : snd_hda_sync_vmaster_hook(hook);
2016 : 0 : return 1;
2017 : : }
2018 : :
2019 : : static const struct snd_kcontrol_new vmaster_mute_mode = {
2020 : : .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2021 : : .name = "Mute-LED Mode",
2022 : : .info = vmaster_mute_mode_info,
2023 : : .get = vmaster_mute_mode_get,
2024 : : .put = vmaster_mute_mode_put,
2025 : : };
2026 : :
2027 : : /* meta hook to call each driver's vmaster hook */
2028 : 0 : static void vmaster_hook(void *private_data, int enabled)
2029 : : {
2030 : 0 : struct hda_vmaster_mute_hook *hook = private_data;
2031 : :
2032 [ # # ]: 0 : if (hook->mute_mode != HDA_VMUTE_FOLLOW_MASTER)
2033 : 0 : enabled = hook->mute_mode;
2034 : 0 : hook->hook(hook->codec, enabled);
2035 : 0 : }
2036 : :
2037 : : /**
2038 : : * snd_hda_add_vmaster_hook - Add a vmaster hook for mute-LED
2039 : : * @codec: the HDA codec
2040 : : * @hook: the vmaster hook object
2041 : : * @expose_enum_ctl: flag to create an enum ctl
2042 : : *
2043 : : * Add a mute-LED hook with the given vmaster switch kctl.
2044 : : * When @expose_enum_ctl is set, "Mute-LED Mode" control is automatically
2045 : : * created and associated with the given hook.
2046 : : */
2047 : 0 : int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2048 : : struct hda_vmaster_mute_hook *hook,
2049 : : bool expose_enum_ctl)
2050 : : {
2051 : 0 : struct snd_kcontrol *kctl;
2052 : :
2053 [ # # # # ]: 0 : if (!hook->hook || !hook->sw_kctl)
2054 : : return 0;
2055 : 0 : hook->codec = codec;
2056 : 0 : hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2057 : 0 : snd_ctl_add_vmaster_hook(hook->sw_kctl, vmaster_hook, hook);
2058 [ # # ]: 0 : if (!expose_enum_ctl)
2059 : : return 0;
2060 : 0 : kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2061 [ # # ]: 0 : if (!kctl)
2062 : : return -ENOMEM;
2063 : 0 : return snd_hda_ctl_add(codec, 0, kctl);
2064 : : }
2065 : : EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook);
2066 : :
2067 : : /**
2068 : : * snd_hda_sync_vmaster_hook - Sync vmaster hook
2069 : : * @hook: the vmaster hook
2070 : : *
2071 : : * Call the hook with the current value for synchronization.
2072 : : * Should be called in init callback.
2073 : : */
2074 : 0 : void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2075 : : {
2076 [ # # # # ]: 0 : if (!hook->hook || !hook->codec)
2077 : : return;
2078 : : /* don't call vmaster hook in the destructor since it might have
2079 : : * been already destroyed
2080 : : */
2081 [ # # ]: 0 : if (hook->codec->bus->shutdown)
2082 : : return;
2083 : 0 : snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2084 : : }
2085 : : EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook);
2086 : :
2087 : :
2088 : : /**
2089 : : * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2090 : : * @kcontrol: referred ctl element
2091 : : * @uinfo: pointer to get/store the data
2092 : : *
2093 : : * The control element is supposed to have the private_value field
2094 : : * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2095 : : */
2096 : 0 : int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2097 : : struct snd_ctl_elem_info *uinfo)
2098 : : {
2099 : 0 : int chs = get_amp_channels(kcontrol);
2100 : :
2101 : 0 : uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2102 [ # # ]: 0 : uinfo->count = chs == 3 ? 2 : 1;
2103 : 0 : uinfo->value.integer.min = 0;
2104 : 0 : uinfo->value.integer.max = 1;
2105 : 0 : return 0;
2106 : : }
2107 : : EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
2108 : :
2109 : : /**
2110 : : * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2111 : : * @kcontrol: ctl element
2112 : : * @ucontrol: pointer to get/store the data
2113 : : *
2114 : : * The control element is supposed to have the private_value field
2115 : : * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2116 : : */
2117 : 0 : int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2118 : : struct snd_ctl_elem_value *ucontrol)
2119 : : {
2120 : 0 : struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2121 : 0 : hda_nid_t nid = get_amp_nid(kcontrol);
2122 : 0 : int chs = get_amp_channels(kcontrol);
2123 : 0 : int dir = get_amp_direction(kcontrol);
2124 : 0 : int idx = get_amp_index(kcontrol);
2125 : 0 : long *valp = ucontrol->value.integer.value;
2126 : :
2127 [ # # ]: 0 : if (chs & 1)
2128 : 0 : *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2129 : 0 : HDA_AMP_MUTE) ? 0 : 1;
2130 [ # # ]: 0 : if (chs & 2)
2131 : 0 : *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2132 : 0 : HDA_AMP_MUTE) ? 0 : 1;
2133 : 0 : return 0;
2134 : : }
2135 : : EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
2136 : :
2137 : : /**
2138 : : * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2139 : : * @kcontrol: ctl element
2140 : : * @ucontrol: pointer to get/store the data
2141 : : *
2142 : : * The control element is supposed to have the private_value field
2143 : : * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2144 : : */
2145 : 0 : int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2146 : : struct snd_ctl_elem_value *ucontrol)
2147 : : {
2148 : 0 : struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2149 : 0 : hda_nid_t nid = get_amp_nid(kcontrol);
2150 : 0 : int chs = get_amp_channels(kcontrol);
2151 : 0 : int dir = get_amp_direction(kcontrol);
2152 : 0 : int idx = get_amp_index(kcontrol);
2153 : 0 : long *valp = ucontrol->value.integer.value;
2154 : 0 : int change = 0;
2155 : :
2156 [ # # ]: 0 : if (chs & 1) {
2157 : 0 : change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2158 : : HDA_AMP_MUTE,
2159 [ # # ]: 0 : *valp ? 0 : HDA_AMP_MUTE);
2160 : 0 : valp++;
2161 : : }
2162 [ # # ]: 0 : if (chs & 2)
2163 : 0 : change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2164 : : HDA_AMP_MUTE,
2165 [ # # ]: 0 : *valp ? 0 : HDA_AMP_MUTE);
2166 [ # # ]: 0 : hda_call_check_power_status(codec, nid);
2167 : 0 : return change;
2168 : : }
2169 : : EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
2170 : :
2171 : : /*
2172 : : * SPDIF out controls
2173 : : */
2174 : :
2175 : 0 : static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2176 : : struct snd_ctl_elem_info *uinfo)
2177 : : {
2178 : 0 : uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2179 : 0 : uinfo->count = 1;
2180 : 0 : return 0;
2181 : : }
2182 : :
2183 : 0 : static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2184 : : struct snd_ctl_elem_value *ucontrol)
2185 : : {
2186 : 0 : ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2187 : : IEC958_AES0_NONAUDIO |
2188 : : IEC958_AES0_CON_EMPHASIS_5015 |
2189 : : IEC958_AES0_CON_NOT_COPYRIGHT;
2190 : 0 : ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2191 : : IEC958_AES1_CON_ORIGINAL;
2192 : 0 : return 0;
2193 : : }
2194 : :
2195 : 0 : static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2196 : : struct snd_ctl_elem_value *ucontrol)
2197 : : {
2198 : 0 : ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2199 : : IEC958_AES0_NONAUDIO |
2200 : : IEC958_AES0_PRO_EMPHASIS_5015;
2201 : 0 : return 0;
2202 : : }
2203 : :
2204 : 0 : static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2205 : : struct snd_ctl_elem_value *ucontrol)
2206 : : {
2207 : 0 : struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2208 : 0 : int idx = kcontrol->private_value;
2209 : 0 : struct hda_spdif_out *spdif;
2210 : :
2211 [ # # # # ]: 0 : if (WARN_ON(codec->spdif_out.used <= idx))
2212 : : return -EINVAL;
2213 : 0 : mutex_lock(&codec->spdif_mutex);
2214 : 0 : spdif = snd_array_elem(&codec->spdif_out, idx);
2215 : 0 : ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2216 : 0 : ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2217 : 0 : ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2218 : 0 : ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2219 : 0 : mutex_unlock(&codec->spdif_mutex);
2220 : :
2221 : 0 : return 0;
2222 : : }
2223 : :
2224 : : /* convert from SPDIF status bits to HDA SPDIF bits
2225 : : * bit 0 (DigEn) is always set zero (to be filled later)
2226 : : */
2227 : 0 : static unsigned short convert_from_spdif_status(unsigned int sbits)
2228 : : {
2229 : 0 : unsigned short val = 0;
2230 : :
2231 [ # # ]: 0 : if (sbits & IEC958_AES0_PROFESSIONAL)
2232 : 0 : val |= AC_DIG1_PROFESSIONAL;
2233 [ # # ]: 0 : if (sbits & IEC958_AES0_NONAUDIO)
2234 : 0 : val |= AC_DIG1_NONAUDIO;
2235 [ # # ]: 0 : if (sbits & IEC958_AES0_PROFESSIONAL) {
2236 [ # # ]: 0 : if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2237 : : IEC958_AES0_PRO_EMPHASIS_5015)
2238 : 0 : val |= AC_DIG1_EMPHASIS;
2239 : : } else {
2240 [ # # ]: 0 : if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2241 : : IEC958_AES0_CON_EMPHASIS_5015)
2242 : 0 : val |= AC_DIG1_EMPHASIS;
2243 [ # # ]: 0 : if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2244 : 0 : val |= AC_DIG1_COPYRIGHT;
2245 [ # # ]: 0 : if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2246 : 0 : val |= AC_DIG1_LEVEL;
2247 : 0 : val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2248 : : }
2249 : 0 : return val;
2250 : : }
2251 : :
2252 : : /* convert to SPDIF status bits from HDA SPDIF bits
2253 : : */
2254 : 0 : static unsigned int convert_to_spdif_status(unsigned short val)
2255 : : {
2256 : 0 : unsigned int sbits = 0;
2257 : :
2258 [ # # ]: 0 : if (val & AC_DIG1_NONAUDIO)
2259 : 0 : sbits |= IEC958_AES0_NONAUDIO;
2260 [ # # ]: 0 : if (val & AC_DIG1_PROFESSIONAL)
2261 : 0 : sbits |= IEC958_AES0_PROFESSIONAL;
2262 [ # # ]: 0 : if (sbits & IEC958_AES0_PROFESSIONAL) {
2263 [ # # ]: 0 : if (val & AC_DIG1_EMPHASIS)
2264 : 0 : sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2265 : : } else {
2266 [ # # ]: 0 : if (val & AC_DIG1_EMPHASIS)
2267 : 0 : sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2268 [ # # ]: 0 : if (!(val & AC_DIG1_COPYRIGHT))
2269 : 0 : sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2270 [ # # ]: 0 : if (val & AC_DIG1_LEVEL)
2271 : 0 : sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2272 : 0 : sbits |= val & (0x7f << 8);
2273 : : }
2274 : 0 : return sbits;
2275 : : }
2276 : :
2277 : : /* set digital convert verbs both for the given NID and its slaves */
2278 : 0 : static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2279 : : int mask, int val)
2280 : : {
2281 : 0 : const hda_nid_t *d;
2282 : :
2283 : 0 : snd_hdac_regmap_update(&codec->core, nid, AC_VERB_SET_DIGI_CONVERT_1,
2284 : : mask, val);
2285 : 0 : d = codec->slave_dig_outs;
2286 [ # # ]: 0 : if (!d)
2287 : : return;
2288 [ # # ]: 0 : for (; *d; d++)
2289 : 0 : snd_hdac_regmap_update(&codec->core, *d,
2290 : : AC_VERB_SET_DIGI_CONVERT_1, mask, val);
2291 : : }
2292 : :
2293 : 0 : static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2294 : : int dig1, int dig2)
2295 : : {
2296 : 0 : unsigned int mask = 0;
2297 : 0 : unsigned int val = 0;
2298 : :
2299 : 0 : if (dig1 != -1) {
2300 : 0 : mask |= 0xff;
2301 : 0 : val = dig1;
2302 : : }
2303 [ # # ]: 0 : if (dig2 != -1) {
2304 : 0 : mask |= 0xff00;
2305 : 0 : val |= dig2 << 8;
2306 : : }
2307 : 0 : set_dig_out(codec, nid, mask, val);
2308 : 0 : }
2309 : :
2310 : 0 : static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2311 : : struct snd_ctl_elem_value *ucontrol)
2312 : : {
2313 : 0 : struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2314 : 0 : int idx = kcontrol->private_value;
2315 : 0 : struct hda_spdif_out *spdif;
2316 : 0 : hda_nid_t nid;
2317 : 0 : unsigned short val;
2318 : 0 : int change;
2319 : :
2320 [ # # # # ]: 0 : if (WARN_ON(codec->spdif_out.used <= idx))
2321 : : return -EINVAL;
2322 : 0 : mutex_lock(&codec->spdif_mutex);
2323 [ # # ]: 0 : spdif = snd_array_elem(&codec->spdif_out, idx);
2324 : 0 : nid = spdif->nid;
2325 : 0 : spdif->status = ucontrol->value.iec958.status[0] |
2326 : 0 : ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2327 : 0 : ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2328 : 0 : ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2329 : 0 : val = convert_from_spdif_status(spdif->status);
2330 : 0 : val |= spdif->ctls & 1;
2331 : 0 : change = spdif->ctls != val;
2332 : 0 : spdif->ctls = val;
2333 [ # # ]: 0 : if (change && nid != (u16)-1)
2334 : 0 : set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2335 : 0 : mutex_unlock(&codec->spdif_mutex);
2336 : 0 : return change;
2337 : : }
2338 : :
2339 : : #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2340 : :
2341 : 0 : static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2342 : : struct snd_ctl_elem_value *ucontrol)
2343 : : {
2344 : 0 : struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2345 : 0 : int idx = kcontrol->private_value;
2346 : 0 : struct hda_spdif_out *spdif;
2347 : :
2348 [ # # # # ]: 0 : if (WARN_ON(codec->spdif_out.used <= idx))
2349 : : return -EINVAL;
2350 : 0 : mutex_lock(&codec->spdif_mutex);
2351 : 0 : spdif = snd_array_elem(&codec->spdif_out, idx);
2352 : 0 : ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
2353 : 0 : mutex_unlock(&codec->spdif_mutex);
2354 : 0 : return 0;
2355 : : }
2356 : :
2357 : 0 : static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2358 : : int dig1, int dig2)
2359 : : {
2360 [ # # ]: 0 : set_dig_out_convert(codec, nid, dig1, dig2);
2361 : : /* unmute amp switch (if any) */
2362 [ # # # # ]: 0 : if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2363 [ # # ]: 0 : (dig1 & AC_DIG1_ENABLE))
2364 : 0 : snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2365 : : HDA_AMP_MUTE, 0);
2366 : 0 : }
2367 : :
2368 : 0 : static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2369 : : struct snd_ctl_elem_value *ucontrol)
2370 : : {
2371 : 0 : struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2372 : 0 : int idx = kcontrol->private_value;
2373 : 0 : struct hda_spdif_out *spdif;
2374 : 0 : hda_nid_t nid;
2375 : 0 : unsigned short val;
2376 : 0 : int change;
2377 : :
2378 [ # # # # ]: 0 : if (WARN_ON(codec->spdif_out.used <= idx))
2379 : : return -EINVAL;
2380 : 0 : mutex_lock(&codec->spdif_mutex);
2381 [ # # ]: 0 : spdif = snd_array_elem(&codec->spdif_out, idx);
2382 : 0 : nid = spdif->nid;
2383 : 0 : val = spdif->ctls & ~AC_DIG1_ENABLE;
2384 [ # # ]: 0 : if (ucontrol->value.integer.value[0])
2385 : 0 : val |= AC_DIG1_ENABLE;
2386 : 0 : change = spdif->ctls != val;
2387 : 0 : spdif->ctls = val;
2388 [ # # ]: 0 : if (change && nid != (u16)-1)
2389 : 0 : set_spdif_ctls(codec, nid, val & 0xff, -1);
2390 : 0 : mutex_unlock(&codec->spdif_mutex);
2391 : 0 : return change;
2392 : : }
2393 : :
2394 : : static const struct snd_kcontrol_new dig_mixes[] = {
2395 : : {
2396 : : .access = SNDRV_CTL_ELEM_ACCESS_READ,
2397 : : .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2398 : : .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
2399 : : .info = snd_hda_spdif_mask_info,
2400 : : .get = snd_hda_spdif_cmask_get,
2401 : : },
2402 : : {
2403 : : .access = SNDRV_CTL_ELEM_ACCESS_READ,
2404 : : .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2405 : : .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
2406 : : .info = snd_hda_spdif_mask_info,
2407 : : .get = snd_hda_spdif_pmask_get,
2408 : : },
2409 : : {
2410 : : .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2411 : : .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
2412 : : .info = snd_hda_spdif_mask_info,
2413 : : .get = snd_hda_spdif_default_get,
2414 : : .put = snd_hda_spdif_default_put,
2415 : : },
2416 : : {
2417 : : .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2418 : : .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
2419 : : .info = snd_hda_spdif_out_switch_info,
2420 : : .get = snd_hda_spdif_out_switch_get,
2421 : : .put = snd_hda_spdif_out_switch_put,
2422 : : },
2423 : : { } /* end */
2424 : : };
2425 : :
2426 : : /**
2427 : : * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
2428 : : * @codec: the HDA codec
2429 : : * @associated_nid: NID that new ctls associated with
2430 : : * @cvt_nid: converter NID
2431 : : * @type: HDA_PCM_TYPE_*
2432 : : * Creates controls related with the digital output.
2433 : : * Called from each patch supporting the digital out.
2434 : : *
2435 : : * Returns 0 if successful, or a negative error code.
2436 : : */
2437 : 0 : int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
2438 : : hda_nid_t associated_nid,
2439 : : hda_nid_t cvt_nid,
2440 : : int type)
2441 : : {
2442 : 0 : int err;
2443 : 0 : struct snd_kcontrol *kctl;
2444 : 0 : const struct snd_kcontrol_new *dig_mix;
2445 : 0 : int idx = 0;
2446 : 0 : int val = 0;
2447 : 0 : const int spdif_index = 16;
2448 : 0 : struct hda_spdif_out *spdif;
2449 : 0 : struct hda_bus *bus = codec->bus;
2450 : :
2451 [ # # # # ]: 0 : if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
2452 : : type == HDA_PCM_TYPE_SPDIF) {
2453 : : idx = spdif_index;
2454 [ # # # # ]: 0 : } else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
2455 : : type == HDA_PCM_TYPE_HDMI) {
2456 : : /* suppose a single SPDIF device */
2457 [ # # ]: 0 : for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2458 : 0 : kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
2459 [ # # ]: 0 : if (!kctl)
2460 : : break;
2461 : 0 : kctl->id.index = spdif_index;
2462 : : }
2463 : 0 : bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
2464 : : }
2465 [ # # ]: 0 : if (!bus->primary_dig_out_type)
2466 : 0 : bus->primary_dig_out_type = type;
2467 : :
2468 : : idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
2469 [ # # ]: 0 : if (idx < 0) {
2470 : 0 : codec_err(codec, "too many IEC958 outputs\n");
2471 : 0 : return -EBUSY;
2472 : : }
2473 : 0 : spdif = snd_array_new(&codec->spdif_out);
2474 [ # # ]: 0 : if (!spdif)
2475 : : return -ENOMEM;
2476 [ # # ]: 0 : for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2477 : 0 : kctl = snd_ctl_new1(dig_mix, codec);
2478 [ # # ]: 0 : if (!kctl)
2479 : : return -ENOMEM;
2480 : 0 : kctl->id.index = idx;
2481 : 0 : kctl->private_value = codec->spdif_out.used - 1;
2482 : 0 : err = snd_hda_ctl_add(codec, associated_nid, kctl);
2483 [ # # ]: 0 : if (err < 0)
2484 : 0 : return err;
2485 : : }
2486 : 0 : spdif->nid = cvt_nid;
2487 : 0 : snd_hdac_regmap_read(&codec->core, cvt_nid,
2488 : : AC_VERB_GET_DIGI_CONVERT_1, &val);
2489 : 0 : spdif->ctls = val;
2490 : 0 : spdif->status = convert_to_spdif_status(spdif->ctls);
2491 : 0 : return 0;
2492 : : }
2493 : : EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls);
2494 : :
2495 : : /**
2496 : : * snd_hda_spdif_out_of_nid - get the hda_spdif_out entry from the given NID
2497 : : * @codec: the HDA codec
2498 : : * @nid: widget NID
2499 : : *
2500 : : * call within spdif_mutex lock
2501 : : */
2502 : 0 : struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
2503 : : hda_nid_t nid)
2504 : : {
2505 : 0 : struct hda_spdif_out *spdif;
2506 : 0 : int i;
2507 : :
2508 [ # # # # : 0 : snd_array_for_each(&codec->spdif_out, i, spdif) {
# # ]
2509 [ # # # # : 0 : if (spdif->nid == nid)
# # ]
2510 : 0 : return spdif;
2511 : : }
2512 : : return NULL;
2513 : : }
2514 : : EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_nid);
2515 : :
2516 : : /**
2517 : : * snd_hda_spdif_ctls_unassign - Unassign the given SPDIF ctl
2518 : : * @codec: the HDA codec
2519 : : * @idx: the SPDIF ctl index
2520 : : *
2521 : : * Unassign the widget from the given SPDIF control.
2522 : : */
2523 : 0 : void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
2524 : : {
2525 : 0 : struct hda_spdif_out *spdif;
2526 : :
2527 [ # # # # ]: 0 : if (WARN_ON(codec->spdif_out.used <= idx))
2528 : : return;
2529 : 0 : mutex_lock(&codec->spdif_mutex);
2530 : 0 : spdif = snd_array_elem(&codec->spdif_out, idx);
2531 : 0 : spdif->nid = (u16)-1;
2532 : 0 : mutex_unlock(&codec->spdif_mutex);
2533 : : }
2534 : : EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
2535 : :
2536 : : /**
2537 : : * snd_hda_spdif_ctls_assign - Assign the SPDIF controls to the given NID
2538 : : * @codec: the HDA codec
2539 : : * @idx: the SPDIF ctl idx
2540 : : * @nid: widget NID
2541 : : *
2542 : : * Assign the widget to the SPDIF control with the given index.
2543 : : */
2544 : 0 : void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
2545 : : {
2546 : 0 : struct hda_spdif_out *spdif;
2547 : 0 : unsigned short val;
2548 : :
2549 [ # # # # ]: 0 : if (WARN_ON(codec->spdif_out.used <= idx))
2550 : : return;
2551 : 0 : mutex_lock(&codec->spdif_mutex);
2552 [ # # ]: 0 : spdif = snd_array_elem(&codec->spdif_out, idx);
2553 [ # # ]: 0 : if (spdif->nid != nid) {
2554 : 0 : spdif->nid = nid;
2555 : 0 : val = spdif->ctls;
2556 : 0 : set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
2557 : : }
2558 : 0 : mutex_unlock(&codec->spdif_mutex);
2559 : : }
2560 : : EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
2561 : :
2562 : : /*
2563 : : * SPDIF sharing with analog output
2564 : : */
2565 : 0 : static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2566 : : struct snd_ctl_elem_value *ucontrol)
2567 : : {
2568 : 0 : struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2569 : 0 : ucontrol->value.integer.value[0] = mout->share_spdif;
2570 : 0 : return 0;
2571 : : }
2572 : :
2573 : 0 : static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2574 : : struct snd_ctl_elem_value *ucontrol)
2575 : : {
2576 : 0 : struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2577 : 0 : mout->share_spdif = !!ucontrol->value.integer.value[0];
2578 : 0 : return 0;
2579 : : }
2580 : :
2581 : : static const struct snd_kcontrol_new spdif_share_sw = {
2582 : : .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2583 : : .name = "IEC958 Default PCM Playback Switch",
2584 : : .info = snd_ctl_boolean_mono_info,
2585 : : .get = spdif_share_sw_get,
2586 : : .put = spdif_share_sw_put,
2587 : : };
2588 : :
2589 : : /**
2590 : : * snd_hda_create_spdif_share_sw - create Default PCM switch
2591 : : * @codec: the HDA codec
2592 : : * @mout: multi-out instance
2593 : : */
2594 : 0 : int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2595 : : struct hda_multi_out *mout)
2596 : : {
2597 : 0 : struct snd_kcontrol *kctl;
2598 : :
2599 [ # # ]: 0 : if (!mout->dig_out_nid)
2600 : : return 0;
2601 : :
2602 : 0 : kctl = snd_ctl_new1(&spdif_share_sw, mout);
2603 [ # # ]: 0 : if (!kctl)
2604 : : return -ENOMEM;
2605 : : /* ATTENTION: here mout is passed as private_data, instead of codec */
2606 : 0 : return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
2607 : : }
2608 : : EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
2609 : :
2610 : : /*
2611 : : * SPDIF input
2612 : : */
2613 : :
2614 : : #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2615 : :
2616 : 0 : static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2617 : : struct snd_ctl_elem_value *ucontrol)
2618 : : {
2619 : 0 : struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2620 : :
2621 : 0 : ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2622 : 0 : return 0;
2623 : : }
2624 : :
2625 : 0 : static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2626 : : struct snd_ctl_elem_value *ucontrol)
2627 : : {
2628 : 0 : struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2629 : 0 : hda_nid_t nid = kcontrol->private_value;
2630 : 0 : unsigned int val = !!ucontrol->value.integer.value[0];
2631 : 0 : int change;
2632 : :
2633 : 0 : mutex_lock(&codec->spdif_mutex);
2634 : 0 : change = codec->spdif_in_enable != val;
2635 [ # # ]: 0 : if (change) {
2636 : 0 : codec->spdif_in_enable = val;
2637 : 0 : snd_hdac_regmap_write(&codec->core, nid,
2638 : : AC_VERB_SET_DIGI_CONVERT_1, val);
2639 : : }
2640 : 0 : mutex_unlock(&codec->spdif_mutex);
2641 : 0 : return change;
2642 : : }
2643 : :
2644 : 0 : static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2645 : : struct snd_ctl_elem_value *ucontrol)
2646 : : {
2647 : 0 : struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2648 : 0 : hda_nid_t nid = kcontrol->private_value;
2649 : 0 : unsigned int val;
2650 : 0 : unsigned int sbits;
2651 : :
2652 : 0 : snd_hdac_regmap_read(&codec->core, nid,
2653 : : AC_VERB_GET_DIGI_CONVERT_1, &val);
2654 : 0 : sbits = convert_to_spdif_status(val);
2655 : 0 : ucontrol->value.iec958.status[0] = sbits;
2656 : 0 : ucontrol->value.iec958.status[1] = sbits >> 8;
2657 : 0 : ucontrol->value.iec958.status[2] = sbits >> 16;
2658 : 0 : ucontrol->value.iec958.status[3] = sbits >> 24;
2659 : 0 : return 0;
2660 : : }
2661 : :
2662 : : static const struct snd_kcontrol_new dig_in_ctls[] = {
2663 : : {
2664 : : .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2665 : : .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
2666 : : .info = snd_hda_spdif_in_switch_info,
2667 : : .get = snd_hda_spdif_in_switch_get,
2668 : : .put = snd_hda_spdif_in_switch_put,
2669 : : },
2670 : : {
2671 : : .access = SNDRV_CTL_ELEM_ACCESS_READ,
2672 : : .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2673 : : .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
2674 : : .info = snd_hda_spdif_mask_info,
2675 : : .get = snd_hda_spdif_in_status_get,
2676 : : },
2677 : : { } /* end */
2678 : : };
2679 : :
2680 : : /**
2681 : : * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2682 : : * @codec: the HDA codec
2683 : : * @nid: audio in widget NID
2684 : : *
2685 : : * Creates controls related with the SPDIF input.
2686 : : * Called from each patch supporting the SPDIF in.
2687 : : *
2688 : : * Returns 0 if successful, or a negative error code.
2689 : : */
2690 : 0 : int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2691 : : {
2692 : 0 : int err;
2693 : 0 : struct snd_kcontrol *kctl;
2694 : 0 : const struct snd_kcontrol_new *dig_mix;
2695 : 0 : int idx;
2696 : :
2697 : 0 : idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
2698 [ # # ]: 0 : if (idx < 0) {
2699 : 0 : codec_err(codec, "too many IEC958 inputs\n");
2700 : 0 : return -EBUSY;
2701 : : }
2702 [ # # ]: 0 : for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2703 : 0 : kctl = snd_ctl_new1(dig_mix, codec);
2704 [ # # ]: 0 : if (!kctl)
2705 : : return -ENOMEM;
2706 : 0 : kctl->private_value = nid;
2707 : 0 : err = snd_hda_ctl_add(codec, nid, kctl);
2708 [ # # ]: 0 : if (err < 0)
2709 : 0 : return err;
2710 : : }
2711 : 0 : codec->spdif_in_enable =
2712 : 0 : snd_hda_codec_read(codec, nid, 0,
2713 : 0 : AC_VERB_GET_DIGI_CONVERT_1, 0) &
2714 : : AC_DIG1_ENABLE;
2715 : 0 : return 0;
2716 : : }
2717 : : EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
2718 : :
2719 : : /**
2720 : : * snd_hda_codec_set_power_to_all - Set the power state to all widgets
2721 : : * @codec: the HDA codec
2722 : : * @fg: function group (not used now)
2723 : : * @power_state: the power state to set (AC_PWRST_*)
2724 : : *
2725 : : * Set the given power state to all widgets that have the power control.
2726 : : * If the codec has power_filter set, it evaluates the power state and
2727 : : * filter out if it's unchanged as D3.
2728 : : */
2729 : 0 : void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
2730 : : unsigned int power_state)
2731 : : {
2732 : 0 : hda_nid_t nid;
2733 : :
2734 [ # # ]: 0 : for_each_hda_codec_node(nid, codec) {
2735 [ # # ]: 0 : unsigned int wcaps = get_wcaps(codec, nid);
2736 : 0 : unsigned int state = power_state;
2737 [ # # ]: 0 : if (!(wcaps & AC_WCAP_POWER))
2738 : 0 : continue;
2739 [ # # ]: 0 : if (codec->power_filter) {
2740 : 0 : state = codec->power_filter(codec, nid, power_state);
2741 [ # # ]: 0 : if (state != power_state && power_state == AC_PWRST_D3)
2742 : 0 : continue;
2743 : : }
2744 : 0 : snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
2745 : : state);
2746 : : }
2747 : 0 : }
2748 : : EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all);
2749 : :
2750 : : /**
2751 : : * snd_hda_codec_eapd_power_filter - A power filter callback for EAPD
2752 : : * @codec: the HDA codec
2753 : : * @nid: widget NID
2754 : : * @power_state: power state to evalue
2755 : : *
2756 : : * Don't power down the widget if it controls eapd and EAPD_BTLENABLE is set.
2757 : : * This can be used a codec power_filter callback.
2758 : : */
2759 : 0 : unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
2760 : : hda_nid_t nid,
2761 : : unsigned int power_state)
2762 : : {
2763 [ # # # # ]: 0 : if (nid == codec->core.afg || nid == codec->core.mfg)
2764 : : return power_state;
2765 [ # # # # ]: 0 : if (power_state == AC_PWRST_D3 &&
2766 [ # # ]: 0 : get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
2767 [ # # ]: 0 : (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
2768 : 0 : int eapd = snd_hda_codec_read(codec, nid, 0,
2769 : : AC_VERB_GET_EAPD_BTLENABLE, 0);
2770 [ # # ]: 0 : if (eapd & 0x02)
2771 : 0 : return AC_PWRST_D0;
2772 : : }
2773 : : return power_state;
2774 : : }
2775 : : EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter);
2776 : :
2777 : : /*
2778 : : * set power state of the codec, and return the power state
2779 : : */
2780 : 0 : static unsigned int hda_set_power_state(struct hda_codec *codec,
2781 : : unsigned int power_state)
2782 : : {
2783 [ # # ]: 0 : hda_nid_t fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
2784 : 0 : int count;
2785 : 0 : unsigned int state;
2786 : 0 : int flags = 0;
2787 : :
2788 : : /* this delay seems necessary to avoid click noise at power-down */
2789 [ # # ]: 0 : if (power_state == AC_PWRST_D3) {
2790 [ # # ]: 0 : if (codec->depop_delay < 0)
2791 [ # # ]: 0 : msleep(codec_has_epss(codec) ? 10 : 100);
2792 [ # # ]: 0 : else if (codec->depop_delay > 0)
2793 : 0 : msleep(codec->depop_delay);
2794 : : flags = HDA_RW_NO_RESPONSE_FALLBACK;
2795 : : }
2796 : :
2797 : : /* repeat power states setting at most 10 times*/
2798 [ # # ]: 0 : for (count = 0; count < 10; count++) {
2799 [ # # ]: 0 : if (codec->patch_ops.set_power_state)
2800 : 0 : codec->patch_ops.set_power_state(codec, fg,
2801 : : power_state);
2802 : : else {
2803 : 0 : state = power_state;
2804 [ # # ]: 0 : if (codec->power_filter)
2805 : 0 : state = codec->power_filter(codec, fg, state);
2806 [ # # ]: 0 : if (state == power_state || power_state != AC_PWRST_D3)
2807 : 0 : snd_hda_codec_read(codec, fg, flags,
2808 : : AC_VERB_SET_POWER_STATE,
2809 : : state);
2810 : 0 : snd_hda_codec_set_power_to_all(codec, fg, power_state);
2811 : : }
2812 : 0 : state = snd_hda_sync_power_state(codec, fg, power_state);
2813 [ # # ]: 0 : if (!(state & AC_PWRST_ERROR))
2814 : : break;
2815 : : }
2816 : :
2817 : 0 : return state;
2818 : : }
2819 : :
2820 : : /* sync power states of all widgets;
2821 : : * this is called at the end of codec parsing
2822 : : */
2823 : 0 : static void sync_power_up_states(struct hda_codec *codec)
2824 : : {
2825 : 0 : hda_nid_t nid;
2826 : :
2827 : : /* don't care if no filter is used */
2828 [ # # ]: 0 : if (!codec->power_filter)
2829 : : return;
2830 : :
2831 [ # # ]: 0 : for_each_hda_codec_node(nid, codec) {
2832 [ # # ]: 0 : unsigned int wcaps = get_wcaps(codec, nid);
2833 : 0 : unsigned int target;
2834 [ # # ]: 0 : if (!(wcaps & AC_WCAP_POWER))
2835 : 0 : continue;
2836 : 0 : target = codec->power_filter(codec, nid, AC_PWRST_D0);
2837 [ # # ]: 0 : if (target == AC_PWRST_D0)
2838 : 0 : continue;
2839 [ # # ]: 0 : if (!snd_hda_check_power_state(codec, nid, target))
2840 : 0 : snd_hda_codec_write(codec, nid, 0,
2841 : : AC_VERB_SET_POWER_STATE, target);
2842 : : }
2843 : : }
2844 : :
2845 : : #ifdef CONFIG_SND_HDA_RECONFIG
2846 : : /* execute additional init verbs */
2847 : : static void hda_exec_init_verbs(struct hda_codec *codec)
2848 : : {
2849 : : if (codec->init_verbs.list)
2850 : : snd_hda_sequence_write(codec, codec->init_verbs.list);
2851 : : }
2852 : : #else
2853 : 0 : static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2854 : : #endif
2855 : :
2856 : : #ifdef CONFIG_PM
2857 : : /* update the power on/off account with the current jiffies */
2858 : 0 : static void update_power_acct(struct hda_codec *codec, bool on)
2859 : : {
2860 : 0 : unsigned long delta = jiffies - codec->power_jiffies;
2861 : :
2862 [ # # ]: 0 : if (on)
2863 : 0 : codec->power_on_acct += delta;
2864 : : else
2865 : 0 : codec->power_off_acct += delta;
2866 : 0 : codec->power_jiffies += delta;
2867 : : }
2868 : :
2869 : 0 : void snd_hda_update_power_acct(struct hda_codec *codec)
2870 : : {
2871 [ # # ]: 0 : update_power_acct(codec, hda_codec_is_power_on(codec));
2872 : 0 : }
2873 : :
2874 : : /*
2875 : : * call suspend and power-down; used both from PM and power-save
2876 : : * this function returns the power state in the end
2877 : : */
2878 : 0 : static unsigned int hda_call_codec_suspend(struct hda_codec *codec)
2879 : : {
2880 : 0 : unsigned int state;
2881 : :
2882 : 0 : snd_hdac_enter_pm(&codec->core);
2883 [ # # ]: 0 : if (codec->patch_ops.suspend)
2884 : 0 : codec->patch_ops.suspend(codec);
2885 : 0 : hda_cleanup_all_streams(codec);
2886 : 0 : state = hda_set_power_state(codec, AC_PWRST_D3);
2887 : 0 : update_power_acct(codec, true);
2888 : 0 : snd_hdac_leave_pm(&codec->core);
2889 : 0 : return state;
2890 : : }
2891 : :
2892 : : /*
2893 : : * kick up codec; used both from PM and power-save
2894 : : */
2895 : 0 : static void hda_call_codec_resume(struct hda_codec *codec)
2896 : : {
2897 : 0 : snd_hdac_enter_pm(&codec->core);
2898 [ # # ]: 0 : if (codec->core.regmap)
2899 : 0 : regcache_mark_dirty(codec->core.regmap);
2900 : :
2901 : 0 : codec->power_jiffies = jiffies;
2902 : :
2903 : 0 : hda_set_power_state(codec, AC_PWRST_D0);
2904 : 0 : restore_shutup_pins(codec);
2905 : 0 : hda_exec_init_verbs(codec);
2906 : 0 : snd_hda_jack_set_dirty_all(codec);
2907 [ # # ]: 0 : if (codec->patch_ops.resume)
2908 : 0 : codec->patch_ops.resume(codec);
2909 : : else {
2910 [ # # ]: 0 : if (codec->patch_ops.init)
2911 : 0 : codec->patch_ops.init(codec);
2912 : 0 : snd_hda_regmap_sync(codec);
2913 : : }
2914 : :
2915 [ # # ]: 0 : if (codec->jackpoll_interval)
2916 : 0 : hda_jackpoll_work(&codec->jackpoll_work.work);
2917 : : else
2918 : 0 : snd_hda_jack_report_sync(codec);
2919 : 0 : codec->core.dev.power.power_state = PMSG_ON;
2920 : 0 : snd_hdac_leave_pm(&codec->core);
2921 : 0 : }
2922 : :
2923 : 0 : static int hda_codec_runtime_suspend(struct device *dev)
2924 : : {
2925 : 0 : struct hda_codec *codec = dev_to_hda_codec(dev);
2926 : 0 : unsigned int state;
2927 : :
2928 : 0 : cancel_delayed_work_sync(&codec->jackpoll_work);
2929 : 0 : state = hda_call_codec_suspend(codec);
2930 [ # # ]: 0 : if (codec->link_down_at_suspend ||
2931 [ # # # # ]: 0 : (codec_has_clkstop(codec) && codec_has_epss(codec) &&
2932 [ # # ]: 0 : (state & AC_PWRST_CLK_STOP_OK)))
2933 : 0 : snd_hdac_codec_link_down(&codec->core);
2934 [ # # ]: 0 : codec_display_power(codec, false);
2935 : 0 : return 0;
2936 : : }
2937 : :
2938 : 0 : static int hda_codec_runtime_resume(struct device *dev)
2939 : : {
2940 : 0 : struct hda_codec *codec = dev_to_hda_codec(dev);
2941 : :
2942 [ # # ]: 0 : codec_display_power(codec, true);
2943 : 0 : snd_hdac_codec_link_up(&codec->core);
2944 : 0 : hda_call_codec_resume(codec);
2945 : 0 : pm_runtime_mark_last_busy(dev);
2946 : 0 : return 0;
2947 : : }
2948 : : #endif /* CONFIG_PM */
2949 : :
2950 : : #ifdef CONFIG_PM_SLEEP
2951 : 0 : static int hda_codec_force_resume(struct device *dev)
2952 : : {
2953 : 0 : struct hda_codec *codec = dev_to_hda_codec(dev);
2954 [ # # # # ]: 0 : bool forced_resume = !codec->relaxed_resume && codec->jacktbl.used;
2955 : 0 : int ret;
2956 : :
2957 : : /* The get/put pair below enforces the runtime resume even if the
2958 : : * device hasn't been used at suspend time. This trick is needed to
2959 : : * update the jack state change during the sleep.
2960 : : */
2961 [ # # ]: 0 : if (forced_resume)
2962 : 0 : pm_runtime_get_noresume(dev);
2963 : 0 : ret = pm_runtime_force_resume(dev);
2964 [ # # ]: 0 : if (forced_resume)
2965 : 0 : pm_runtime_put(dev);
2966 : 0 : return ret;
2967 : : }
2968 : :
2969 : 0 : static int hda_codec_pm_suspend(struct device *dev)
2970 : : {
2971 : 0 : dev->power.power_state = PMSG_SUSPEND;
2972 : 0 : return pm_runtime_force_suspend(dev);
2973 : : }
2974 : :
2975 : 0 : static int hda_codec_pm_resume(struct device *dev)
2976 : : {
2977 : 0 : dev->power.power_state = PMSG_RESUME;
2978 : 0 : return hda_codec_force_resume(dev);
2979 : : }
2980 : :
2981 : 0 : static int hda_codec_pm_freeze(struct device *dev)
2982 : : {
2983 : 0 : dev->power.power_state = PMSG_FREEZE;
2984 : 0 : return pm_runtime_force_suspend(dev);
2985 : : }
2986 : :
2987 : 0 : static int hda_codec_pm_thaw(struct device *dev)
2988 : : {
2989 : 0 : dev->power.power_state = PMSG_THAW;
2990 : 0 : return hda_codec_force_resume(dev);
2991 : : }
2992 : :
2993 : 0 : static int hda_codec_pm_restore(struct device *dev)
2994 : : {
2995 : 0 : dev->power.power_state = PMSG_RESTORE;
2996 : 0 : return hda_codec_force_resume(dev);
2997 : : }
2998 : : #endif /* CONFIG_PM_SLEEP */
2999 : :
3000 : : /* referred in hda_bind.c */
3001 : : const struct dev_pm_ops hda_codec_driver_pm = {
3002 : : #ifdef CONFIG_PM_SLEEP
3003 : : .suspend = hda_codec_pm_suspend,
3004 : : .resume = hda_codec_pm_resume,
3005 : : .freeze = hda_codec_pm_freeze,
3006 : : .thaw = hda_codec_pm_thaw,
3007 : : .poweroff = hda_codec_pm_suspend,
3008 : : .restore = hda_codec_pm_restore,
3009 : : #endif /* CONFIG_PM_SLEEP */
3010 : : SET_RUNTIME_PM_OPS(hda_codec_runtime_suspend, hda_codec_runtime_resume,
3011 : : NULL)
3012 : : };
3013 : :
3014 : : /*
3015 : : * add standard channel maps if not specified
3016 : : */
3017 : 0 : static int add_std_chmaps(struct hda_codec *codec)
3018 : : {
3019 : 0 : struct hda_pcm *pcm;
3020 : 0 : int str, err;
3021 : :
3022 [ # # ]: 0 : list_for_each_entry(pcm, &codec->pcm_list_head, list) {
3023 [ # # ]: 0 : for (str = 0; str < 2; str++) {
3024 : 0 : struct hda_pcm_stream *hinfo = &pcm->stream[str];
3025 : 0 : struct snd_pcm_chmap *chmap;
3026 : 0 : const struct snd_pcm_chmap_elem *elem;
3027 : :
3028 [ # # # # : 0 : if (!pcm->pcm || pcm->own_chmap || !hinfo->substreams)
# # ]
3029 : 0 : continue;
3030 [ # # ]: 0 : elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
3031 : 0 : err = snd_pcm_add_chmap_ctls(pcm->pcm, str, elem,
3032 : 0 : hinfo->channels_max,
3033 : : 0, &chmap);
3034 [ # # ]: 0 : if (err < 0)
3035 : 0 : return err;
3036 : 0 : chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
3037 : : }
3038 : : }
3039 : : return 0;
3040 : : }
3041 : :
3042 : : /* default channel maps for 2.1 speakers;
3043 : : * since HD-audio supports only stereo, odd number channels are omitted
3044 : : */
3045 : : const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
3046 : : { .channels = 2,
3047 : : .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
3048 : : { .channels = 4,
3049 : : .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
3050 : : SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
3051 : : { }
3052 : : };
3053 : : EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
3054 : :
3055 : 0 : int snd_hda_codec_build_controls(struct hda_codec *codec)
3056 : : {
3057 : 0 : int err = 0;
3058 : 0 : hda_exec_init_verbs(codec);
3059 : : /* continue to initialize... */
3060 [ # # ]: 0 : if (codec->patch_ops.init)
3061 : 0 : err = codec->patch_ops.init(codec);
3062 [ # # # # ]: 0 : if (!err && codec->patch_ops.build_controls)
3063 : 0 : err = codec->patch_ops.build_controls(codec);
3064 [ # # ]: 0 : if (err < 0)
3065 : : return err;
3066 : :
3067 : : /* we create chmaps here instead of build_pcms */
3068 : 0 : err = add_std_chmaps(codec);
3069 [ # # ]: 0 : if (err < 0)
3070 : : return err;
3071 : :
3072 [ # # ]: 0 : if (codec->jackpoll_interval)
3073 : 0 : hda_jackpoll_work(&codec->jackpoll_work.work);
3074 : : else
3075 : 0 : snd_hda_jack_report_sync(codec); /* call at the last init point */
3076 : 0 : sync_power_up_states(codec);
3077 : 0 : return 0;
3078 : : }
3079 : : EXPORT_SYMBOL_GPL(snd_hda_codec_build_controls);
3080 : :
3081 : : /*
3082 : : * PCM stuff
3083 : : */
3084 : 0 : static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3085 : : struct hda_codec *codec,
3086 : : struct snd_pcm_substream *substream)
3087 : : {
3088 : 0 : return 0;
3089 : : }
3090 : :
3091 : 0 : static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3092 : : struct hda_codec *codec,
3093 : : unsigned int stream_tag,
3094 : : unsigned int format,
3095 : : struct snd_pcm_substream *substream)
3096 : : {
3097 : 0 : snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3098 : 0 : return 0;
3099 : : }
3100 : :
3101 : 0 : static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3102 : : struct hda_codec *codec,
3103 : : struct snd_pcm_substream *substream)
3104 : : {
3105 : 0 : snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3106 : 0 : return 0;
3107 : : }
3108 : :
3109 : 0 : static int set_pcm_default_values(struct hda_codec *codec,
3110 : : struct hda_pcm_stream *info)
3111 : : {
3112 : 0 : int err;
3113 : :
3114 : : /* query support PCM information from the given NID */
3115 [ # # # # : 0 : if (info->nid && (!info->rates || !info->formats)) {
# # ]
3116 [ # # # # : 0 : err = snd_hda_query_supported_pcm(codec, info->nid,
# # ]
3117 : : info->rates ? NULL : &info->rates,
3118 : : info->formats ? NULL : &info->formats,
3119 : : info->maxbps ? NULL : &info->maxbps);
3120 [ # # ]: 0 : if (err < 0)
3121 : : return err;
3122 : : }
3123 [ # # ]: 0 : if (info->ops.open == NULL)
3124 : 0 : info->ops.open = hda_pcm_default_open_close;
3125 [ # # ]: 0 : if (info->ops.close == NULL)
3126 : 0 : info->ops.close = hda_pcm_default_open_close;
3127 [ # # ]: 0 : if (info->ops.prepare == NULL) {
3128 [ # # ]: 0 : if (snd_BUG_ON(!info->nid))
3129 : : return -EINVAL;
3130 : 0 : info->ops.prepare = hda_pcm_default_prepare;
3131 : : }
3132 [ # # ]: 0 : if (info->ops.cleanup == NULL) {
3133 [ # # ]: 0 : if (snd_BUG_ON(!info->nid))
3134 : : return -EINVAL;
3135 : 0 : info->ops.cleanup = hda_pcm_default_cleanup;
3136 : : }
3137 : : return 0;
3138 : : }
3139 : :
3140 : : /*
3141 : : * codec prepare/cleanup entries
3142 : : */
3143 : : /**
3144 : : * snd_hda_codec_prepare - Prepare a stream
3145 : : * @codec: the HDA codec
3146 : : * @hinfo: PCM information
3147 : : * @stream: stream tag to assign
3148 : : * @format: format id to assign
3149 : : * @substream: PCM substream to assign
3150 : : *
3151 : : * Calls the prepare callback set by the codec with the given arguments.
3152 : : * Clean up the inactive streams when successful.
3153 : : */
3154 : 0 : int snd_hda_codec_prepare(struct hda_codec *codec,
3155 : : struct hda_pcm_stream *hinfo,
3156 : : unsigned int stream,
3157 : : unsigned int format,
3158 : : struct snd_pcm_substream *substream)
3159 : : {
3160 : 0 : int ret;
3161 : 0 : mutex_lock(&codec->bus->prepare_mutex);
3162 [ # # ]: 0 : if (hinfo->ops.prepare)
3163 : 0 : ret = hinfo->ops.prepare(hinfo, codec, stream, format,
3164 : : substream);
3165 : : else
3166 : : ret = -ENODEV;
3167 [ # # ]: 0 : if (ret >= 0)
3168 : 0 : purify_inactive_streams(codec);
3169 : 0 : mutex_unlock(&codec->bus->prepare_mutex);
3170 : 0 : return ret;
3171 : : }
3172 : : EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
3173 : :
3174 : : /**
3175 : : * snd_hda_codec_cleanup - Prepare a stream
3176 : : * @codec: the HDA codec
3177 : : * @hinfo: PCM information
3178 : : * @substream: PCM substream
3179 : : *
3180 : : * Calls the cleanup callback set by the codec with the given arguments.
3181 : : */
3182 : 0 : void snd_hda_codec_cleanup(struct hda_codec *codec,
3183 : : struct hda_pcm_stream *hinfo,
3184 : : struct snd_pcm_substream *substream)
3185 : : {
3186 : 0 : mutex_lock(&codec->bus->prepare_mutex);
3187 [ # # ]: 0 : if (hinfo->ops.cleanup)
3188 : 0 : hinfo->ops.cleanup(hinfo, codec, substream);
3189 : 0 : mutex_unlock(&codec->bus->prepare_mutex);
3190 : 0 : }
3191 : : EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
3192 : :
3193 : : /* global */
3194 : : const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3195 : : "Audio", "SPDIF", "HDMI", "Modem"
3196 : : };
3197 : :
3198 : : /*
3199 : : * get the empty PCM device number to assign
3200 : : */
3201 : 0 : static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type)
3202 : : {
3203 : : /* audio device indices; not linear to keep compatibility */
3204 : : /* assigned to static slots up to dev#10; if more needed, assign
3205 : : * the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y)
3206 : : */
3207 : 0 : static const int audio_idx[HDA_PCM_NTYPES][5] = {
3208 : : [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3209 : : [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3210 : : [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
3211 : : [HDA_PCM_TYPE_MODEM] = { 6, -1 },
3212 : : };
3213 : 0 : int i;
3214 : :
3215 [ # # ]: 0 : if (type >= HDA_PCM_NTYPES) {
3216 : 0 : dev_err(bus->card->dev, "Invalid PCM type %d\n", type);
3217 : 0 : return -EINVAL;
3218 : : }
3219 : :
3220 [ # # ]: 0 : for (i = 0; audio_idx[type][i] >= 0; i++) {
3221 : : #ifndef CONFIG_SND_DYNAMIC_MINORS
3222 [ # # ]: 0 : if (audio_idx[type][i] >= 8)
3223 : : break;
3224 : : #endif
3225 [ # # ]: 0 : if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3226 : 0 : return audio_idx[type][i];
3227 : : }
3228 : :
3229 : : #ifdef CONFIG_SND_DYNAMIC_MINORS
3230 : : /* non-fixed slots starting from 10 */
3231 : : for (i = 10; i < 32; i++) {
3232 : : if (!test_and_set_bit(i, bus->pcm_dev_bits))
3233 : : return i;
3234 : : }
3235 : : #endif
3236 : :
3237 : 0 : dev_warn(bus->card->dev, "Too many %s devices\n",
3238 : : snd_hda_pcm_type_name[type]);
3239 : : #ifndef CONFIG_SND_DYNAMIC_MINORS
3240 : 0 : dev_warn(bus->card->dev,
3241 : : "Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n");
3242 : : #endif
3243 : 0 : return -EAGAIN;
3244 : : }
3245 : :
3246 : : /* call build_pcms ops of the given codec and set up the default parameters */
3247 : 0 : int snd_hda_codec_parse_pcms(struct hda_codec *codec)
3248 : : {
3249 : 0 : struct hda_pcm *cpcm;
3250 : 0 : int err;
3251 : :
3252 [ # # ]: 0 : if (!list_empty(&codec->pcm_list_head))
3253 : : return 0; /* already parsed */
3254 : :
3255 [ # # ]: 0 : if (!codec->patch_ops.build_pcms)
3256 : : return 0;
3257 : :
3258 : 0 : err = codec->patch_ops.build_pcms(codec);
3259 [ # # ]: 0 : if (err < 0) {
3260 : 0 : codec_err(codec, "cannot build PCMs for #%d (error %d)\n",
3261 : : codec->core.addr, err);
3262 : 0 : return err;
3263 : : }
3264 : :
3265 [ # # ]: 0 : list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
3266 : : int stream;
3267 : :
3268 [ # # ]: 0 : for (stream = 0; stream < 2; stream++) {
3269 : 0 : struct hda_pcm_stream *info = &cpcm->stream[stream];
3270 : :
3271 [ # # ]: 0 : if (!info->substreams)
3272 : 0 : continue;
3273 : 0 : err = set_pcm_default_values(codec, info);
3274 [ # # ]: 0 : if (err < 0) {
3275 : 0 : codec_warn(codec,
3276 : : "fail to setup default for PCM %s\n",
3277 : : cpcm->name);
3278 : 0 : return err;
3279 : : }
3280 : : }
3281 : : }
3282 : :
3283 : : return 0;
3284 : : }
3285 : : EXPORT_SYMBOL_GPL(snd_hda_codec_parse_pcms);
3286 : :
3287 : : /* assign all PCMs of the given codec */
3288 : 0 : int snd_hda_codec_build_pcms(struct hda_codec *codec)
3289 : : {
3290 : 0 : struct hda_bus *bus = codec->bus;
3291 : 0 : struct hda_pcm *cpcm;
3292 : 0 : int dev, err;
3293 : :
3294 : 0 : err = snd_hda_codec_parse_pcms(codec);
3295 [ # # ]: 0 : if (err < 0)
3296 : : return err;
3297 : :
3298 : : /* attach a new PCM streams */
3299 [ # # ]: 0 : list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
3300 [ # # ]: 0 : if (cpcm->pcm)
3301 : 0 : continue; /* already attached */
3302 [ # # # # ]: 0 : if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
3303 : 0 : continue; /* no substreams assigned */
3304 : :
3305 : 0 : dev = get_empty_pcm_device(bus, cpcm->pcm_type);
3306 [ # # ]: 0 : if (dev < 0) {
3307 : 0 : cpcm->device = SNDRV_PCM_INVALID_DEVICE;
3308 : 0 : continue; /* no fatal error */
3309 : : }
3310 : 0 : cpcm->device = dev;
3311 : 0 : err = snd_hda_attach_pcm_stream(bus, codec, cpcm);
3312 [ # # ]: 0 : if (err < 0) {
3313 : 0 : codec_err(codec,
3314 : : "cannot attach PCM stream %d for codec #%d\n",
3315 : : dev, codec->core.addr);
3316 : 0 : continue; /* no fatal error */
3317 : : }
3318 : : }
3319 : :
3320 : : return 0;
3321 : : }
3322 : :
3323 : : /**
3324 : : * snd_hda_add_new_ctls - create controls from the array
3325 : : * @codec: the HDA codec
3326 : : * @knew: the array of struct snd_kcontrol_new
3327 : : *
3328 : : * This helper function creates and add new controls in the given array.
3329 : : * The array must be terminated with an empty entry as terminator.
3330 : : *
3331 : : * Returns 0 if successful, or a negative error code.
3332 : : */
3333 : 0 : int snd_hda_add_new_ctls(struct hda_codec *codec,
3334 : : const struct snd_kcontrol_new *knew)
3335 : : {
3336 : 0 : int err;
3337 : :
3338 [ # # ]: 0 : for (; knew->name; knew++) {
3339 : 0 : struct snd_kcontrol *kctl;
3340 : 0 : int addr = 0, idx = 0;
3341 [ # # ]: 0 : if (knew->iface == (__force snd_ctl_elem_iface_t)-1)
3342 : 0 : continue; /* skip this codec private value */
3343 : 0 : for (;;) {
3344 : 0 : kctl = snd_ctl_new1(knew, codec);
3345 [ # # ]: 0 : if (!kctl)
3346 : : return -ENOMEM;
3347 [ # # ]: 0 : if (addr > 0)
3348 : 0 : kctl->id.device = addr;
3349 [ # # ]: 0 : if (idx > 0)
3350 : 0 : kctl->id.index = idx;
3351 : 0 : err = snd_hda_ctl_add(codec, 0, kctl);
3352 [ # # ]: 0 : if (!err)
3353 : : break;
3354 : : /* try first with another device index corresponding to
3355 : : * the codec addr; if it still fails (or it's the
3356 : : * primary codec), then try another control index
3357 : : */
3358 [ # # # # ]: 0 : if (!addr && codec->core.addr)
3359 : 0 : addr = codec->core.addr;
3360 [ # # # # ]: 0 : else if (!idx && !knew->index) {
3361 : 0 : idx = find_empty_mixer_ctl_idx(codec,
3362 : 0 : knew->name, 0);
3363 [ # # ]: 0 : if (idx <= 0)
3364 : 0 : return err;
3365 : : } else
3366 : 0 : return err;
3367 : : }
3368 : : }
3369 : : return 0;
3370 : : }
3371 : : EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
3372 : :
3373 : : #ifdef CONFIG_PM
3374 : 0 : static void codec_set_power_save(struct hda_codec *codec, int delay)
3375 : : {
3376 : 0 : struct device *dev = hda_codec_dev(codec);
3377 : :
3378 [ # # # # ]: 0 : if (delay == 0 && codec->auto_runtime_pm)
3379 : : delay = 3000;
3380 : :
3381 [ # # ]: 0 : if (delay > 0) {
3382 : 0 : pm_runtime_set_autosuspend_delay(dev, delay);
3383 : 0 : pm_runtime_use_autosuspend(dev);
3384 : 0 : pm_runtime_allow(dev);
3385 [ # # # # ]: 0 : if (!pm_runtime_suspended(dev))
3386 : 0 : pm_runtime_mark_last_busy(dev);
3387 : : } else {
3388 : 0 : pm_runtime_dont_use_autosuspend(dev);
3389 : 0 : pm_runtime_forbid(dev);
3390 : : }
3391 : 0 : }
3392 : :
3393 : : /**
3394 : : * snd_hda_set_power_save - reprogram autosuspend for the given delay
3395 : : * @bus: HD-audio bus
3396 : : * @delay: autosuspend delay in msec, 0 = off
3397 : : *
3398 : : * Synchronize the runtime PM autosuspend state from the power_save option.
3399 : : */
3400 : 0 : void snd_hda_set_power_save(struct hda_bus *bus, int delay)
3401 : : {
3402 : 0 : struct hda_codec *c;
3403 : :
3404 [ # # ]: 0 : list_for_each_codec(c, bus)
3405 : 0 : codec_set_power_save(c, delay);
3406 : 0 : }
3407 : : EXPORT_SYMBOL_GPL(snd_hda_set_power_save);
3408 : :
3409 : : /**
3410 : : * snd_hda_check_amp_list_power - Check the amp list and update the power
3411 : : * @codec: HD-audio codec
3412 : : * @check: the object containing an AMP list and the status
3413 : : * @nid: NID to check / update
3414 : : *
3415 : : * Check whether the given NID is in the amp list. If it's in the list,
3416 : : * check the current AMP status, and update the the power-status according
3417 : : * to the mute status.
3418 : : *
3419 : : * This function is supposed to be set or called from the check_power_status
3420 : : * patch ops.
3421 : : */
3422 : 0 : int snd_hda_check_amp_list_power(struct hda_codec *codec,
3423 : : struct hda_loopback_check *check,
3424 : : hda_nid_t nid)
3425 : : {
3426 : 0 : const struct hda_amp_list *p;
3427 : 0 : int ch, v;
3428 : :
3429 [ # # ]: 0 : if (!check->amplist)
3430 : : return 0;
3431 [ # # ]: 0 : for (p = check->amplist; p->nid; p++) {
3432 [ # # ]: 0 : if (p->nid == nid)
3433 : : break;
3434 : : }
3435 [ # # ]: 0 : if (!p->nid)
3436 : : return 0; /* nothing changed */
3437 : :
3438 [ # # ]: 0 : for (p = check->amplist; p->nid; p++) {
3439 [ # # ]: 0 : for (ch = 0; ch < 2; ch++) {
3440 : 0 : v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3441 : : p->idx);
3442 [ # # # # ]: 0 : if (!(v & HDA_AMP_MUTE) && v > 0) {
3443 [ # # ]: 0 : if (!check->power_on) {
3444 : 0 : check->power_on = 1;
3445 : 0 : snd_hda_power_up_pm(codec);
3446 : : }
3447 : 0 : return 1;
3448 : : }
3449 : : }
3450 : : }
3451 [ # # ]: 0 : if (check->power_on) {
3452 : 0 : check->power_on = 0;
3453 : 0 : snd_hda_power_down_pm(codec);
3454 : : }
3455 : : return 0;
3456 : : }
3457 : : EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
3458 : : #endif
3459 : :
3460 : : /*
3461 : : * input MUX helper
3462 : : */
3463 : :
3464 : : /**
3465 : : * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
3466 : : * @imux: imux helper object
3467 : : * @uinfo: pointer to get/store the data
3468 : : */
3469 : 0 : int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3470 : : struct snd_ctl_elem_info *uinfo)
3471 : : {
3472 : 0 : unsigned int index;
3473 : :
3474 : 0 : uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3475 : 0 : uinfo->count = 1;
3476 : 0 : uinfo->value.enumerated.items = imux->num_items;
3477 [ # # ]: 0 : if (!imux->num_items)
3478 : : return 0;
3479 : 0 : index = uinfo->value.enumerated.item;
3480 [ # # ]: 0 : if (index >= imux->num_items)
3481 : 0 : index = imux->num_items - 1;
3482 : 0 : strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3483 : 0 : return 0;
3484 : : }
3485 : : EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
3486 : :
3487 : : /**
3488 : : * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
3489 : : * @codec: the HDA codec
3490 : : * @imux: imux helper object
3491 : : * @ucontrol: pointer to get/store the data
3492 : : * @nid: input mux NID
3493 : : * @cur_val: pointer to get/store the current imux value
3494 : : */
3495 : 0 : int snd_hda_input_mux_put(struct hda_codec *codec,
3496 : : const struct hda_input_mux *imux,
3497 : : struct snd_ctl_elem_value *ucontrol,
3498 : : hda_nid_t nid,
3499 : : unsigned int *cur_val)
3500 : : {
3501 : 0 : unsigned int idx;
3502 : :
3503 [ # # ]: 0 : if (!imux->num_items)
3504 : : return 0;
3505 : 0 : idx = ucontrol->value.enumerated.item[0];
3506 [ # # ]: 0 : if (idx >= imux->num_items)
3507 : 0 : idx = imux->num_items - 1;
3508 [ # # ]: 0 : if (*cur_val == idx)
3509 : : return 0;
3510 : 0 : snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3511 : : imux->items[idx].index);
3512 : 0 : *cur_val = idx;
3513 : 0 : return 1;
3514 : : }
3515 : : EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
3516 : :
3517 : :
3518 : : /**
3519 : : * snd_hda_enum_helper_info - Helper for simple enum ctls
3520 : : * @kcontrol: ctl element
3521 : : * @uinfo: pointer to get/store the data
3522 : : * @num_items: number of enum items
3523 : : * @texts: enum item string array
3524 : : *
3525 : : * process kcontrol info callback of a simple string enum array
3526 : : * when @num_items is 0 or @texts is NULL, assume a boolean enum array
3527 : : */
3528 : 0 : int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
3529 : : struct snd_ctl_elem_info *uinfo,
3530 : : int num_items, const char * const *texts)
3531 : : {
3532 : 0 : static const char * const texts_default[] = {
3533 : : "Disabled", "Enabled"
3534 : : };
3535 : :
3536 [ # # ]: 0 : if (!texts || !num_items) {
3537 : 0 : num_items = 2;
3538 : 0 : texts = texts_default;
3539 : : }
3540 : :
3541 : 0 : return snd_ctl_enum_info(uinfo, 1, num_items, texts);
3542 : : }
3543 : : EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info);
3544 : :
3545 : : /*
3546 : : * Multi-channel / digital-out PCM helper functions
3547 : : */
3548 : :
3549 : : /* setup SPDIF output stream */
3550 : 0 : static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3551 : : unsigned int stream_tag, unsigned int format)
3552 : : {
3553 : 0 : struct hda_spdif_out *spdif;
3554 : 0 : unsigned int curr_fmt;
3555 : 0 : bool reset;
3556 : :
3557 : 0 : spdif = snd_hda_spdif_out_of_nid(codec, nid);
3558 : : /* Add sanity check to pass klockwork check.
3559 : : * This should never happen.
3560 : : */
3561 [ # # # # ]: 0 : if (WARN_ON(spdif == NULL))
3562 : : return;
3563 : :
3564 : 0 : curr_fmt = snd_hda_codec_read(codec, nid, 0,
3565 : : AC_VERB_GET_STREAM_FORMAT, 0);
3566 : 0 : reset = codec->spdif_status_reset &&
3567 [ # # # # : 0 : (spdif->ctls & AC_DIG1_ENABLE) &&
# # ]
3568 : : curr_fmt != format;
3569 : :
3570 : : /* turn off SPDIF if needed; otherwise the IEC958 bits won't be
3571 : : updated */
3572 [ # # ]: 0 : if (reset)
3573 : 0 : set_dig_out_convert(codec, nid,
3574 : 0 : spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
3575 : : -1);
3576 : 0 : snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3577 [ # # ]: 0 : if (codec->slave_dig_outs) {
3578 : : const hda_nid_t *d;
3579 [ # # ]: 0 : for (d = codec->slave_dig_outs; *d; d++)
3580 : 0 : snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3581 : : format);
3582 : : }
3583 : : /* turn on again (if needed) */
3584 [ # # ]: 0 : if (reset)
3585 : 0 : set_dig_out_convert(codec, nid,
3586 : 0 : spdif->ctls & 0xff, -1);
3587 : : }
3588 : :
3589 : 0 : static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3590 : : {
3591 : 0 : snd_hda_codec_cleanup_stream(codec, nid);
3592 [ # # ]: 0 : if (codec->slave_dig_outs) {
3593 : : const hda_nid_t *d;
3594 [ # # ]: 0 : for (d = codec->slave_dig_outs; *d; d++)
3595 : 0 : snd_hda_codec_cleanup_stream(codec, *d);
3596 : : }
3597 : 0 : }
3598 : :
3599 : : /**
3600 : : * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
3601 : : * @codec: the HDA codec
3602 : : * @mout: hda_multi_out object
3603 : : */
3604 : 0 : int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3605 : : struct hda_multi_out *mout)
3606 : : {
3607 : 0 : mutex_lock(&codec->spdif_mutex);
3608 [ # # ]: 0 : if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3609 : : /* already opened as analog dup; reset it once */
3610 : 0 : cleanup_dig_out_stream(codec, mout->dig_out_nid);
3611 : 0 : mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3612 : 0 : mutex_unlock(&codec->spdif_mutex);
3613 : 0 : return 0;
3614 : : }
3615 : : EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
3616 : :
3617 : : /**
3618 : : * snd_hda_multi_out_dig_prepare - prepare the digital out stream
3619 : : * @codec: the HDA codec
3620 : : * @mout: hda_multi_out object
3621 : : * @stream_tag: stream tag to assign
3622 : : * @format: format id to assign
3623 : : * @substream: PCM substream to assign
3624 : : */
3625 : 0 : int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3626 : : struct hda_multi_out *mout,
3627 : : unsigned int stream_tag,
3628 : : unsigned int format,
3629 : : struct snd_pcm_substream *substream)
3630 : : {
3631 : 0 : mutex_lock(&codec->spdif_mutex);
3632 : 0 : setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3633 : 0 : mutex_unlock(&codec->spdif_mutex);
3634 : 0 : return 0;
3635 : : }
3636 : : EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
3637 : :
3638 : : /**
3639 : : * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
3640 : : * @codec: the HDA codec
3641 : : * @mout: hda_multi_out object
3642 : : */
3643 : 0 : int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3644 : : struct hda_multi_out *mout)
3645 : : {
3646 : 0 : mutex_lock(&codec->spdif_mutex);
3647 : 0 : cleanup_dig_out_stream(codec, mout->dig_out_nid);
3648 : 0 : mutex_unlock(&codec->spdif_mutex);
3649 : 0 : return 0;
3650 : : }
3651 : : EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
3652 : :
3653 : : /**
3654 : : * snd_hda_multi_out_dig_close - release the digital out stream
3655 : : * @codec: the HDA codec
3656 : : * @mout: hda_multi_out object
3657 : : */
3658 : 0 : int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3659 : : struct hda_multi_out *mout)
3660 : : {
3661 : 0 : mutex_lock(&codec->spdif_mutex);
3662 : 0 : mout->dig_out_used = 0;
3663 : 0 : mutex_unlock(&codec->spdif_mutex);
3664 : 0 : return 0;
3665 : : }
3666 : : EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
3667 : :
3668 : : /**
3669 : : * snd_hda_multi_out_analog_open - open analog outputs
3670 : : * @codec: the HDA codec
3671 : : * @mout: hda_multi_out object
3672 : : * @substream: PCM substream to assign
3673 : : * @hinfo: PCM information to assign
3674 : : *
3675 : : * Open analog outputs and set up the hw-constraints.
3676 : : * If the digital outputs can be opened as slave, open the digital
3677 : : * outputs, too.
3678 : : */
3679 : 0 : int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3680 : : struct hda_multi_out *mout,
3681 : : struct snd_pcm_substream *substream,
3682 : : struct hda_pcm_stream *hinfo)
3683 : : {
3684 : 0 : struct snd_pcm_runtime *runtime = substream->runtime;
3685 : 0 : runtime->hw.channels_max = mout->max_channels;
3686 [ # # ]: 0 : if (mout->dig_out_nid) {
3687 [ # # ]: 0 : if (!mout->analog_rates) {
3688 : 0 : mout->analog_rates = hinfo->rates;
3689 : 0 : mout->analog_formats = hinfo->formats;
3690 : 0 : mout->analog_maxbps = hinfo->maxbps;
3691 : : } else {
3692 : 0 : runtime->hw.rates = mout->analog_rates;
3693 : 0 : runtime->hw.formats = mout->analog_formats;
3694 : 0 : hinfo->maxbps = mout->analog_maxbps;
3695 : : }
3696 [ # # ]: 0 : if (!mout->spdif_rates) {
3697 : 0 : snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3698 : : &mout->spdif_rates,
3699 : : &mout->spdif_formats,
3700 : : &mout->spdif_maxbps);
3701 : : }
3702 : 0 : mutex_lock(&codec->spdif_mutex);
3703 [ # # ]: 0 : if (mout->share_spdif) {
3704 [ # # ]: 0 : if ((runtime->hw.rates & mout->spdif_rates) &&
3705 [ # # ]: 0 : (runtime->hw.formats & mout->spdif_formats)) {
3706 : 0 : runtime->hw.rates &= mout->spdif_rates;
3707 : 0 : runtime->hw.formats &= mout->spdif_formats;
3708 [ # # ]: 0 : if (mout->spdif_maxbps < hinfo->maxbps)
3709 : 0 : hinfo->maxbps = mout->spdif_maxbps;
3710 : : } else {
3711 : 0 : mout->share_spdif = 0;
3712 : : /* FIXME: need notify? */
3713 : : }
3714 : : }
3715 : 0 : mutex_unlock(&codec->spdif_mutex);
3716 : : }
3717 : 0 : return snd_pcm_hw_constraint_step(substream->runtime, 0,
3718 : : SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3719 : : }
3720 : : EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
3721 : :
3722 : : /**
3723 : : * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
3724 : : * @codec: the HDA codec
3725 : : * @mout: hda_multi_out object
3726 : : * @stream_tag: stream tag to assign
3727 : : * @format: format id to assign
3728 : : * @substream: PCM substream to assign
3729 : : *
3730 : : * Set up the i/o for analog out.
3731 : : * When the digital out is available, copy the front out to digital out, too.
3732 : : */
3733 : 0 : int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3734 : : struct hda_multi_out *mout,
3735 : : unsigned int stream_tag,
3736 : : unsigned int format,
3737 : : struct snd_pcm_substream *substream)
3738 : : {
3739 : 0 : const hda_nid_t *nids = mout->dac_nids;
3740 : 0 : int chs = substream->runtime->channels;
3741 : 0 : struct hda_spdif_out *spdif;
3742 : 0 : int i;
3743 : :
3744 : 0 : mutex_lock(&codec->spdif_mutex);
3745 : 0 : spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
3746 [ # # # # ]: 0 : if (mout->dig_out_nid && mout->share_spdif &&
3747 [ # # ]: 0 : mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3748 [ # # # # ]: 0 : if (chs == 2 && spdif != NULL &&
3749 : 0 : snd_hda_is_supported_format(codec, mout->dig_out_nid,
3750 : 0 : format) &&
3751 [ # # ]: 0 : !(spdif->status & IEC958_AES0_NONAUDIO)) {
3752 : 0 : mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3753 : 0 : setup_dig_out_stream(codec, mout->dig_out_nid,
3754 : : stream_tag, format);
3755 : : } else {
3756 : 0 : mout->dig_out_used = 0;
3757 : 0 : cleanup_dig_out_stream(codec, mout->dig_out_nid);
3758 : : }
3759 : : }
3760 : 0 : mutex_unlock(&codec->spdif_mutex);
3761 : :
3762 : : /* front */
3763 : 0 : snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3764 : : 0, format);
3765 [ # # ]: 0 : if (!mout->no_share_stream &&
3766 [ # # # # ]: 0 : mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3767 : : /* headphone out will just decode front left/right (stereo) */
3768 : 0 : snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3769 : : 0, format);
3770 : : /* extra outputs copied from front */
3771 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
3772 [ # # # # ]: 0 : if (!mout->no_share_stream && mout->hp_out_nid[i])
3773 : 0 : snd_hda_codec_setup_stream(codec,
3774 : : mout->hp_out_nid[i],
3775 : : stream_tag, 0, format);
3776 : :
3777 : : /* surrounds */
3778 [ # # ]: 0 : for (i = 1; i < mout->num_dacs; i++) {
3779 [ # # ]: 0 : if (chs >= (i + 1) * 2) /* independent out */
3780 : 0 : snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3781 : : i * 2, format);
3782 [ # # ]: 0 : else if (!mout->no_share_stream) /* copy front */
3783 : 0 : snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3784 : : 0, format);
3785 : : }
3786 : :
3787 : : /* extra surrounds */
3788 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) {
3789 : 0 : int ch = 0;
3790 [ # # ]: 0 : if (!mout->extra_out_nid[i])
3791 : : break;
3792 [ # # ]: 0 : if (chs >= (i + 1) * 2)
3793 : 0 : ch = i * 2;
3794 [ # # ]: 0 : else if (!mout->no_share_stream)
3795 : : break;
3796 : 0 : snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i],
3797 : : stream_tag, ch, format);
3798 : : }
3799 : :
3800 : 0 : return 0;
3801 : : }
3802 : : EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
3803 : :
3804 : : /**
3805 : : * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
3806 : : * @codec: the HDA codec
3807 : : * @mout: hda_multi_out object
3808 : : */
3809 : 0 : int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3810 : : struct hda_multi_out *mout)
3811 : : {
3812 : 0 : const hda_nid_t *nids = mout->dac_nids;
3813 : 0 : int i;
3814 : :
3815 [ # # ]: 0 : for (i = 0; i < mout->num_dacs; i++)
3816 : 0 : snd_hda_codec_cleanup_stream(codec, nids[i]);
3817 [ # # ]: 0 : if (mout->hp_nid)
3818 : 0 : snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3819 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
3820 [ # # ]: 0 : if (mout->hp_out_nid[i])
3821 : 0 : snd_hda_codec_cleanup_stream(codec,
3822 : : mout->hp_out_nid[i]);
3823 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3824 [ # # ]: 0 : if (mout->extra_out_nid[i])
3825 : 0 : snd_hda_codec_cleanup_stream(codec,
3826 : : mout->extra_out_nid[i]);
3827 : 0 : mutex_lock(&codec->spdif_mutex);
3828 [ # # # # ]: 0 : if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3829 : 0 : cleanup_dig_out_stream(codec, mout->dig_out_nid);
3830 : 0 : mout->dig_out_used = 0;
3831 : : }
3832 : 0 : mutex_unlock(&codec->spdif_mutex);
3833 : 0 : return 0;
3834 : : }
3835 : : EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
3836 : :
3837 : : /**
3838 : : * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
3839 : : * @codec: the HDA codec
3840 : : * @pin: referred pin NID
3841 : : *
3842 : : * Guess the suitable VREF pin bits to be set as the pin-control value.
3843 : : * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
3844 : : */
3845 : 0 : unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
3846 : : {
3847 : 0 : unsigned int pincap;
3848 : 0 : unsigned int oldval;
3849 : 0 : oldval = snd_hda_codec_read(codec, pin, 0,
3850 : : AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3851 : 0 : pincap = snd_hda_query_pin_caps(codec, pin);
3852 : 0 : pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
3853 : : /* Exception: if the default pin setup is vref50, we give it priority */
3854 [ # # # # ]: 0 : if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
3855 : : return AC_PINCTL_VREF_80;
3856 [ # # ]: 0 : else if (pincap & AC_PINCAP_VREF_50)
3857 : : return AC_PINCTL_VREF_50;
3858 [ # # ]: 0 : else if (pincap & AC_PINCAP_VREF_100)
3859 : : return AC_PINCTL_VREF_100;
3860 [ # # ]: 0 : else if (pincap & AC_PINCAP_VREF_GRD)
3861 : 0 : return AC_PINCTL_VREF_GRD;
3862 : : return AC_PINCTL_VREF_HIZ;
3863 : : }
3864 : : EXPORT_SYMBOL_GPL(snd_hda_get_default_vref);
3865 : :
3866 : : /**
3867 : : * snd_hda_correct_pin_ctl - correct the pin ctl value for matching with the pin cap
3868 : : * @codec: the HDA codec
3869 : : * @pin: referred pin NID
3870 : : * @val: pin ctl value to audit
3871 : : */
3872 : 0 : unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
3873 : : hda_nid_t pin, unsigned int val)
3874 : : {
3875 : 0 : static const unsigned int cap_lists[][2] = {
3876 : : { AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
3877 : : { AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
3878 : : { AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
3879 : : { AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
3880 : : };
3881 : 0 : unsigned int cap;
3882 : :
3883 [ # # ]: 0 : if (!val)
3884 : : return 0;
3885 : 0 : cap = snd_hda_query_pin_caps(codec, pin);
3886 [ # # ]: 0 : if (!cap)
3887 : : return val; /* don't know what to do... */
3888 : :
3889 [ # # ]: 0 : if (val & AC_PINCTL_OUT_EN) {
3890 [ # # ]: 0 : if (!(cap & AC_PINCAP_OUT))
3891 : 0 : val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3892 [ # # # # ]: 0 : else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
3893 : 0 : val &= ~AC_PINCTL_HP_EN;
3894 : : }
3895 : :
3896 [ # # ]: 0 : if (val & AC_PINCTL_IN_EN) {
3897 [ # # ]: 0 : if (!(cap & AC_PINCAP_IN))
3898 : 0 : val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
3899 : : else {
3900 : 0 : unsigned int vcap, vref;
3901 : 0 : int i;
3902 : 0 : vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
3903 : 0 : vref = val & AC_PINCTL_VREFEN;
3904 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
3905 [ # # ]: 0 : if (vref == cap_lists[i][0] &&
3906 [ # # ]: 0 : !(vcap & cap_lists[i][1])) {
3907 [ # # ]: 0 : if (i == ARRAY_SIZE(cap_lists) - 1)
3908 : : vref = AC_PINCTL_VREF_HIZ;
3909 : : else
3910 : 0 : vref = cap_lists[i + 1][0];
3911 : : }
3912 : : }
3913 : 0 : val &= ~AC_PINCTL_VREFEN;
3914 : 0 : val |= vref;
3915 : : }
3916 : : }
3917 : :
3918 : : return val;
3919 : : }
3920 : : EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl);
3921 : :
3922 : : /**
3923 : : * _snd_hda_pin_ctl - Helper to set pin ctl value
3924 : : * @codec: the HDA codec
3925 : : * @pin: referred pin NID
3926 : : * @val: pin control value to set
3927 : : * @cached: access over codec pinctl cache or direct write
3928 : : *
3929 : : * This function is a helper to set a pin ctl value more safely.
3930 : : * It corrects the pin ctl value via snd_hda_correct_pin_ctl(), stores the
3931 : : * value in pin target array via snd_hda_codec_set_pin_target(), then
3932 : : * actually writes the value via either snd_hda_codec_write_cache() or
3933 : : * snd_hda_codec_write() depending on @cached flag.
3934 : : */
3935 : 0 : int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
3936 : : unsigned int val, bool cached)
3937 : : {
3938 : 0 : val = snd_hda_correct_pin_ctl(codec, pin, val);
3939 : 0 : snd_hda_codec_set_pin_target(codec, pin, val);
3940 [ # # ]: 0 : if (cached)
3941 : 0 : return snd_hda_codec_write_cache(codec, pin, 0,
3942 : : AC_VERB_SET_PIN_WIDGET_CONTROL, val);
3943 : : else
3944 : 0 : return snd_hda_codec_write(codec, pin, 0,
3945 : : AC_VERB_SET_PIN_WIDGET_CONTROL, val);
3946 : : }
3947 : : EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl);
3948 : :
3949 : : /**
3950 : : * snd_hda_add_imux_item - Add an item to input_mux
3951 : : * @codec: the HDA codec
3952 : : * @imux: imux helper object
3953 : : * @label: the name of imux item to assign
3954 : : * @index: index number of imux item to assign
3955 : : * @type_idx: pointer to store the resultant label index
3956 : : *
3957 : : * When the same label is used already in the existing items, the number
3958 : : * suffix is appended to the label. This label index number is stored
3959 : : * to type_idx when non-NULL pointer is given.
3960 : : */
3961 : 0 : int snd_hda_add_imux_item(struct hda_codec *codec,
3962 : : struct hda_input_mux *imux, const char *label,
3963 : : int index, int *type_idx)
3964 : : {
3965 : 0 : int i, label_idx = 0;
3966 [ # # ]: 0 : if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
3967 : 0 : codec_err(codec, "hda_codec: Too many imux items!\n");
3968 : 0 : return -EINVAL;
3969 : : }
3970 [ # # ]: 0 : for (i = 0; i < imux->num_items; i++) {
3971 [ # # ]: 0 : if (!strncmp(label, imux->items[i].label, strlen(label)))
3972 : 0 : label_idx++;
3973 : : }
3974 [ # # ]: 0 : if (type_idx)
3975 : 0 : *type_idx = label_idx;
3976 [ # # ]: 0 : if (label_idx > 0)
3977 : 0 : snprintf(imux->items[imux->num_items].label,
3978 : : sizeof(imux->items[imux->num_items].label),
3979 : : "%s %d", label, label_idx);
3980 : : else
3981 : 0 : strlcpy(imux->items[imux->num_items].label, label,
3982 : : sizeof(imux->items[imux->num_items].label));
3983 : 0 : imux->items[imux->num_items].index = index;
3984 : 0 : imux->num_items++;
3985 : 0 : return 0;
3986 : : }
3987 : : EXPORT_SYMBOL_GPL(snd_hda_add_imux_item);
3988 : :
3989 : : /**
3990 : : * snd_hda_bus_reset_codecs - Reset the bus
3991 : : * @bus: HD-audio bus
3992 : : */
3993 : 0 : void snd_hda_bus_reset_codecs(struct hda_bus *bus)
3994 : : {
3995 : 0 : struct hda_codec *codec;
3996 : :
3997 [ # # ]: 0 : list_for_each_codec(codec, bus) {
3998 : : /* FIXME: maybe a better way needed for forced reset */
3999 [ # # ]: 0 : if (current_work() != &codec->jackpoll_work.work)
4000 : 0 : cancel_delayed_work_sync(&codec->jackpoll_work);
4001 : : #ifdef CONFIG_PM
4002 [ # # # # ]: 0 : if (hda_codec_is_power_on(codec)) {
4003 : 0 : hda_call_codec_suspend(codec);
4004 : 0 : hda_call_codec_resume(codec);
4005 : : }
4006 : : #endif
4007 : : }
4008 : 0 : }
4009 : :
4010 : : /**
4011 : : * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4012 : : * @pcm: PCM caps bits
4013 : : * @buf: the string buffer to write
4014 : : * @buflen: the max buffer length
4015 : : *
4016 : : * used by hda_proc.c and hda_eld.c
4017 : : */
4018 : 0 : void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4019 : : {
4020 : 0 : static const unsigned int bits[] = { 8, 16, 20, 24, 32 };
4021 : 0 : int i, j;
4022 : :
4023 [ # # ]: 0 : for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4024 [ # # ]: 0 : if (pcm & (AC_SUPPCM_BITS_8 << i))
4025 : 0 : j += scnprintf(buf + j, buflen - j, " %d", bits[i]);
4026 : :
4027 : 0 : buf[j] = '\0'; /* necessary when j == 0 */
4028 : 0 : }
4029 : : EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
4030 : :
4031 : : MODULE_DESCRIPTION("HDA codec core");
4032 : : MODULE_LICENSE("GPL");
|
