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