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