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