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  */
snd_hda_get_jack_location(u32 cfg)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  */
snd_hda_get_jack_connectivity(u32 cfg)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  */
snd_hda_get_jack_type(u32 cfg)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  */
codec_exec_verb(struct hdac_device * dev,unsigned int cmd,unsigned int flags,unsigned int * res)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  */
snd_hda_codec_read(struct hda_codec * codec,hda_nid_t nid,int flags,unsigned int verb,unsigned int parm)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  */
snd_hda_codec_write(struct hda_codec * codec,hda_nid_t nid,int flags,unsigned int verb,unsigned int parm)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  */
snd_hda_sequence_write(struct hda_codec * codec,const struct hda_verb * seq)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 *
lookup_conn_list(struct hda_codec * codec,hda_nid_t nid)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 
add_conn_list(struct hda_codec * codec,hda_nid_t nid,int len,const hda_nid_t * list)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 
remove_conn_list(struct hda_codec * codec)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 */
read_and_add_raw_conns(struct hda_codec * codec,hda_nid_t nid)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  */
snd_hda_get_conn_list(struct hda_codec * codec,hda_nid_t nid,const hda_nid_t ** listp)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  */
snd_hda_get_connections(struct hda_codec * codec,hda_nid_t nid,hda_nid_t * conn_list,int max_conns)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  */
snd_hda_override_conn_list(struct hda_codec * codec,hda_nid_t nid,int len,const hda_nid_t * list)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  */
snd_hda_get_conn_index(struct hda_codec * codec,hda_nid_t mux,hda_nid_t nid,int recursive)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 */
get_num_devices(struct hda_codec * codec,hda_nid_t nid)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_hdac_read_parm_uncached(&codec->core, 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  */
snd_hda_get_devices(struct hda_codec * codec,hda_nid_t nid,u8 * dev_list,int max_devices)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  */
snd_hda_bus_free(struct hda_bus * bus)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 
snd_hda_bus_dev_free(struct snd_device * device)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 
snd_hda_bus_dev_disconnect(struct snd_device * device)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 */
_hda_bus_command(struct hdac_bus * _bus,unsigned int cmd)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 
_hda_bus_get_response(struct hdac_bus * _bus,unsigned int addr,unsigned int * res)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  */
snd_hda_bus_new(struct snd_card * card,struct hda_bus ** busp)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  */
read_widget_caps(struct hda_codec * codec,hda_nid_t fg_node)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 */
read_pin_defaults(struct hda_codec * codec)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 */
look_up_pincfg(struct hda_codec * codec,struct snd_array * array,hda_nid_t 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  */
snd_hda_add_pincfg(struct hda_codec * codec,struct snd_array * list,hda_nid_t nid,unsigned int cfg)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  */
snd_hda_codec_set_pincfg(struct hda_codec * codec,hda_nid_t nid,unsigned int cfg)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  */
snd_hda_codec_get_pincfg(struct hda_codec * codec,hda_nid_t nid)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  */
snd_hda_codec_set_pin_target(struct hda_codec * codec,hda_nid_t nid,unsigned int val)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  */
snd_hda_codec_get_pin_target(struct hda_codec * codec,hda_nid_t nid)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  */
snd_hda_shutup_pins(struct hda_codec * codec)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() */
restore_shutup_pins(struct hda_codec * codec)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 
hda_jackpoll_work(struct work_struct * work)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 */
free_init_pincfgs(struct hda_codec * codec)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 *
get_hda_cvt_setup(struct hda_codec * codec,hda_nid_t nid)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  */
release_pcm(struct kref * kref)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 
snd_hda_codec_pcm_put(struct hda_pcm * pcm)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 
snd_hda_codec_pcm_new(struct hda_codec * codec,const char * fmt,...)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  */
codec_release_pcms(struct hda_codec * codec)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 
snd_hda_codec_cleanup_for_unbind(struct hda_codec * codec)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 */
snd_hda_codec_register(struct hda_codec * codec)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 
snd_hda_codec_dev_register(struct snd_device * device)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 
snd_hda_codec_dev_disconnect(struct snd_device * device)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 
snd_hda_codec_dev_free(struct snd_device * device)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 
snd_hda_codec_dev_release(struct device * dev)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  */
snd_hda_codec_new(struct hda_bus * bus,struct snd_card * card,unsigned int codec_addr,struct hda_codec ** codecp)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  */
snd_hda_codec_update_widgets(struct hda_codec * codec)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 */
update_pcm_stream_id(struct hda_codec * codec,struct hda_cvt_setup * p,hda_nid_t nid,u32 stream_tag,int channel_id)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 */
update_pcm_format(struct hda_codec * codec,struct hda_cvt_setup * p,hda_nid_t nid,int format)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  */
snd_hda_codec_setup_stream(struct hda_codec * codec,hda_nid_t nid,u32 stream_tag,int channel_id,int format)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  */
__snd_hda_codec_cleanup_stream(struct hda_codec * codec,hda_nid_t nid,int do_now)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 
really_cleanup_stream(struct hda_codec * codec,struct hda_cvt_setup * q)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 */
purify_inactive_streams(struct hda_codec * codec)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 */
hda_cleanup_all_streams(struct hda_codec * codec)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  */
query_amp_caps(struct hda_codec * codec,hda_nid_t nid,int direction)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  */
snd_hda_check_amp_caps(struct hda_codec * codec,hda_nid_t nid,int dir,unsigned int bits)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  */
snd_hda_override_amp_caps(struct hda_codec * codec,hda_nid_t nid,int dir,unsigned int caps)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_update - update the AMP mono value
1380  * @codec: HD-audio codec
1381  * @nid: NID to read the AMP value
1382  * @ch: channel to update (0 or 1)
1383  * @dir: #HDA_INPUT or #HDA_OUTPUT
1384  * @idx: the index value (only for input direction)
1385  * @mask: bit mask to set
1386  * @val: the bits value to set
1387  *
1388  * Update the AMP values for the given channel, direction and index.
1389  */
snd_hda_codec_amp_update(struct hda_codec * codec,hda_nid_t nid,int ch,int dir,int idx,int mask,int val)1390 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid,
1391 			     int ch, int dir, int idx, int mask, int val)
1392 {
1393 	unsigned int cmd = snd_hdac_regmap_encode_amp(nid, ch, dir, idx);
1394 
1395 	/* enable fake mute if no h/w mute but min=mute */
1396 	if ((query_amp_caps(codec, nid, dir) &
1397 	     (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) == AC_AMPCAP_MIN_MUTE)
1398 		cmd |= AC_AMP_FAKE_MUTE;
1399 	return snd_hdac_regmap_update_raw(&codec->core, cmd, mask, val);
1400 }
1401 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update);
1402 
1403 /**
1404  * snd_hda_codec_amp_stereo - update the AMP stereo values
1405  * @codec: HD-audio codec
1406  * @nid: NID to read the AMP value
1407  * @direction: #HDA_INPUT or #HDA_OUTPUT
1408  * @idx: the index value (only for input direction)
1409  * @mask: bit mask to set
1410  * @val: the bits value to set
1411  *
1412  * Update the AMP values like snd_hda_codec_amp_update(), but for a
1413  * stereo widget with the same mask and value.
1414  */
snd_hda_codec_amp_stereo(struct hda_codec * codec,hda_nid_t nid,int direction,int idx,int mask,int val)1415 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1416 			     int direction, int idx, int mask, int val)
1417 {
1418 	int ch, ret = 0;
1419 
1420 	if (snd_BUG_ON(mask & ~0xff))
1421 		mask &= 0xff;
1422 	for (ch = 0; ch < 2; ch++)
1423 		ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1424 						idx, mask, val);
1425 	return ret;
1426 }
1427 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
1428 
1429 /**
1430  * snd_hda_codec_amp_init - initialize the AMP value
1431  * @codec: the HDA codec
1432  * @nid: NID to read the AMP value
1433  * @ch: channel (left=0 or right=1)
1434  * @dir: #HDA_INPUT or #HDA_OUTPUT
1435  * @idx: the index value (only for input direction)
1436  * @mask: bit mask to set
1437  * @val: the bits value to set
1438  *
1439  * Works like snd_hda_codec_amp_update() but it writes the value only at
1440  * the first access.  If the amp was already initialized / updated beforehand,
1441  * this does nothing.
1442  */
snd_hda_codec_amp_init(struct hda_codec * codec,hda_nid_t nid,int ch,int dir,int idx,int mask,int val)1443 int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
1444 			   int dir, int idx, int mask, int val)
1445 {
1446 	int orig;
1447 
1448 	if (!codec->core.regmap)
1449 		return -EINVAL;
1450 	regcache_cache_only(codec->core.regmap, true);
1451 	orig = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1452 	regcache_cache_only(codec->core.regmap, false);
1453 	if (orig >= 0)
1454 		return 0;
1455 	return snd_hda_codec_amp_update(codec, nid, ch, dir, idx, mask, val);
1456 }
1457 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init);
1458 
1459 /**
1460  * snd_hda_codec_amp_init_stereo - initialize the stereo AMP value
1461  * @codec: the HDA codec
1462  * @nid: NID to read the AMP value
1463  * @dir: #HDA_INPUT or #HDA_OUTPUT
1464  * @idx: the index value (only for input direction)
1465  * @mask: bit mask to set
1466  * @val: the bits value to set
1467  *
1468  * Call snd_hda_codec_amp_init() for both stereo channels.
1469  */
snd_hda_codec_amp_init_stereo(struct hda_codec * codec,hda_nid_t nid,int dir,int idx,int mask,int val)1470 int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
1471 				  int dir, int idx, int mask, int val)
1472 {
1473 	int ch, ret = 0;
1474 
1475 	if (snd_BUG_ON(mask & ~0xff))
1476 		mask &= 0xff;
1477 	for (ch = 0; ch < 2; ch++)
1478 		ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
1479 					      idx, mask, val);
1480 	return ret;
1481 }
1482 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo);
1483 
get_amp_max_value(struct hda_codec * codec,hda_nid_t nid,int dir,unsigned int ofs)1484 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1485 			     unsigned int ofs)
1486 {
1487 	u32 caps = query_amp_caps(codec, nid, dir);
1488 	/* get num steps */
1489 	caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1490 	if (ofs < caps)
1491 		caps -= ofs;
1492 	return caps;
1493 }
1494 
1495 /**
1496  * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1497  * @kcontrol: referred ctl element
1498  * @uinfo: pointer to get/store the data
1499  *
1500  * The control element is supposed to have the private_value field
1501  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1502  */
snd_hda_mixer_amp_volume_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)1503 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1504 				  struct snd_ctl_elem_info *uinfo)
1505 {
1506 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1507 	u16 nid = get_amp_nid(kcontrol);
1508 	u8 chs = get_amp_channels(kcontrol);
1509 	int dir = get_amp_direction(kcontrol);
1510 	unsigned int ofs = get_amp_offset(kcontrol);
1511 
1512 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1513 	uinfo->count = chs == 3 ? 2 : 1;
1514 	uinfo->value.integer.min = 0;
1515 	uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1516 	if (!uinfo->value.integer.max) {
1517 		codec_warn(codec,
1518 			   "num_steps = 0 for NID=0x%x (ctl = %s)\n",
1519 			   nid, kcontrol->id.name);
1520 		return -EINVAL;
1521 	}
1522 	return 0;
1523 }
1524 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
1525 
1526 
1527 static inline unsigned int
read_amp_value(struct hda_codec * codec,hda_nid_t nid,int ch,int dir,int idx,unsigned int ofs)1528 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1529 	       int ch, int dir, int idx, unsigned int ofs)
1530 {
1531 	unsigned int val;
1532 	val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1533 	val &= HDA_AMP_VOLMASK;
1534 	if (val >= ofs)
1535 		val -= ofs;
1536 	else
1537 		val = 0;
1538 	return val;
1539 }
1540 
1541 static inline int
update_amp_value(struct hda_codec * codec,hda_nid_t nid,int ch,int dir,int idx,unsigned int ofs,unsigned int val)1542 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1543 		 int ch, int dir, int idx, unsigned int ofs,
1544 		 unsigned int val)
1545 {
1546 	unsigned int maxval;
1547 
1548 	if (val > 0)
1549 		val += ofs;
1550 	/* ofs = 0: raw max value */
1551 	maxval = get_amp_max_value(codec, nid, dir, 0);
1552 	if (val > maxval)
1553 		val = maxval;
1554 	return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1555 					HDA_AMP_VOLMASK, val);
1556 }
1557 
1558 /**
1559  * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1560  * @kcontrol: ctl element
1561  * @ucontrol: pointer to get/store the data
1562  *
1563  * The control element is supposed to have the private_value field
1564  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1565  */
snd_hda_mixer_amp_volume_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1566 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1567 				 struct snd_ctl_elem_value *ucontrol)
1568 {
1569 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1570 	hda_nid_t nid = get_amp_nid(kcontrol);
1571 	int chs = get_amp_channels(kcontrol);
1572 	int dir = get_amp_direction(kcontrol);
1573 	int idx = get_amp_index(kcontrol);
1574 	unsigned int ofs = get_amp_offset(kcontrol);
1575 	long *valp = ucontrol->value.integer.value;
1576 
1577 	if (chs & 1)
1578 		*valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1579 	if (chs & 2)
1580 		*valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1581 	return 0;
1582 }
1583 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
1584 
1585 /**
1586  * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1587  * @kcontrol: ctl element
1588  * @ucontrol: pointer to get/store the data
1589  *
1590  * The control element is supposed to have the private_value field
1591  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1592  */
snd_hda_mixer_amp_volume_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1593 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1594 				 struct snd_ctl_elem_value *ucontrol)
1595 {
1596 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1597 	hda_nid_t nid = get_amp_nid(kcontrol);
1598 	int chs = get_amp_channels(kcontrol);
1599 	int dir = get_amp_direction(kcontrol);
1600 	int idx = get_amp_index(kcontrol);
1601 	unsigned int ofs = get_amp_offset(kcontrol);
1602 	long *valp = ucontrol->value.integer.value;
1603 	int change = 0;
1604 
1605 	if (chs & 1) {
1606 		change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1607 		valp++;
1608 	}
1609 	if (chs & 2)
1610 		change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1611 	return change;
1612 }
1613 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
1614 
1615 /**
1616  * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
1617  * @kcontrol: ctl element
1618  * @op_flag: operation flag
1619  * @size: byte size of input TLV
1620  * @_tlv: TLV data
1621  *
1622  * The control element is supposed to have the private_value field
1623  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1624  */
snd_hda_mixer_amp_tlv(struct snd_kcontrol * kcontrol,int op_flag,unsigned int size,unsigned int __user * _tlv)1625 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1626 			  unsigned int size, unsigned int __user *_tlv)
1627 {
1628 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1629 	hda_nid_t nid = get_amp_nid(kcontrol);
1630 	int dir = get_amp_direction(kcontrol);
1631 	unsigned int ofs = get_amp_offset(kcontrol);
1632 	bool min_mute = get_amp_min_mute(kcontrol);
1633 	u32 caps, val1, val2;
1634 
1635 	if (size < 4 * sizeof(unsigned int))
1636 		return -ENOMEM;
1637 	caps = query_amp_caps(codec, nid, dir);
1638 	val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1639 	val2 = (val2 + 1) * 25;
1640 	val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1641 	val1 += ofs;
1642 	val1 = ((int)val1) * ((int)val2);
1643 	if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
1644 		val2 |= TLV_DB_SCALE_MUTE;
1645 	if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1646 		return -EFAULT;
1647 	if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1648 		return -EFAULT;
1649 	if (put_user(val1, _tlv + 2))
1650 		return -EFAULT;
1651 	if (put_user(val2, _tlv + 3))
1652 		return -EFAULT;
1653 	return 0;
1654 }
1655 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
1656 
1657 /**
1658  * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1659  * @codec: HD-audio codec
1660  * @nid: NID of a reference widget
1661  * @dir: #HDA_INPUT or #HDA_OUTPUT
1662  * @tlv: TLV data to be stored, at least 4 elements
1663  *
1664  * Set (static) TLV data for a virtual master volume using the AMP caps
1665  * obtained from the reference NID.
1666  * The volume range is recalculated as if the max volume is 0dB.
1667  */
snd_hda_set_vmaster_tlv(struct hda_codec * codec,hda_nid_t nid,int dir,unsigned int * tlv)1668 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1669 			     unsigned int *tlv)
1670 {
1671 	u32 caps;
1672 	int nums, step;
1673 
1674 	caps = query_amp_caps(codec, nid, dir);
1675 	nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1676 	step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1677 	step = (step + 1) * 25;
1678 	tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1679 	tlv[1] = 2 * sizeof(unsigned int);
1680 	tlv[2] = -nums * step;
1681 	tlv[3] = step;
1682 }
1683 EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
1684 
1685 /* find a mixer control element with the given name */
1686 static struct snd_kcontrol *
find_mixer_ctl(struct hda_codec * codec,const char * name,int dev,int idx)1687 find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
1688 {
1689 	struct snd_ctl_elem_id id;
1690 	memset(&id, 0, sizeof(id));
1691 	id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1692 	id.device = dev;
1693 	id.index = idx;
1694 	if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1695 		return NULL;
1696 	strcpy(id.name, name);
1697 	return snd_ctl_find_id(codec->card, &id);
1698 }
1699 
1700 /**
1701  * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1702  * @codec: HD-audio codec
1703  * @name: ctl id name string
1704  *
1705  * Get the control element with the given id string and IFACE_MIXER.
1706  */
snd_hda_find_mixer_ctl(struct hda_codec * codec,const char * name)1707 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1708 					    const char *name)
1709 {
1710 	return find_mixer_ctl(codec, name, 0, 0);
1711 }
1712 EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
1713 
find_empty_mixer_ctl_idx(struct hda_codec * codec,const char * name,int start_idx)1714 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
1715 				    int start_idx)
1716 {
1717 	int i, idx;
1718 	/* 16 ctlrs should be large enough */
1719 	for (i = 0, idx = start_idx; i < 16; i++, idx++) {
1720 		if (!find_mixer_ctl(codec, name, 0, idx))
1721 			return idx;
1722 	}
1723 	return -EBUSY;
1724 }
1725 
1726 /**
1727  * snd_hda_ctl_add - Add a control element and assign to the codec
1728  * @codec: HD-audio codec
1729  * @nid: corresponding NID (optional)
1730  * @kctl: the control element to assign
1731  *
1732  * Add the given control element to an array inside the codec instance.
1733  * All control elements belonging to a codec are supposed to be added
1734  * by this function so that a proper clean-up works at the free or
1735  * reconfiguration time.
1736  *
1737  * If non-zero @nid is passed, the NID is assigned to the control element.
1738  * The assignment is shown in the codec proc file.
1739  *
1740  * snd_hda_ctl_add() checks the control subdev id field whether
1741  * #HDA_SUBDEV_NID_FLAG bit is set.  If set (and @nid is zero), the lower
1742  * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
1743  * specifies if kctl->private_value is a HDA amplifier value.
1744  */
snd_hda_ctl_add(struct hda_codec * codec,hda_nid_t nid,struct snd_kcontrol * kctl)1745 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
1746 		    struct snd_kcontrol *kctl)
1747 {
1748 	int err;
1749 	unsigned short flags = 0;
1750 	struct hda_nid_item *item;
1751 
1752 	if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
1753 		flags |= HDA_NID_ITEM_AMP;
1754 		if (nid == 0)
1755 			nid = get_amp_nid_(kctl->private_value);
1756 	}
1757 	if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
1758 		nid = kctl->id.subdevice & 0xffff;
1759 	if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
1760 		kctl->id.subdevice = 0;
1761 	err = snd_ctl_add(codec->card, kctl);
1762 	if (err < 0)
1763 		return err;
1764 	item = snd_array_new(&codec->mixers);
1765 	if (!item)
1766 		return -ENOMEM;
1767 	item->kctl = kctl;
1768 	item->nid = nid;
1769 	item->flags = flags;
1770 	return 0;
1771 }
1772 EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
1773 
1774 /**
1775  * snd_hda_add_nid - Assign a NID to a control element
1776  * @codec: HD-audio codec
1777  * @nid: corresponding NID (optional)
1778  * @kctl: the control element to assign
1779  * @index: index to kctl
1780  *
1781  * Add the given control element to an array inside the codec instance.
1782  * This function is used when #snd_hda_ctl_add cannot be used for 1:1
1783  * NID:KCTL mapping - for example "Capture Source" selector.
1784  */
snd_hda_add_nid(struct hda_codec * codec,struct snd_kcontrol * kctl,unsigned int index,hda_nid_t nid)1785 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
1786 		    unsigned int index, hda_nid_t nid)
1787 {
1788 	struct hda_nid_item *item;
1789 
1790 	if (nid > 0) {
1791 		item = snd_array_new(&codec->nids);
1792 		if (!item)
1793 			return -ENOMEM;
1794 		item->kctl = kctl;
1795 		item->index = index;
1796 		item->nid = nid;
1797 		return 0;
1798 	}
1799 	codec_err(codec, "no NID for mapping control %s:%d:%d\n",
1800 		  kctl->id.name, kctl->id.index, index);
1801 	return -EINVAL;
1802 }
1803 EXPORT_SYMBOL_GPL(snd_hda_add_nid);
1804 
1805 /**
1806  * snd_hda_ctls_clear - Clear all controls assigned to the given codec
1807  * @codec: HD-audio codec
1808  */
snd_hda_ctls_clear(struct hda_codec * codec)1809 void snd_hda_ctls_clear(struct hda_codec *codec)
1810 {
1811 	int i;
1812 	struct hda_nid_item *items = codec->mixers.list;
1813 	for (i = 0; i < codec->mixers.used; i++)
1814 		snd_ctl_remove(codec->card, items[i].kctl);
1815 	snd_array_free(&codec->mixers);
1816 	snd_array_free(&codec->nids);
1817 }
1818 
1819 /**
1820  * snd_hda_lock_devices - pseudo device locking
1821  * @bus: the BUS
1822  *
1823  * toggle card->shutdown to allow/disallow the device access (as a hack)
1824  */
snd_hda_lock_devices(struct hda_bus * bus)1825 int snd_hda_lock_devices(struct hda_bus *bus)
1826 {
1827 	struct snd_card *card = bus->card;
1828 	struct hda_codec *codec;
1829 
1830 	spin_lock(&card->files_lock);
1831 	if (card->shutdown)
1832 		goto err_unlock;
1833 	card->shutdown = 1;
1834 	if (!list_empty(&card->ctl_files))
1835 		goto err_clear;
1836 
1837 	list_for_each_codec(codec, bus) {
1838 		struct hda_pcm *cpcm;
1839 		list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
1840 			if (!cpcm->pcm)
1841 				continue;
1842 			if (cpcm->pcm->streams[0].substream_opened ||
1843 			    cpcm->pcm->streams[1].substream_opened)
1844 				goto err_clear;
1845 		}
1846 	}
1847 	spin_unlock(&card->files_lock);
1848 	return 0;
1849 
1850  err_clear:
1851 	card->shutdown = 0;
1852  err_unlock:
1853 	spin_unlock(&card->files_lock);
1854 	return -EINVAL;
1855 }
1856 EXPORT_SYMBOL_GPL(snd_hda_lock_devices);
1857 
1858 /**
1859  * snd_hda_unlock_devices - pseudo device unlocking
1860  * @bus: the BUS
1861  */
snd_hda_unlock_devices(struct hda_bus * bus)1862 void snd_hda_unlock_devices(struct hda_bus *bus)
1863 {
1864 	struct snd_card *card = bus->card;
1865 
1866 	spin_lock(&card->files_lock);
1867 	card->shutdown = 0;
1868 	spin_unlock(&card->files_lock);
1869 }
1870 EXPORT_SYMBOL_GPL(snd_hda_unlock_devices);
1871 
1872 /**
1873  * snd_hda_codec_reset - Clear all objects assigned to the codec
1874  * @codec: HD-audio codec
1875  *
1876  * This frees the all PCM and control elements assigned to the codec, and
1877  * clears the caches and restores the pin default configurations.
1878  *
1879  * When a device is being used, it returns -EBSY.  If successfully freed,
1880  * returns zero.
1881  */
snd_hda_codec_reset(struct hda_codec * codec)1882 int snd_hda_codec_reset(struct hda_codec *codec)
1883 {
1884 	struct hda_bus *bus = codec->bus;
1885 
1886 	if (snd_hda_lock_devices(bus) < 0)
1887 		return -EBUSY;
1888 
1889 	/* OK, let it free */
1890 	snd_hdac_device_unregister(&codec->core);
1891 
1892 	/* allow device access again */
1893 	snd_hda_unlock_devices(bus);
1894 	return 0;
1895 }
1896 
1897 typedef int (*map_slave_func_t)(struct hda_codec *, void *, struct snd_kcontrol *);
1898 
1899 /* apply the function to all matching slave ctls in the mixer list */
map_slaves(struct hda_codec * codec,const char * const * slaves,const char * suffix,map_slave_func_t func,void * data)1900 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
1901 		      const char *suffix, map_slave_func_t func, void *data)
1902 {
1903 	struct hda_nid_item *items;
1904 	const char * const *s;
1905 	int i, err;
1906 
1907 	items = codec->mixers.list;
1908 	for (i = 0; i < codec->mixers.used; i++) {
1909 		struct snd_kcontrol *sctl = items[i].kctl;
1910 		if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
1911 			continue;
1912 		for (s = slaves; *s; s++) {
1913 			char tmpname[sizeof(sctl->id.name)];
1914 			const char *name = *s;
1915 			if (suffix) {
1916 				snprintf(tmpname, sizeof(tmpname), "%s %s",
1917 					 name, suffix);
1918 				name = tmpname;
1919 			}
1920 			if (!strcmp(sctl->id.name, name)) {
1921 				err = func(codec, data, sctl);
1922 				if (err)
1923 					return err;
1924 				break;
1925 			}
1926 		}
1927 	}
1928 	return 0;
1929 }
1930 
check_slave_present(struct hda_codec * codec,void * data,struct snd_kcontrol * sctl)1931 static int check_slave_present(struct hda_codec *codec,
1932 			       void *data, struct snd_kcontrol *sctl)
1933 {
1934 	return 1;
1935 }
1936 
1937 /* guess the value corresponding to 0dB */
get_kctl_0dB_offset(struct hda_codec * codec,struct snd_kcontrol * kctl,int * step_to_check)1938 static int get_kctl_0dB_offset(struct hda_codec *codec,
1939 			       struct snd_kcontrol *kctl, int *step_to_check)
1940 {
1941 	int _tlv[4];
1942 	const int *tlv = NULL;
1943 	int val = -1;
1944 
1945 	if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1946 		/* FIXME: set_fs() hack for obtaining user-space TLV data */
1947 		mm_segment_t fs = get_fs();
1948 		set_fs(get_ds());
1949 		if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
1950 			tlv = _tlv;
1951 		set_fs(fs);
1952 	} else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
1953 		tlv = kctl->tlv.p;
1954 	if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE) {
1955 		int step = tlv[3];
1956 		step &= ~TLV_DB_SCALE_MUTE;
1957 		if (!step)
1958 			return -1;
1959 		if (*step_to_check && *step_to_check != step) {
1960 			codec_err(codec, "Mismatching dB step for vmaster slave (%d!=%d)\n",
1961 -				   *step_to_check, step);
1962 			return -1;
1963 		}
1964 		*step_to_check = step;
1965 		val = -tlv[2] / step;
1966 	}
1967 	return val;
1968 }
1969 
1970 /* call kctl->put with the given value(s) */
put_kctl_with_value(struct snd_kcontrol * kctl,int val)1971 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
1972 {
1973 	struct snd_ctl_elem_value *ucontrol;
1974 	ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
1975 	if (!ucontrol)
1976 		return -ENOMEM;
1977 	ucontrol->value.integer.value[0] = val;
1978 	ucontrol->value.integer.value[1] = val;
1979 	kctl->put(kctl, ucontrol);
1980 	kfree(ucontrol);
1981 	return 0;
1982 }
1983 
1984 /* initialize the slave volume with 0dB */
init_slave_0dB(struct hda_codec * codec,void * data,struct snd_kcontrol * slave)1985 static int init_slave_0dB(struct hda_codec *codec,
1986 			  void *data, struct snd_kcontrol *slave)
1987 {
1988 	int offset = get_kctl_0dB_offset(codec, slave, data);
1989 	if (offset > 0)
1990 		put_kctl_with_value(slave, offset);
1991 	return 0;
1992 }
1993 
1994 /* unmute the slave */
init_slave_unmute(struct hda_codec * codec,void * data,struct snd_kcontrol * slave)1995 static int init_slave_unmute(struct hda_codec *codec,
1996 			     void *data, struct snd_kcontrol *slave)
1997 {
1998 	return put_kctl_with_value(slave, 1);
1999 }
2000 
add_slave(struct hda_codec * codec,void * data,struct snd_kcontrol * slave)2001 static int add_slave(struct hda_codec *codec,
2002 		     void *data, struct snd_kcontrol *slave)
2003 {
2004 	return snd_ctl_add_slave(data, slave);
2005 }
2006 
2007 /**
2008  * __snd_hda_add_vmaster - create a virtual master control and add slaves
2009  * @codec: HD-audio codec
2010  * @name: vmaster control name
2011  * @tlv: TLV data (optional)
2012  * @slaves: slave control names (optional)
2013  * @suffix: suffix string to each slave name (optional)
2014  * @init_slave_vol: initialize slaves to unmute/0dB
2015  * @ctl_ret: store the vmaster kcontrol in return
2016  *
2017  * Create a virtual master control with the given name.  The TLV data
2018  * must be either NULL or a valid data.
2019  *
2020  * @slaves is a NULL-terminated array of strings, each of which is a
2021  * slave control name.  All controls with these names are assigned to
2022  * the new virtual master control.
2023  *
2024  * This function returns zero if successful or a negative error code.
2025  */
__snd_hda_add_vmaster(struct hda_codec * codec,char * name,unsigned int * tlv,const char * const * slaves,const char * suffix,bool init_slave_vol,struct snd_kcontrol ** ctl_ret)2026 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2027 			unsigned int *tlv, const char * const *slaves,
2028 			  const char *suffix, bool init_slave_vol,
2029 			  struct snd_kcontrol **ctl_ret)
2030 {
2031 	struct snd_kcontrol *kctl;
2032 	int err;
2033 
2034 	if (ctl_ret)
2035 		*ctl_ret = NULL;
2036 
2037 	err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2038 	if (err != 1) {
2039 		codec_dbg(codec, "No slave found for %s\n", name);
2040 		return 0;
2041 	}
2042 	kctl = snd_ctl_make_virtual_master(name, tlv);
2043 	if (!kctl)
2044 		return -ENOMEM;
2045 	err = snd_hda_ctl_add(codec, 0, kctl);
2046 	if (err < 0)
2047 		return err;
2048 
2049 	err = map_slaves(codec, slaves, suffix, add_slave, kctl);
2050 	if (err < 0)
2051 		return err;
2052 
2053 	/* init with master mute & zero volume */
2054 	put_kctl_with_value(kctl, 0);
2055 	if (init_slave_vol) {
2056 		int step = 0;
2057 		map_slaves(codec, slaves, suffix,
2058 			   tlv ? init_slave_0dB : init_slave_unmute, &step);
2059 	}
2060 
2061 	if (ctl_ret)
2062 		*ctl_ret = kctl;
2063 	return 0;
2064 }
2065 EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster);
2066 
2067 /*
2068  * mute-LED control using vmaster
2069  */
vmaster_mute_mode_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)2070 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2071 				  struct snd_ctl_elem_info *uinfo)
2072 {
2073 	static const char * const texts[] = {
2074 		"On", "Off", "Follow Master"
2075 	};
2076 
2077 	return snd_ctl_enum_info(uinfo, 1, 3, texts);
2078 }
2079 
vmaster_mute_mode_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2080 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2081 				 struct snd_ctl_elem_value *ucontrol)
2082 {
2083 	struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2084 	ucontrol->value.enumerated.item[0] = hook->mute_mode;
2085 	return 0;
2086 }
2087 
vmaster_mute_mode_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2088 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2089 				 struct snd_ctl_elem_value *ucontrol)
2090 {
2091 	struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2092 	unsigned int old_mode = hook->mute_mode;
2093 
2094 	hook->mute_mode = ucontrol->value.enumerated.item[0];
2095 	if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2096 		hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2097 	if (old_mode == hook->mute_mode)
2098 		return 0;
2099 	snd_hda_sync_vmaster_hook(hook);
2100 	return 1;
2101 }
2102 
2103 static struct snd_kcontrol_new vmaster_mute_mode = {
2104 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2105 	.name = "Mute-LED Mode",
2106 	.info = vmaster_mute_mode_info,
2107 	.get = vmaster_mute_mode_get,
2108 	.put = vmaster_mute_mode_put,
2109 };
2110 
2111 /* meta hook to call each driver's vmaster hook */
vmaster_hook(void * private_data,int enabled)2112 static void vmaster_hook(void *private_data, int enabled)
2113 {
2114 	struct hda_vmaster_mute_hook *hook = private_data;
2115 
2116 	if (hook->mute_mode != HDA_VMUTE_FOLLOW_MASTER)
2117 		enabled = hook->mute_mode;
2118 	hook->hook(hook->codec, enabled);
2119 }
2120 
2121 /**
2122  * snd_hda_add_vmaster_hook - Add a vmaster hook for mute-LED
2123  * @codec: the HDA codec
2124  * @hook: the vmaster hook object
2125  * @expose_enum_ctl: flag to create an enum ctl
2126  *
2127  * Add a mute-LED hook with the given vmaster switch kctl.
2128  * When @expose_enum_ctl is set, "Mute-LED Mode" control is automatically
2129  * created and associated with the given hook.
2130  */
snd_hda_add_vmaster_hook(struct hda_codec * codec,struct hda_vmaster_mute_hook * hook,bool expose_enum_ctl)2131 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2132 			     struct hda_vmaster_mute_hook *hook,
2133 			     bool expose_enum_ctl)
2134 {
2135 	struct snd_kcontrol *kctl;
2136 
2137 	if (!hook->hook || !hook->sw_kctl)
2138 		return 0;
2139 	hook->codec = codec;
2140 	hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2141 	snd_ctl_add_vmaster_hook(hook->sw_kctl, vmaster_hook, hook);
2142 	if (!expose_enum_ctl)
2143 		return 0;
2144 	kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2145 	if (!kctl)
2146 		return -ENOMEM;
2147 	return snd_hda_ctl_add(codec, 0, kctl);
2148 }
2149 EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook);
2150 
2151 /**
2152  * snd_hda_sync_vmaster_hook - Sync vmaster hook
2153  * @hook: the vmaster hook
2154  *
2155  * Call the hook with the current value for synchronization.
2156  * Should be called in init callback.
2157  */
snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook * hook)2158 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2159 {
2160 	if (!hook->hook || !hook->codec)
2161 		return;
2162 	/* don't call vmaster hook in the destructor since it might have
2163 	 * been already destroyed
2164 	 */
2165 	if (hook->codec->bus->shutdown)
2166 		return;
2167 	snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2168 }
2169 EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook);
2170 
2171 
2172 /**
2173  * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2174  * @kcontrol: referred ctl element
2175  * @uinfo: pointer to get/store the data
2176  *
2177  * The control element is supposed to have the private_value field
2178  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2179  */
snd_hda_mixer_amp_switch_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)2180 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2181 				  struct snd_ctl_elem_info *uinfo)
2182 {
2183 	int chs = get_amp_channels(kcontrol);
2184 
2185 	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2186 	uinfo->count = chs == 3 ? 2 : 1;
2187 	uinfo->value.integer.min = 0;
2188 	uinfo->value.integer.max = 1;
2189 	return 0;
2190 }
2191 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
2192 
2193 /**
2194  * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2195  * @kcontrol: ctl element
2196  * @ucontrol: pointer to get/store the data
2197  *
2198  * The control element is supposed to have the private_value field
2199  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2200  */
snd_hda_mixer_amp_switch_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2201 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2202 				 struct snd_ctl_elem_value *ucontrol)
2203 {
2204 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2205 	hda_nid_t nid = get_amp_nid(kcontrol);
2206 	int chs = get_amp_channels(kcontrol);
2207 	int dir = get_amp_direction(kcontrol);
2208 	int idx = get_amp_index(kcontrol);
2209 	long *valp = ucontrol->value.integer.value;
2210 
2211 	if (chs & 1)
2212 		*valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2213 			   HDA_AMP_MUTE) ? 0 : 1;
2214 	if (chs & 2)
2215 		*valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2216 			 HDA_AMP_MUTE) ? 0 : 1;
2217 	return 0;
2218 }
2219 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
2220 
2221 /**
2222  * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2223  * @kcontrol: ctl element
2224  * @ucontrol: pointer to get/store the data
2225  *
2226  * The control element is supposed to have the private_value field
2227  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2228  */
snd_hda_mixer_amp_switch_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2229 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2230 				 struct snd_ctl_elem_value *ucontrol)
2231 {
2232 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2233 	hda_nid_t nid = get_amp_nid(kcontrol);
2234 	int chs = get_amp_channels(kcontrol);
2235 	int dir = get_amp_direction(kcontrol);
2236 	int idx = get_amp_index(kcontrol);
2237 	long *valp = ucontrol->value.integer.value;
2238 	int change = 0;
2239 
2240 	if (chs & 1) {
2241 		change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2242 						  HDA_AMP_MUTE,
2243 						  *valp ? 0 : HDA_AMP_MUTE);
2244 		valp++;
2245 	}
2246 	if (chs & 2)
2247 		change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2248 						   HDA_AMP_MUTE,
2249 						   *valp ? 0 : HDA_AMP_MUTE);
2250 	hda_call_check_power_status(codec, nid);
2251 	return change;
2252 }
2253 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
2254 
2255 /*
2256  * bound volume controls
2257  *
2258  * bind multiple volumes (# indices, from 0)
2259  */
2260 
2261 #define AMP_VAL_IDX_SHIFT	19
2262 #define AMP_VAL_IDX_MASK	(0x0f<<19)
2263 
2264 /**
2265  * snd_hda_mixer_bind_switch_get - Get 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  */
snd_hda_mixer_bind_switch_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2272 int snd_hda_mixer_bind_switch_get(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 err;
2278 
2279 	mutex_lock(&codec->control_mutex);
2280 	pval = kcontrol->private_value;
2281 	kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2282 	err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2283 	kcontrol->private_value = pval;
2284 	mutex_unlock(&codec->control_mutex);
2285 	return err;
2286 }
2287 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_get);
2288 
2289 /**
2290  * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2291  * @kcontrol: ctl element
2292  * @ucontrol: pointer to get/store the data
2293  *
2294  * The control element is supposed to have the private_value field
2295  * set up via HDA_BIND_MUTE*() macros.
2296  */
snd_hda_mixer_bind_switch_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2297 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2298 				  struct snd_ctl_elem_value *ucontrol)
2299 {
2300 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2301 	unsigned long pval;
2302 	int i, indices, err = 0, change = 0;
2303 
2304 	mutex_lock(&codec->control_mutex);
2305 	pval = kcontrol->private_value;
2306 	indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2307 	for (i = 0; i < indices; i++) {
2308 		kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2309 			(i << AMP_VAL_IDX_SHIFT);
2310 		err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2311 		if (err < 0)
2312 			break;
2313 		change |= err;
2314 	}
2315 	kcontrol->private_value = pval;
2316 	mutex_unlock(&codec->control_mutex);
2317 	return err < 0 ? err : change;
2318 }
2319 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_put);
2320 
2321 /**
2322  * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2323  * @kcontrol: referred ctl element
2324  * @uinfo: 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  */
snd_hda_mixer_bind_ctls_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)2329 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2330 				 struct snd_ctl_elem_info *uinfo)
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->info(kcontrol, uinfo);
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_info);
2345 
2346 /**
2347  * snd_hda_mixer_bind_ctls_get - Get 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  */
snd_hda_mixer_bind_ctls_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2354 int snd_hda_mixer_bind_ctls_get(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 	int err;
2360 
2361 	mutex_lock(&codec->control_mutex);
2362 	c = (struct hda_bind_ctls *)kcontrol->private_value;
2363 	kcontrol->private_value = *c->values;
2364 	err = c->ops->get(kcontrol, ucontrol);
2365 	kcontrol->private_value = (long)c;
2366 	mutex_unlock(&codec->control_mutex);
2367 	return err;
2368 }
2369 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_get);
2370 
2371 /**
2372  * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2373  * @kcontrol: ctl element
2374  * @ucontrol: pointer to get/store the data
2375  *
2376  * The control element is supposed to have the private_value field
2377  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2378  */
snd_hda_mixer_bind_ctls_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2379 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2380 				struct snd_ctl_elem_value *ucontrol)
2381 {
2382 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2383 	struct hda_bind_ctls *c;
2384 	unsigned long *vals;
2385 	int err = 0, change = 0;
2386 
2387 	mutex_lock(&codec->control_mutex);
2388 	c = (struct hda_bind_ctls *)kcontrol->private_value;
2389 	for (vals = c->values; *vals; vals++) {
2390 		kcontrol->private_value = *vals;
2391 		err = c->ops->put(kcontrol, ucontrol);
2392 		if (err < 0)
2393 			break;
2394 		change |= err;
2395 	}
2396 	kcontrol->private_value = (long)c;
2397 	mutex_unlock(&codec->control_mutex);
2398 	return err < 0 ? err : change;
2399 }
2400 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_put);
2401 
2402 /**
2403  * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2404  * @kcontrol: ctl element
2405  * @op_flag: operation flag
2406  * @size: byte size of input TLV
2407  * @tlv: TLV data
2408  *
2409  * The control element is supposed to have the private_value field
2410  * set up via HDA_BIND_VOL() macro.
2411  */
snd_hda_mixer_bind_tlv(struct snd_kcontrol * kcontrol,int op_flag,unsigned int size,unsigned int __user * tlv)2412 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2413 			   unsigned int size, unsigned int __user *tlv)
2414 {
2415 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2416 	struct hda_bind_ctls *c;
2417 	int err;
2418 
2419 	mutex_lock(&codec->control_mutex);
2420 	c = (struct hda_bind_ctls *)kcontrol->private_value;
2421 	kcontrol->private_value = *c->values;
2422 	err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2423 	kcontrol->private_value = (long)c;
2424 	mutex_unlock(&codec->control_mutex);
2425 	return err;
2426 }
2427 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_tlv);
2428 
2429 struct hda_ctl_ops snd_hda_bind_vol = {
2430 	.info = snd_hda_mixer_amp_volume_info,
2431 	.get = snd_hda_mixer_amp_volume_get,
2432 	.put = snd_hda_mixer_amp_volume_put,
2433 	.tlv = snd_hda_mixer_amp_tlv
2434 };
2435 EXPORT_SYMBOL_GPL(snd_hda_bind_vol);
2436 
2437 struct hda_ctl_ops snd_hda_bind_sw = {
2438 	.info = snd_hda_mixer_amp_switch_info,
2439 	.get = snd_hda_mixer_amp_switch_get,
2440 	.put = snd_hda_mixer_amp_switch_put,
2441 	.tlv = snd_hda_mixer_amp_tlv
2442 };
2443 EXPORT_SYMBOL_GPL(snd_hda_bind_sw);
2444 
2445 /*
2446  * SPDIF out controls
2447  */
2448 
snd_hda_spdif_mask_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)2449 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2450 				   struct snd_ctl_elem_info *uinfo)
2451 {
2452 	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2453 	uinfo->count = 1;
2454 	return 0;
2455 }
2456 
snd_hda_spdif_cmask_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2457 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2458 				   struct snd_ctl_elem_value *ucontrol)
2459 {
2460 	ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2461 					   IEC958_AES0_NONAUDIO |
2462 					   IEC958_AES0_CON_EMPHASIS_5015 |
2463 					   IEC958_AES0_CON_NOT_COPYRIGHT;
2464 	ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2465 					   IEC958_AES1_CON_ORIGINAL;
2466 	return 0;
2467 }
2468 
snd_hda_spdif_pmask_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2469 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2470 				   struct snd_ctl_elem_value *ucontrol)
2471 {
2472 	ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2473 					   IEC958_AES0_NONAUDIO |
2474 					   IEC958_AES0_PRO_EMPHASIS_5015;
2475 	return 0;
2476 }
2477 
snd_hda_spdif_default_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2478 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2479 				     struct snd_ctl_elem_value *ucontrol)
2480 {
2481 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2482 	int idx = kcontrol->private_value;
2483 	struct hda_spdif_out *spdif;
2484 
2485 	mutex_lock(&codec->spdif_mutex);
2486 	spdif = snd_array_elem(&codec->spdif_out, idx);
2487 	ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2488 	ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2489 	ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2490 	ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2491 	mutex_unlock(&codec->spdif_mutex);
2492 
2493 	return 0;
2494 }
2495 
2496 /* convert from SPDIF status bits to HDA SPDIF bits
2497  * bit 0 (DigEn) is always set zero (to be filled later)
2498  */
convert_from_spdif_status(unsigned int sbits)2499 static unsigned short convert_from_spdif_status(unsigned int sbits)
2500 {
2501 	unsigned short val = 0;
2502 
2503 	if (sbits & IEC958_AES0_PROFESSIONAL)
2504 		val |= AC_DIG1_PROFESSIONAL;
2505 	if (sbits & IEC958_AES0_NONAUDIO)
2506 		val |= AC_DIG1_NONAUDIO;
2507 	if (sbits & IEC958_AES0_PROFESSIONAL) {
2508 		if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2509 		    IEC958_AES0_PRO_EMPHASIS_5015)
2510 			val |= AC_DIG1_EMPHASIS;
2511 	} else {
2512 		if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2513 		    IEC958_AES0_CON_EMPHASIS_5015)
2514 			val |= AC_DIG1_EMPHASIS;
2515 		if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2516 			val |= AC_DIG1_COPYRIGHT;
2517 		if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2518 			val |= AC_DIG1_LEVEL;
2519 		val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2520 	}
2521 	return val;
2522 }
2523 
2524 /* convert to SPDIF status bits from HDA SPDIF bits
2525  */
convert_to_spdif_status(unsigned short val)2526 static unsigned int convert_to_spdif_status(unsigned short val)
2527 {
2528 	unsigned int sbits = 0;
2529 
2530 	if (val & AC_DIG1_NONAUDIO)
2531 		sbits |= IEC958_AES0_NONAUDIO;
2532 	if (val & AC_DIG1_PROFESSIONAL)
2533 		sbits |= IEC958_AES0_PROFESSIONAL;
2534 	if (sbits & IEC958_AES0_PROFESSIONAL) {
2535 		if (val & AC_DIG1_EMPHASIS)
2536 			sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2537 	} else {
2538 		if (val & AC_DIG1_EMPHASIS)
2539 			sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2540 		if (!(val & AC_DIG1_COPYRIGHT))
2541 			sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2542 		if (val & AC_DIG1_LEVEL)
2543 			sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2544 		sbits |= val & (0x7f << 8);
2545 	}
2546 	return sbits;
2547 }
2548 
2549 /* set digital convert verbs both for the given NID and its slaves */
set_dig_out(struct hda_codec * codec,hda_nid_t nid,int mask,int val)2550 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2551 			int mask, int val)
2552 {
2553 	const hda_nid_t *d;
2554 
2555 	snd_hdac_regmap_update(&codec->core, nid, AC_VERB_SET_DIGI_CONVERT_1,
2556 			       mask, val);
2557 	d = codec->slave_dig_outs;
2558 	if (!d)
2559 		return;
2560 	for (; *d; d++)
2561 		snd_hdac_regmap_update(&codec->core, *d,
2562 				       AC_VERB_SET_DIGI_CONVERT_1, mask, val);
2563 }
2564 
set_dig_out_convert(struct hda_codec * codec,hda_nid_t nid,int dig1,int dig2)2565 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2566 				       int dig1, int dig2)
2567 {
2568 	unsigned int mask = 0;
2569 	unsigned int val = 0;
2570 
2571 	if (dig1 != -1) {
2572 		mask |= 0xff;
2573 		val = dig1;
2574 	}
2575 	if (dig2 != -1) {
2576 		mask |= 0xff00;
2577 		val |= dig2 << 8;
2578 	}
2579 	set_dig_out(codec, nid, mask, val);
2580 }
2581 
snd_hda_spdif_default_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2582 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2583 				     struct snd_ctl_elem_value *ucontrol)
2584 {
2585 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2586 	int idx = kcontrol->private_value;
2587 	struct hda_spdif_out *spdif;
2588 	hda_nid_t nid;
2589 	unsigned short val;
2590 	int change;
2591 
2592 	mutex_lock(&codec->spdif_mutex);
2593 	spdif = snd_array_elem(&codec->spdif_out, idx);
2594 	nid = spdif->nid;
2595 	spdif->status = ucontrol->value.iec958.status[0] |
2596 		((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2597 		((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2598 		((unsigned int)ucontrol->value.iec958.status[3] << 24);
2599 	val = convert_from_spdif_status(spdif->status);
2600 	val |= spdif->ctls & 1;
2601 	change = spdif->ctls != val;
2602 	spdif->ctls = val;
2603 	if (change && nid != (u16)-1)
2604 		set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2605 	mutex_unlock(&codec->spdif_mutex);
2606 	return change;
2607 }
2608 
2609 #define snd_hda_spdif_out_switch_info	snd_ctl_boolean_mono_info
2610 
snd_hda_spdif_out_switch_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2611 static int snd_hda_spdif_out_switch_get(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 
2618 	mutex_lock(&codec->spdif_mutex);
2619 	spdif = snd_array_elem(&codec->spdif_out, idx);
2620 	ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
2621 	mutex_unlock(&codec->spdif_mutex);
2622 	return 0;
2623 }
2624 
set_spdif_ctls(struct hda_codec * codec,hda_nid_t nid,int dig1,int dig2)2625 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2626 				  int dig1, int dig2)
2627 {
2628 	set_dig_out_convert(codec, nid, dig1, dig2);
2629 	/* unmute amp switch (if any) */
2630 	if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2631 	    (dig1 & AC_DIG1_ENABLE))
2632 		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2633 					    HDA_AMP_MUTE, 0);
2634 }
2635 
snd_hda_spdif_out_switch_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2636 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2637 					struct snd_ctl_elem_value *ucontrol)
2638 {
2639 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2640 	int idx = kcontrol->private_value;
2641 	struct hda_spdif_out *spdif;
2642 	hda_nid_t nid;
2643 	unsigned short val;
2644 	int change;
2645 
2646 	mutex_lock(&codec->spdif_mutex);
2647 	spdif = snd_array_elem(&codec->spdif_out, idx);
2648 	nid = spdif->nid;
2649 	val = spdif->ctls & ~AC_DIG1_ENABLE;
2650 	if (ucontrol->value.integer.value[0])
2651 		val |= AC_DIG1_ENABLE;
2652 	change = spdif->ctls != val;
2653 	spdif->ctls = val;
2654 	if (change && nid != (u16)-1)
2655 		set_spdif_ctls(codec, nid, val & 0xff, -1);
2656 	mutex_unlock(&codec->spdif_mutex);
2657 	return change;
2658 }
2659 
2660 static struct snd_kcontrol_new dig_mixes[] = {
2661 	{
2662 		.access = SNDRV_CTL_ELEM_ACCESS_READ,
2663 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2664 		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
2665 		.info = snd_hda_spdif_mask_info,
2666 		.get = snd_hda_spdif_cmask_get,
2667 	},
2668 	{
2669 		.access = SNDRV_CTL_ELEM_ACCESS_READ,
2670 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2671 		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
2672 		.info = snd_hda_spdif_mask_info,
2673 		.get = snd_hda_spdif_pmask_get,
2674 	},
2675 	{
2676 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2677 		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
2678 		.info = snd_hda_spdif_mask_info,
2679 		.get = snd_hda_spdif_default_get,
2680 		.put = snd_hda_spdif_default_put,
2681 	},
2682 	{
2683 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2684 		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
2685 		.info = snd_hda_spdif_out_switch_info,
2686 		.get = snd_hda_spdif_out_switch_get,
2687 		.put = snd_hda_spdif_out_switch_put,
2688 	},
2689 	{ } /* end */
2690 };
2691 
2692 /**
2693  * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
2694  * @codec: the HDA codec
2695  * @associated_nid: NID that new ctls associated with
2696  * @cvt_nid: converter NID
2697  * @type: HDA_PCM_TYPE_*
2698  * Creates controls related with the digital output.
2699  * Called from each patch supporting the digital out.
2700  *
2701  * Returns 0 if successful, or a negative error code.
2702  */
snd_hda_create_dig_out_ctls(struct hda_codec * codec,hda_nid_t associated_nid,hda_nid_t cvt_nid,int type)2703 int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
2704 				hda_nid_t associated_nid,
2705 				hda_nid_t cvt_nid,
2706 				int type)
2707 {
2708 	int err;
2709 	struct snd_kcontrol *kctl;
2710 	struct snd_kcontrol_new *dig_mix;
2711 	int idx = 0;
2712 	int val = 0;
2713 	const int spdif_index = 16;
2714 	struct hda_spdif_out *spdif;
2715 	struct hda_bus *bus = codec->bus;
2716 
2717 	if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
2718 	    type == HDA_PCM_TYPE_SPDIF) {
2719 		idx = spdif_index;
2720 	} else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
2721 		   type == HDA_PCM_TYPE_HDMI) {
2722 		/* suppose a single SPDIF device */
2723 		for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2724 			kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
2725 			if (!kctl)
2726 				break;
2727 			kctl->id.index = spdif_index;
2728 		}
2729 		bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
2730 	}
2731 	if (!bus->primary_dig_out_type)
2732 		bus->primary_dig_out_type = type;
2733 
2734 	idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
2735 	if (idx < 0) {
2736 		codec_err(codec, "too many IEC958 outputs\n");
2737 		return -EBUSY;
2738 	}
2739 	spdif = snd_array_new(&codec->spdif_out);
2740 	if (!spdif)
2741 		return -ENOMEM;
2742 	for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2743 		kctl = snd_ctl_new1(dig_mix, codec);
2744 		if (!kctl)
2745 			return -ENOMEM;
2746 		kctl->id.index = idx;
2747 		kctl->private_value = codec->spdif_out.used - 1;
2748 		err = snd_hda_ctl_add(codec, associated_nid, kctl);
2749 		if (err < 0)
2750 			return err;
2751 	}
2752 	spdif->nid = cvt_nid;
2753 	snd_hdac_regmap_read(&codec->core, cvt_nid,
2754 			     AC_VERB_GET_DIGI_CONVERT_1, &val);
2755 	spdif->ctls = val;
2756 	spdif->status = convert_to_spdif_status(spdif->ctls);
2757 	return 0;
2758 }
2759 EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls);
2760 
2761 /**
2762  * snd_hda_spdif_out_of_nid - get the hda_spdif_out entry from the given NID
2763  * @codec: the HDA codec
2764  * @nid: widget NID
2765  *
2766  * call within spdif_mutex lock
2767  */
snd_hda_spdif_out_of_nid(struct hda_codec * codec,hda_nid_t nid)2768 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
2769 					       hda_nid_t nid)
2770 {
2771 	int i;
2772 	for (i = 0; i < codec->spdif_out.used; i++) {
2773 		struct hda_spdif_out *spdif =
2774 				snd_array_elem(&codec->spdif_out, i);
2775 		if (spdif->nid == nid)
2776 			return spdif;
2777 	}
2778 	return NULL;
2779 }
2780 EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_nid);
2781 
2782 /**
2783  * snd_hda_spdif_ctls_unassign - Unassign the given SPDIF ctl
2784  * @codec: the HDA codec
2785  * @idx: the SPDIF ctl index
2786  *
2787  * Unassign the widget from the given SPDIF control.
2788  */
snd_hda_spdif_ctls_unassign(struct hda_codec * codec,int idx)2789 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
2790 {
2791 	struct hda_spdif_out *spdif;
2792 
2793 	mutex_lock(&codec->spdif_mutex);
2794 	spdif = snd_array_elem(&codec->spdif_out, idx);
2795 	spdif->nid = (u16)-1;
2796 	mutex_unlock(&codec->spdif_mutex);
2797 }
2798 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
2799 
2800 /**
2801  * snd_hda_spdif_ctls_assign - Assign the SPDIF controls to the given NID
2802  * @codec: the HDA codec
2803  * @idx: the SPDIF ctl idx
2804  * @nid: widget NID
2805  *
2806  * Assign the widget to the SPDIF control with the given index.
2807  */
snd_hda_spdif_ctls_assign(struct hda_codec * codec,int idx,hda_nid_t nid)2808 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
2809 {
2810 	struct hda_spdif_out *spdif;
2811 	unsigned short val;
2812 
2813 	mutex_lock(&codec->spdif_mutex);
2814 	spdif = snd_array_elem(&codec->spdif_out, idx);
2815 	if (spdif->nid != nid) {
2816 		spdif->nid = nid;
2817 		val = spdif->ctls;
2818 		set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
2819 	}
2820 	mutex_unlock(&codec->spdif_mutex);
2821 }
2822 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
2823 
2824 /*
2825  * SPDIF sharing with analog output
2826  */
spdif_share_sw_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2827 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2828 			      struct snd_ctl_elem_value *ucontrol)
2829 {
2830 	struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2831 	ucontrol->value.integer.value[0] = mout->share_spdif;
2832 	return 0;
2833 }
2834 
spdif_share_sw_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2835 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2836 			      struct snd_ctl_elem_value *ucontrol)
2837 {
2838 	struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2839 	mout->share_spdif = !!ucontrol->value.integer.value[0];
2840 	return 0;
2841 }
2842 
2843 static struct snd_kcontrol_new spdif_share_sw = {
2844 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2845 	.name = "IEC958 Default PCM Playback Switch",
2846 	.info = snd_ctl_boolean_mono_info,
2847 	.get = spdif_share_sw_get,
2848 	.put = spdif_share_sw_put,
2849 };
2850 
2851 /**
2852  * snd_hda_create_spdif_share_sw - create Default PCM switch
2853  * @codec: the HDA codec
2854  * @mout: multi-out instance
2855  */
snd_hda_create_spdif_share_sw(struct hda_codec * codec,struct hda_multi_out * mout)2856 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2857 				  struct hda_multi_out *mout)
2858 {
2859 	struct snd_kcontrol *kctl;
2860 
2861 	if (!mout->dig_out_nid)
2862 		return 0;
2863 
2864 	kctl = snd_ctl_new1(&spdif_share_sw, mout);
2865 	if (!kctl)
2866 		return -ENOMEM;
2867 	/* ATTENTION: here mout is passed as private_data, instead of codec */
2868 	return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
2869 }
2870 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
2871 
2872 /*
2873  * SPDIF input
2874  */
2875 
2876 #define snd_hda_spdif_in_switch_info	snd_hda_spdif_out_switch_info
2877 
snd_hda_spdif_in_switch_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2878 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2879 				       struct snd_ctl_elem_value *ucontrol)
2880 {
2881 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2882 
2883 	ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2884 	return 0;
2885 }
2886 
snd_hda_spdif_in_switch_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2887 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2888 				       struct snd_ctl_elem_value *ucontrol)
2889 {
2890 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2891 	hda_nid_t nid = kcontrol->private_value;
2892 	unsigned int val = !!ucontrol->value.integer.value[0];
2893 	int change;
2894 
2895 	mutex_lock(&codec->spdif_mutex);
2896 	change = codec->spdif_in_enable != val;
2897 	if (change) {
2898 		codec->spdif_in_enable = val;
2899 		snd_hdac_regmap_write(&codec->core, nid,
2900 				      AC_VERB_SET_DIGI_CONVERT_1, val);
2901 	}
2902 	mutex_unlock(&codec->spdif_mutex);
2903 	return change;
2904 }
2905 
snd_hda_spdif_in_status_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2906 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2907 				       struct snd_ctl_elem_value *ucontrol)
2908 {
2909 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2910 	hda_nid_t nid = kcontrol->private_value;
2911 	unsigned int val;
2912 	unsigned int sbits;
2913 
2914 	snd_hdac_regmap_read(&codec->core, nid,
2915 			     AC_VERB_GET_DIGI_CONVERT_1, &val);
2916 	sbits = convert_to_spdif_status(val);
2917 	ucontrol->value.iec958.status[0] = sbits;
2918 	ucontrol->value.iec958.status[1] = sbits >> 8;
2919 	ucontrol->value.iec958.status[2] = sbits >> 16;
2920 	ucontrol->value.iec958.status[3] = sbits >> 24;
2921 	return 0;
2922 }
2923 
2924 static struct snd_kcontrol_new dig_in_ctls[] = {
2925 	{
2926 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2927 		.name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
2928 		.info = snd_hda_spdif_in_switch_info,
2929 		.get = snd_hda_spdif_in_switch_get,
2930 		.put = snd_hda_spdif_in_switch_put,
2931 	},
2932 	{
2933 		.access = SNDRV_CTL_ELEM_ACCESS_READ,
2934 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2935 		.name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
2936 		.info = snd_hda_spdif_mask_info,
2937 		.get = snd_hda_spdif_in_status_get,
2938 	},
2939 	{ } /* end */
2940 };
2941 
2942 /**
2943  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2944  * @codec: the HDA codec
2945  * @nid: audio in widget NID
2946  *
2947  * Creates controls related with the SPDIF input.
2948  * Called from each patch supporting the SPDIF in.
2949  *
2950  * Returns 0 if successful, or a negative error code.
2951  */
snd_hda_create_spdif_in_ctls(struct hda_codec * codec,hda_nid_t nid)2952 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2953 {
2954 	int err;
2955 	struct snd_kcontrol *kctl;
2956 	struct snd_kcontrol_new *dig_mix;
2957 	int idx;
2958 
2959 	idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
2960 	if (idx < 0) {
2961 		codec_err(codec, "too many IEC958 inputs\n");
2962 		return -EBUSY;
2963 	}
2964 	for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2965 		kctl = snd_ctl_new1(dig_mix, codec);
2966 		if (!kctl)
2967 			return -ENOMEM;
2968 		kctl->private_value = nid;
2969 		err = snd_hda_ctl_add(codec, nid, kctl);
2970 		if (err < 0)
2971 			return err;
2972 	}
2973 	codec->spdif_in_enable =
2974 		snd_hda_codec_read(codec, nid, 0,
2975 				   AC_VERB_GET_DIGI_CONVERT_1, 0) &
2976 		AC_DIG1_ENABLE;
2977 	return 0;
2978 }
2979 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
2980 
2981 /**
2982  * snd_hda_codec_set_power_to_all - Set the power state to all widgets
2983  * @codec: the HDA codec
2984  * @fg: function group (not used now)
2985  * @power_state: the power state to set (AC_PWRST_*)
2986  *
2987  * Set the given power state to all widgets that have the power control.
2988  * If the codec has power_filter set, it evaluates the power state and
2989  * filter out if it's unchanged as D3.
2990  */
snd_hda_codec_set_power_to_all(struct hda_codec * codec,hda_nid_t fg,unsigned int power_state)2991 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
2992 				    unsigned int power_state)
2993 {
2994 	hda_nid_t nid;
2995 
2996 	for_each_hda_codec_node(nid, codec) {
2997 		unsigned int wcaps = get_wcaps(codec, nid);
2998 		unsigned int state = power_state;
2999 		if (!(wcaps & AC_WCAP_POWER))
3000 			continue;
3001 		if (codec->power_filter) {
3002 			state = codec->power_filter(codec, nid, power_state);
3003 			if (state != power_state && power_state == AC_PWRST_D3)
3004 				continue;
3005 		}
3006 		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3007 				    state);
3008 	}
3009 }
3010 EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all);
3011 
3012 /*
3013  * wait until the state is reached, returns the current state
3014  */
hda_sync_power_state(struct hda_codec * codec,hda_nid_t fg,unsigned int power_state)3015 static unsigned int hda_sync_power_state(struct hda_codec *codec,
3016 					 hda_nid_t fg,
3017 					 unsigned int power_state)
3018 {
3019 	unsigned long end_time = jiffies + msecs_to_jiffies(500);
3020 	unsigned int state, actual_state;
3021 
3022 	for (;;) {
3023 		state = snd_hda_codec_read(codec, fg, 0,
3024 					   AC_VERB_GET_POWER_STATE, 0);
3025 		if (state & AC_PWRST_ERROR)
3026 			break;
3027 		actual_state = (state >> 4) & 0x0f;
3028 		if (actual_state == power_state)
3029 			break;
3030 		if (time_after_eq(jiffies, end_time))
3031 			break;
3032 		/* wait until the codec reachs to the target state */
3033 		msleep(1);
3034 	}
3035 	return state;
3036 }
3037 
3038 /**
3039  * snd_hda_codec_eapd_power_filter - A power filter callback for EAPD
3040  * @codec: the HDA codec
3041  * @nid: widget NID
3042  * @power_state: power state to evalue
3043  *
3044  * Don't power down the widget if it controls eapd and EAPD_BTLENABLE is set.
3045  * This can be used a codec power_filter callback.
3046  */
snd_hda_codec_eapd_power_filter(struct hda_codec * codec,hda_nid_t nid,unsigned int power_state)3047 unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
3048 					     hda_nid_t nid,
3049 					     unsigned int power_state)
3050 {
3051 	if (nid == codec->core.afg || nid == codec->core.mfg)
3052 		return power_state;
3053 	if (power_state == AC_PWRST_D3 &&
3054 	    get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
3055 	    (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3056 		int eapd = snd_hda_codec_read(codec, nid, 0,
3057 					      AC_VERB_GET_EAPD_BTLENABLE, 0);
3058 		if (eapd & 0x02)
3059 			return AC_PWRST_D0;
3060 	}
3061 	return power_state;
3062 }
3063 EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter);
3064 
3065 /*
3066  * set power state of the codec, and return the power state
3067  */
hda_set_power_state(struct hda_codec * codec,unsigned int power_state)3068 static unsigned int hda_set_power_state(struct hda_codec *codec,
3069 					unsigned int power_state)
3070 {
3071 	hda_nid_t fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
3072 	int count;
3073 	unsigned int state;
3074 	int flags = 0;
3075 
3076 	/* this delay seems necessary to avoid click noise at power-down */
3077 	if (power_state == AC_PWRST_D3) {
3078 		if (codec->depop_delay < 0)
3079 			msleep(codec_has_epss(codec) ? 10 : 100);
3080 		else if (codec->depop_delay > 0)
3081 			msleep(codec->depop_delay);
3082 		flags = HDA_RW_NO_RESPONSE_FALLBACK;
3083 	}
3084 
3085 	/* repeat power states setting at most 10 times*/
3086 	for (count = 0; count < 10; count++) {
3087 		if (codec->patch_ops.set_power_state)
3088 			codec->patch_ops.set_power_state(codec, fg,
3089 							 power_state);
3090 		else {
3091 			state = power_state;
3092 			if (codec->power_filter)
3093 				state = codec->power_filter(codec, fg, state);
3094 			if (state == power_state || power_state != AC_PWRST_D3)
3095 				snd_hda_codec_read(codec, fg, flags,
3096 						   AC_VERB_SET_POWER_STATE,
3097 						   state);
3098 			snd_hda_codec_set_power_to_all(codec, fg, power_state);
3099 		}
3100 		state = hda_sync_power_state(codec, fg, power_state);
3101 		if (!(state & AC_PWRST_ERROR))
3102 			break;
3103 	}
3104 
3105 	return state;
3106 }
3107 
3108 /* sync power states of all widgets;
3109  * this is called at the end of codec parsing
3110  */
sync_power_up_states(struct hda_codec * codec)3111 static void sync_power_up_states(struct hda_codec *codec)
3112 {
3113 	hda_nid_t nid;
3114 
3115 	/* don't care if no filter is used */
3116 	if (!codec->power_filter)
3117 		return;
3118 
3119 	for_each_hda_codec_node(nid, codec) {
3120 		unsigned int wcaps = get_wcaps(codec, nid);
3121 		unsigned int target;
3122 		if (!(wcaps & AC_WCAP_POWER))
3123 			continue;
3124 		target = codec->power_filter(codec, nid, AC_PWRST_D0);
3125 		if (target == AC_PWRST_D0)
3126 			continue;
3127 		if (!snd_hda_check_power_state(codec, nid, target))
3128 			snd_hda_codec_write(codec, nid, 0,
3129 					    AC_VERB_SET_POWER_STATE, target);
3130 	}
3131 }
3132 
3133 #ifdef CONFIG_SND_HDA_RECONFIG
3134 /* execute additional init verbs */
hda_exec_init_verbs(struct hda_codec * codec)3135 static void hda_exec_init_verbs(struct hda_codec *codec)
3136 {
3137 	if (codec->init_verbs.list)
3138 		snd_hda_sequence_write(codec, codec->init_verbs.list);
3139 }
3140 #else
hda_exec_init_verbs(struct hda_codec * codec)3141 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3142 #endif
3143 
3144 #ifdef CONFIG_PM
3145 /* update the power on/off account with the current jiffies */
update_power_acct(struct hda_codec * codec,bool on)3146 static void update_power_acct(struct hda_codec *codec, bool on)
3147 {
3148 	unsigned long delta = jiffies - codec->power_jiffies;
3149 
3150 	if (on)
3151 		codec->power_on_acct += delta;
3152 	else
3153 		codec->power_off_acct += delta;
3154 	codec->power_jiffies += delta;
3155 }
3156 
snd_hda_update_power_acct(struct hda_codec * codec)3157 void snd_hda_update_power_acct(struct hda_codec *codec)
3158 {
3159 	update_power_acct(codec, hda_codec_is_power_on(codec));
3160 }
3161 
3162 /*
3163  * call suspend and power-down; used both from PM and power-save
3164  * this function returns the power state in the end
3165  */
hda_call_codec_suspend(struct hda_codec * codec)3166 static unsigned int hda_call_codec_suspend(struct hda_codec *codec)
3167 {
3168 	unsigned int state;
3169 
3170 	atomic_inc(&codec->core.in_pm);
3171 
3172 	if (codec->patch_ops.suspend)
3173 		codec->patch_ops.suspend(codec);
3174 	hda_cleanup_all_streams(codec);
3175 	state = hda_set_power_state(codec, AC_PWRST_D3);
3176 	update_power_acct(codec, true);
3177 	atomic_dec(&codec->core.in_pm);
3178 	return state;
3179 }
3180 
3181 /*
3182  * kick up codec; used both from PM and power-save
3183  */
hda_call_codec_resume(struct hda_codec * codec)3184 static void hda_call_codec_resume(struct hda_codec *codec)
3185 {
3186 	atomic_inc(&codec->core.in_pm);
3187 
3188 	if (codec->core.regmap)
3189 		regcache_mark_dirty(codec->core.regmap);
3190 
3191 	codec->power_jiffies = jiffies;
3192 
3193 	hda_set_power_state(codec, AC_PWRST_D0);
3194 	restore_shutup_pins(codec);
3195 	hda_exec_init_verbs(codec);
3196 	snd_hda_jack_set_dirty_all(codec);
3197 	if (codec->patch_ops.resume)
3198 		codec->patch_ops.resume(codec);
3199 	else {
3200 		if (codec->patch_ops.init)
3201 			codec->patch_ops.init(codec);
3202 		if (codec->core.regmap)
3203 			regcache_sync(codec->core.regmap);
3204 	}
3205 
3206 	if (codec->jackpoll_interval)
3207 		hda_jackpoll_work(&codec->jackpoll_work.work);
3208 	else
3209 		snd_hda_jack_report_sync(codec);
3210 	atomic_dec(&codec->core.in_pm);
3211 }
3212 
hda_codec_runtime_suspend(struct device * dev)3213 static int hda_codec_runtime_suspend(struct device *dev)
3214 {
3215 	struct hda_codec *codec = dev_to_hda_codec(dev);
3216 	struct hda_pcm *pcm;
3217 	unsigned int state;
3218 
3219 	cancel_delayed_work_sync(&codec->jackpoll_work);
3220 	list_for_each_entry(pcm, &codec->pcm_list_head, list)
3221 		snd_pcm_suspend_all(pcm->pcm);
3222 	state = hda_call_codec_suspend(codec);
3223 	if (codec_has_clkstop(codec) && codec_has_epss(codec) &&
3224 	    (state & AC_PWRST_CLK_STOP_OK))
3225 		snd_hdac_codec_link_down(&codec->core);
3226 	return 0;
3227 }
3228 
hda_codec_runtime_resume(struct device * dev)3229 static int hda_codec_runtime_resume(struct device *dev)
3230 {
3231 	struct hda_codec *codec = dev_to_hda_codec(dev);
3232 
3233 	snd_hdac_codec_link_up(&codec->core);
3234 	hda_call_codec_resume(codec);
3235 	pm_runtime_mark_last_busy(dev);
3236 	return 0;
3237 }
3238 #endif /* CONFIG_PM */
3239 
3240 /* referred in hda_bind.c */
3241 const struct dev_pm_ops hda_codec_driver_pm = {
3242 	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
3243 				pm_runtime_force_resume)
3244 	SET_RUNTIME_PM_OPS(hda_codec_runtime_suspend, hda_codec_runtime_resume,
3245 			   NULL)
3246 };
3247 
3248 /*
3249  * add standard channel maps if not specified
3250  */
add_std_chmaps(struct hda_codec * codec)3251 static int add_std_chmaps(struct hda_codec *codec)
3252 {
3253 	struct hda_pcm *pcm;
3254 	int str, err;
3255 
3256 	list_for_each_entry(pcm, &codec->pcm_list_head, list) {
3257 		for (str = 0; str < 2; str++) {
3258 			struct hda_pcm_stream *hinfo = &pcm->stream[str];
3259 			struct snd_pcm_chmap *chmap;
3260 			const struct snd_pcm_chmap_elem *elem;
3261 
3262 			if (!pcm || !pcm->pcm || pcm->own_chmap ||
3263 			    !hinfo->substreams)
3264 				continue;
3265 			elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
3266 			err = snd_pcm_add_chmap_ctls(pcm->pcm, str, elem,
3267 						     hinfo->channels_max,
3268 						     0, &chmap);
3269 			if (err < 0)
3270 				return err;
3271 			chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
3272 		}
3273 	}
3274 	return 0;
3275 }
3276 
3277 /* default channel maps for 2.1 speakers;
3278  * since HD-audio supports only stereo, odd number channels are omitted
3279  */
3280 const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
3281 	{ .channels = 2,
3282 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
3283 	{ .channels = 4,
3284 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
3285 		   SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
3286 	{ }
3287 };
3288 EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
3289 
snd_hda_codec_build_controls(struct hda_codec * codec)3290 int snd_hda_codec_build_controls(struct hda_codec *codec)
3291 {
3292 	int err = 0;
3293 	hda_exec_init_verbs(codec);
3294 	/* continue to initialize... */
3295 	if (codec->patch_ops.init)
3296 		err = codec->patch_ops.init(codec);
3297 	if (!err && codec->patch_ops.build_controls)
3298 		err = codec->patch_ops.build_controls(codec);
3299 	if (err < 0)
3300 		return err;
3301 
3302 	/* we create chmaps here instead of build_pcms */
3303 	err = add_std_chmaps(codec);
3304 	if (err < 0)
3305 		return err;
3306 
3307 	if (codec->jackpoll_interval)
3308 		hda_jackpoll_work(&codec->jackpoll_work.work);
3309 	else
3310 		snd_hda_jack_report_sync(codec); /* call at the last init point */
3311 	sync_power_up_states(codec);
3312 	return 0;
3313 }
3314 
3315 /*
3316  * stream formats
3317  */
3318 struct hda_rate_tbl {
3319 	unsigned int hz;
3320 	unsigned int alsa_bits;
3321 	unsigned int hda_fmt;
3322 };
3323 
3324 /* rate = base * mult / div */
3325 #define HDA_RATE(base, mult, div) \
3326 	(AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3327 	 (((div) - 1) << AC_FMT_DIV_SHIFT))
3328 
3329 static struct hda_rate_tbl rate_bits[] = {
3330 	/* rate in Hz, ALSA rate bitmask, HDA format value */
3331 
3332 	/* autodetected value used in snd_hda_query_supported_pcm */
3333 	{ 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3334 	{ 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3335 	{ 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3336 	{ 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3337 	{ 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3338 	{ 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3339 	{ 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3340 	{ 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3341 	{ 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3342 	{ 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3343 	{ 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3344 #define AC_PAR_PCM_RATE_BITS	11
3345 	/* up to bits 10, 384kHZ isn't supported properly */
3346 
3347 	/* not autodetected value */
3348 	{ 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3349 
3350 	{ 0 } /* terminator */
3351 };
3352 
3353 /**
3354  * snd_hda_calc_stream_format - calculate format bitset
3355  * @codec: HD-audio codec
3356  * @rate: the sample rate
3357  * @channels: the number of channels
3358  * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3359  * @maxbps: the max. bps
3360  * @spdif_ctls: HD-audio SPDIF status bits (0 if irrelevant)
3361  *
3362  * Calculate the format bitset from the given rate, channels and th PCM format.
3363  *
3364  * Return zero if invalid.
3365  */
snd_hda_calc_stream_format(struct hda_codec * codec,unsigned int rate,unsigned int channels,unsigned int format,unsigned int maxbps,unsigned short spdif_ctls)3366 unsigned int snd_hda_calc_stream_format(struct hda_codec *codec,
3367 					unsigned int rate,
3368 					unsigned int channels,
3369 					unsigned int format,
3370 					unsigned int maxbps,
3371 					unsigned short spdif_ctls)
3372 {
3373 	int i;
3374 	unsigned int val = 0;
3375 
3376 	for (i = 0; rate_bits[i].hz; i++)
3377 		if (rate_bits[i].hz == rate) {
3378 			val = rate_bits[i].hda_fmt;
3379 			break;
3380 		}
3381 	if (!rate_bits[i].hz) {
3382 		codec_dbg(codec, "invalid rate %d\n", rate);
3383 		return 0;
3384 	}
3385 
3386 	if (channels == 0 || channels > 8) {
3387 		codec_dbg(codec, "invalid channels %d\n", channels);
3388 		return 0;
3389 	}
3390 	val |= channels - 1;
3391 
3392 	switch (snd_pcm_format_width(format)) {
3393 	case 8:
3394 		val |= AC_FMT_BITS_8;
3395 		break;
3396 	case 16:
3397 		val |= AC_FMT_BITS_16;
3398 		break;
3399 	case 20:
3400 	case 24:
3401 	case 32:
3402 		if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3403 			val |= AC_FMT_BITS_32;
3404 		else if (maxbps >= 24)
3405 			val |= AC_FMT_BITS_24;
3406 		else
3407 			val |= AC_FMT_BITS_20;
3408 		break;
3409 	default:
3410 		codec_dbg(codec, "invalid format width %d\n",
3411 			  snd_pcm_format_width(format));
3412 		return 0;
3413 	}
3414 
3415 	if (spdif_ctls & AC_DIG1_NONAUDIO)
3416 		val |= AC_FMT_TYPE_NON_PCM;
3417 
3418 	return val;
3419 }
3420 EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format);
3421 
query_pcm_param(struct hda_codec * codec,hda_nid_t nid)3422 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3423 {
3424 	unsigned int val = 0;
3425 	if (nid != codec->core.afg &&
3426 	    (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3427 		val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3428 	if (!val || val == -1)
3429 		val = snd_hda_param_read(codec, codec->core.afg, AC_PAR_PCM);
3430 	if (!val || val == -1)
3431 		return 0;
3432 	return val;
3433 }
3434 
query_stream_param(struct hda_codec * codec,hda_nid_t nid)3435 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3436 {
3437 	unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3438 	if (!streams || streams == -1)
3439 		streams = snd_hda_param_read(codec, codec->core.afg, AC_PAR_STREAM);
3440 	if (!streams || streams == -1)
3441 		return 0;
3442 	return streams;
3443 }
3444 
3445 /**
3446  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3447  * @codec: the HDA codec
3448  * @nid: NID to query
3449  * @ratesp: the pointer to store the detected rate bitflags
3450  * @formatsp: the pointer to store the detected formats
3451  * @bpsp: the pointer to store the detected format widths
3452  *
3453  * Queries the supported PCM rates and formats.  The NULL @ratesp, @formatsp
3454  * or @bsps argument is ignored.
3455  *
3456  * Returns 0 if successful, otherwise a negative error code.
3457  */
snd_hda_query_supported_pcm(struct hda_codec * codec,hda_nid_t nid,u32 * ratesp,u64 * formatsp,unsigned int * bpsp)3458 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3459 				u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3460 {
3461 	unsigned int i, val, wcaps;
3462 
3463 	wcaps = get_wcaps(codec, nid);
3464 	val = query_pcm_param(codec, nid);
3465 
3466 	if (ratesp) {
3467 		u32 rates = 0;
3468 		for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3469 			if (val & (1 << i))
3470 				rates |= rate_bits[i].alsa_bits;
3471 		}
3472 		if (rates == 0) {
3473 			codec_err(codec,
3474 				  "rates == 0 (nid=0x%x, val=0x%x, ovrd=%i)\n",
3475 				  nid, val,
3476 				  (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3477 			return -EIO;
3478 		}
3479 		*ratesp = rates;
3480 	}
3481 
3482 	if (formatsp || bpsp) {
3483 		u64 formats = 0;
3484 		unsigned int streams, bps;
3485 
3486 		streams = query_stream_param(codec, nid);
3487 		if (!streams)
3488 			return -EIO;
3489 
3490 		bps = 0;
3491 		if (streams & AC_SUPFMT_PCM) {
3492 			if (val & AC_SUPPCM_BITS_8) {
3493 				formats |= SNDRV_PCM_FMTBIT_U8;
3494 				bps = 8;
3495 			}
3496 			if (val & AC_SUPPCM_BITS_16) {
3497 				formats |= SNDRV_PCM_FMTBIT_S16_LE;
3498 				bps = 16;
3499 			}
3500 			if (wcaps & AC_WCAP_DIGITAL) {
3501 				if (val & AC_SUPPCM_BITS_32)
3502 					formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3503 				if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3504 					formats |= SNDRV_PCM_FMTBIT_S32_LE;
3505 				if (val & AC_SUPPCM_BITS_24)
3506 					bps = 24;
3507 				else if (val & AC_SUPPCM_BITS_20)
3508 					bps = 20;
3509 			} else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3510 					  AC_SUPPCM_BITS_32)) {
3511 				formats |= SNDRV_PCM_FMTBIT_S32_LE;
3512 				if (val & AC_SUPPCM_BITS_32)
3513 					bps = 32;
3514 				else if (val & AC_SUPPCM_BITS_24)
3515 					bps = 24;
3516 				else if (val & AC_SUPPCM_BITS_20)
3517 					bps = 20;
3518 			}
3519 		}
3520 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
3521 		if (streams & AC_SUPFMT_FLOAT32) {
3522 			formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3523 			if (!bps)
3524 				bps = 32;
3525 		}
3526 #endif
3527 		if (streams == AC_SUPFMT_AC3) {
3528 			/* should be exclusive */
3529 			/* temporary hack: we have still no proper support
3530 			 * for the direct AC3 stream...
3531 			 */
3532 			formats |= SNDRV_PCM_FMTBIT_U8;
3533 			bps = 8;
3534 		}
3535 		if (formats == 0) {
3536 			codec_err(codec,
3537 				  "formats == 0 (nid=0x%x, val=0x%x, ovrd=%i, streams=0x%x)\n",
3538 				  nid, val,
3539 				  (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3540 				  streams);
3541 			return -EIO;
3542 		}
3543 		if (formatsp)
3544 			*formatsp = formats;
3545 		if (bpsp)
3546 			*bpsp = bps;
3547 	}
3548 
3549 	return 0;
3550 }
3551 EXPORT_SYMBOL_GPL(snd_hda_query_supported_pcm);
3552 
3553 /**
3554  * snd_hda_is_supported_format - Check the validity of the format
3555  * @codec: HD-audio codec
3556  * @nid: NID to check
3557  * @format: the HD-audio format value to check
3558  *
3559  * Check whether the given node supports the format value.
3560  *
3561  * Returns 1 if supported, 0 if not.
3562  */
snd_hda_is_supported_format(struct hda_codec * codec,hda_nid_t nid,unsigned int format)3563 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3564 				unsigned int format)
3565 {
3566 	int i;
3567 	unsigned int val = 0, rate, stream;
3568 
3569 	val = query_pcm_param(codec, nid);
3570 	if (!val)
3571 		return 0;
3572 
3573 	rate = format & 0xff00;
3574 	for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3575 		if (rate_bits[i].hda_fmt == rate) {
3576 			if (val & (1 << i))
3577 				break;
3578 			return 0;
3579 		}
3580 	if (i >= AC_PAR_PCM_RATE_BITS)
3581 		return 0;
3582 
3583 	stream = query_stream_param(codec, nid);
3584 	if (!stream)
3585 		return 0;
3586 
3587 	if (stream & AC_SUPFMT_PCM) {
3588 		switch (format & 0xf0) {
3589 		case 0x00:
3590 			if (!(val & AC_SUPPCM_BITS_8))
3591 				return 0;
3592 			break;
3593 		case 0x10:
3594 			if (!(val & AC_SUPPCM_BITS_16))
3595 				return 0;
3596 			break;
3597 		case 0x20:
3598 			if (!(val & AC_SUPPCM_BITS_20))
3599 				return 0;
3600 			break;
3601 		case 0x30:
3602 			if (!(val & AC_SUPPCM_BITS_24))
3603 				return 0;
3604 			break;
3605 		case 0x40:
3606 			if (!(val & AC_SUPPCM_BITS_32))
3607 				return 0;
3608 			break;
3609 		default:
3610 			return 0;
3611 		}
3612 	} else {
3613 		/* FIXME: check for float32 and AC3? */
3614 	}
3615 
3616 	return 1;
3617 }
3618 EXPORT_SYMBOL_GPL(snd_hda_is_supported_format);
3619 
3620 /*
3621  * PCM stuff
3622  */
hda_pcm_default_open_close(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)3623 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3624 				      struct hda_codec *codec,
3625 				      struct snd_pcm_substream *substream)
3626 {
3627 	return 0;
3628 }
3629 
hda_pcm_default_prepare(struct hda_pcm_stream * hinfo,struct hda_codec * codec,unsigned int stream_tag,unsigned int format,struct snd_pcm_substream * substream)3630 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3631 				   struct hda_codec *codec,
3632 				   unsigned int stream_tag,
3633 				   unsigned int format,
3634 				   struct snd_pcm_substream *substream)
3635 {
3636 	snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3637 	return 0;
3638 }
3639 
hda_pcm_default_cleanup(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)3640 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3641 				   struct hda_codec *codec,
3642 				   struct snd_pcm_substream *substream)
3643 {
3644 	snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3645 	return 0;
3646 }
3647 
set_pcm_default_values(struct hda_codec * codec,struct hda_pcm_stream * info)3648 static int set_pcm_default_values(struct hda_codec *codec,
3649 				  struct hda_pcm_stream *info)
3650 {
3651 	int err;
3652 
3653 	/* query support PCM information from the given NID */
3654 	if (info->nid && (!info->rates || !info->formats)) {
3655 		err = snd_hda_query_supported_pcm(codec, info->nid,
3656 				info->rates ? NULL : &info->rates,
3657 				info->formats ? NULL : &info->formats,
3658 				info->maxbps ? NULL : &info->maxbps);
3659 		if (err < 0)
3660 			return err;
3661 	}
3662 	if (info->ops.open == NULL)
3663 		info->ops.open = hda_pcm_default_open_close;
3664 	if (info->ops.close == NULL)
3665 		info->ops.close = hda_pcm_default_open_close;
3666 	if (info->ops.prepare == NULL) {
3667 		if (snd_BUG_ON(!info->nid))
3668 			return -EINVAL;
3669 		info->ops.prepare = hda_pcm_default_prepare;
3670 	}
3671 	if (info->ops.cleanup == NULL) {
3672 		if (snd_BUG_ON(!info->nid))
3673 			return -EINVAL;
3674 		info->ops.cleanup = hda_pcm_default_cleanup;
3675 	}
3676 	return 0;
3677 }
3678 
3679 /*
3680  * codec prepare/cleanup entries
3681  */
3682 /**
3683  * snd_hda_codec_prepare - Prepare a stream
3684  * @codec: the HDA codec
3685  * @hinfo: PCM information
3686  * @stream: stream tag to assign
3687  * @format: format id to assign
3688  * @substream: PCM substream to assign
3689  *
3690  * Calls the prepare callback set by the codec with the given arguments.
3691  * Clean up the inactive streams when successful.
3692  */
snd_hda_codec_prepare(struct hda_codec * codec,struct hda_pcm_stream * hinfo,unsigned int stream,unsigned int format,struct snd_pcm_substream * substream)3693 int snd_hda_codec_prepare(struct hda_codec *codec,
3694 			  struct hda_pcm_stream *hinfo,
3695 			  unsigned int stream,
3696 			  unsigned int format,
3697 			  struct snd_pcm_substream *substream)
3698 {
3699 	int ret;
3700 	mutex_lock(&codec->bus->prepare_mutex);
3701 	if (hinfo->ops.prepare)
3702 		ret = hinfo->ops.prepare(hinfo, codec, stream, format,
3703 					 substream);
3704 	else
3705 		ret = -ENODEV;
3706 	if (ret >= 0)
3707 		purify_inactive_streams(codec);
3708 	mutex_unlock(&codec->bus->prepare_mutex);
3709 	return ret;
3710 }
3711 EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
3712 
3713 /**
3714  * snd_hda_codec_cleanup - Prepare a stream
3715  * @codec: the HDA codec
3716  * @hinfo: PCM information
3717  * @substream: PCM substream
3718  *
3719  * Calls the cleanup callback set by the codec with the given arguments.
3720  */
snd_hda_codec_cleanup(struct hda_codec * codec,struct hda_pcm_stream * hinfo,struct snd_pcm_substream * substream)3721 void snd_hda_codec_cleanup(struct hda_codec *codec,
3722 			   struct hda_pcm_stream *hinfo,
3723 			   struct snd_pcm_substream *substream)
3724 {
3725 	mutex_lock(&codec->bus->prepare_mutex);
3726 	if (hinfo->ops.cleanup)
3727 		hinfo->ops.cleanup(hinfo, codec, substream);
3728 	mutex_unlock(&codec->bus->prepare_mutex);
3729 }
3730 EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
3731 
3732 /* global */
3733 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3734 	"Audio", "SPDIF", "HDMI", "Modem"
3735 };
3736 
3737 /*
3738  * get the empty PCM device number to assign
3739  */
get_empty_pcm_device(struct hda_bus * bus,unsigned int type)3740 static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type)
3741 {
3742 	/* audio device indices; not linear to keep compatibility */
3743 	/* assigned to static slots up to dev#10; if more needed, assign
3744 	 * the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y)
3745 	 */
3746 	static int audio_idx[HDA_PCM_NTYPES][5] = {
3747 		[HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3748 		[HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3749 		[HDA_PCM_TYPE_HDMI]  = { 3, 7, 8, 9, -1 },
3750 		[HDA_PCM_TYPE_MODEM] = { 6, -1 },
3751 	};
3752 	int i;
3753 
3754 	if (type >= HDA_PCM_NTYPES) {
3755 		dev_err(bus->card->dev, "Invalid PCM type %d\n", type);
3756 		return -EINVAL;
3757 	}
3758 
3759 	for (i = 0; audio_idx[type][i] >= 0; i++) {
3760 #ifndef CONFIG_SND_DYNAMIC_MINORS
3761 		if (audio_idx[type][i] >= 8)
3762 			break;
3763 #endif
3764 		if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3765 			return audio_idx[type][i];
3766 	}
3767 
3768 #ifdef CONFIG_SND_DYNAMIC_MINORS
3769 	/* non-fixed slots starting from 10 */
3770 	for (i = 10; i < 32; i++) {
3771 		if (!test_and_set_bit(i, bus->pcm_dev_bits))
3772 			return i;
3773 	}
3774 #endif
3775 
3776 	dev_warn(bus->card->dev, "Too many %s devices\n",
3777 		snd_hda_pcm_type_name[type]);
3778 #ifndef CONFIG_SND_DYNAMIC_MINORS
3779 	dev_warn(bus->card->dev,
3780 		 "Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n");
3781 #endif
3782 	return -EAGAIN;
3783 }
3784 
3785 /* call build_pcms ops of the given codec and set up the default parameters */
snd_hda_codec_parse_pcms(struct hda_codec * codec)3786 int snd_hda_codec_parse_pcms(struct hda_codec *codec)
3787 {
3788 	struct hda_pcm *cpcm;
3789 	int err;
3790 
3791 	if (!list_empty(&codec->pcm_list_head))
3792 		return 0; /* already parsed */
3793 
3794 	if (!codec->patch_ops.build_pcms)
3795 		return 0;
3796 
3797 	err = codec->patch_ops.build_pcms(codec);
3798 	if (err < 0) {
3799 		codec_err(codec, "cannot build PCMs for #%d (error %d)\n",
3800 			  codec->core.addr, err);
3801 		return err;
3802 	}
3803 
3804 	list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
3805 		int stream;
3806 
3807 		for (stream = 0; stream < 2; stream++) {
3808 			struct hda_pcm_stream *info = &cpcm->stream[stream];
3809 
3810 			if (!info->substreams)
3811 				continue;
3812 			err = set_pcm_default_values(codec, info);
3813 			if (err < 0) {
3814 				codec_warn(codec,
3815 					   "fail to setup default for PCM %s\n",
3816 					   cpcm->name);
3817 				return err;
3818 			}
3819 		}
3820 	}
3821 
3822 	return 0;
3823 }
3824 
3825 /* assign all PCMs of the given codec */
snd_hda_codec_build_pcms(struct hda_codec * codec)3826 int snd_hda_codec_build_pcms(struct hda_codec *codec)
3827 {
3828 	struct hda_bus *bus = codec->bus;
3829 	struct hda_pcm *cpcm;
3830 	int dev, err;
3831 
3832 	if (snd_BUG_ON(!bus->ops.attach_pcm))
3833 		return -EINVAL;
3834 
3835 	err = snd_hda_codec_parse_pcms(codec);
3836 	if (err < 0)
3837 		return err;
3838 
3839 	/* attach a new PCM streams */
3840 	list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
3841 		if (cpcm->pcm)
3842 			continue; /* already attached */
3843 		if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
3844 			continue; /* no substreams assigned */
3845 
3846 		dev = get_empty_pcm_device(bus, cpcm->pcm_type);
3847 		if (dev < 0)
3848 			continue; /* no fatal error */
3849 		cpcm->device = dev;
3850 		err =  bus->ops.attach_pcm(bus, codec, cpcm);
3851 		if (err < 0) {
3852 			codec_err(codec,
3853 				  "cannot attach PCM stream %d for codec #%d\n",
3854 				  dev, codec->core.addr);
3855 			continue; /* no fatal error */
3856 		}
3857 	}
3858 
3859 	return 0;
3860 }
3861 
3862 /**
3863  * snd_hda_add_new_ctls - create controls from the array
3864  * @codec: the HDA codec
3865  * @knew: the array of struct snd_kcontrol_new
3866  *
3867  * This helper function creates and add new controls in the given array.
3868  * The array must be terminated with an empty entry as terminator.
3869  *
3870  * Returns 0 if successful, or a negative error code.
3871  */
snd_hda_add_new_ctls(struct hda_codec * codec,const struct snd_kcontrol_new * knew)3872 int snd_hda_add_new_ctls(struct hda_codec *codec,
3873 			 const struct snd_kcontrol_new *knew)
3874 {
3875 	int err;
3876 
3877 	for (; knew->name; knew++) {
3878 		struct snd_kcontrol *kctl;
3879 		int addr = 0, idx = 0;
3880 		if (knew->iface == -1)	/* skip this codec private value */
3881 			continue;
3882 		for (;;) {
3883 			kctl = snd_ctl_new1(knew, codec);
3884 			if (!kctl)
3885 				return -ENOMEM;
3886 			if (addr > 0)
3887 				kctl->id.device = addr;
3888 			if (idx > 0)
3889 				kctl->id.index = idx;
3890 			err = snd_hda_ctl_add(codec, 0, kctl);
3891 			if (!err)
3892 				break;
3893 			/* try first with another device index corresponding to
3894 			 * the codec addr; if it still fails (or it's the
3895 			 * primary codec), then try another control index
3896 			 */
3897 			if (!addr && codec->core.addr)
3898 				addr = codec->core.addr;
3899 			else if (!idx && !knew->index) {
3900 				idx = find_empty_mixer_ctl_idx(codec,
3901 							       knew->name, 0);
3902 				if (idx <= 0)
3903 					return err;
3904 			} else
3905 				return err;
3906 		}
3907 	}
3908 	return 0;
3909 }
3910 EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
3911 
3912 #ifdef CONFIG_PM
codec_set_power_save(struct hda_codec * codec,int delay)3913 static void codec_set_power_save(struct hda_codec *codec, int delay)
3914 {
3915 	struct device *dev = hda_codec_dev(codec);
3916 
3917 	if (delay > 0) {
3918 		pm_runtime_set_autosuspend_delay(dev, delay);
3919 		pm_runtime_use_autosuspend(dev);
3920 		pm_runtime_allow(dev);
3921 		if (!pm_runtime_suspended(dev))
3922 			pm_runtime_mark_last_busy(dev);
3923 	} else {
3924 		pm_runtime_dont_use_autosuspend(dev);
3925 		pm_runtime_forbid(dev);
3926 	}
3927 }
3928 
3929 /**
3930  * snd_hda_set_power_save - reprogram autosuspend for the given delay
3931  * @bus: HD-audio bus
3932  * @delay: autosuspend delay in msec, 0 = off
3933  *
3934  * Synchronize the runtime PM autosuspend state from the power_save option.
3935  */
snd_hda_set_power_save(struct hda_bus * bus,int delay)3936 void snd_hda_set_power_save(struct hda_bus *bus, int delay)
3937 {
3938 	struct hda_codec *c;
3939 
3940 	list_for_each_codec(c, bus)
3941 		codec_set_power_save(c, delay);
3942 }
3943 EXPORT_SYMBOL_GPL(snd_hda_set_power_save);
3944 
3945 /**
3946  * snd_hda_check_amp_list_power - Check the amp list and update the power
3947  * @codec: HD-audio codec
3948  * @check: the object containing an AMP list and the status
3949  * @nid: NID to check / update
3950  *
3951  * Check whether the given NID is in the amp list.  If it's in the list,
3952  * check the current AMP status, and update the the power-status according
3953  * to the mute status.
3954  *
3955  * This function is supposed to be set or called from the check_power_status
3956  * patch ops.
3957  */
snd_hda_check_amp_list_power(struct hda_codec * codec,struct hda_loopback_check * check,hda_nid_t nid)3958 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3959 				 struct hda_loopback_check *check,
3960 				 hda_nid_t nid)
3961 {
3962 	const struct hda_amp_list *p;
3963 	int ch, v;
3964 
3965 	if (!check->amplist)
3966 		return 0;
3967 	for (p = check->amplist; p->nid; p++) {
3968 		if (p->nid == nid)
3969 			break;
3970 	}
3971 	if (!p->nid)
3972 		return 0; /* nothing changed */
3973 
3974 	for (p = check->amplist; p->nid; p++) {
3975 		for (ch = 0; ch < 2; ch++) {
3976 			v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3977 						   p->idx);
3978 			if (!(v & HDA_AMP_MUTE) && v > 0) {
3979 				if (!check->power_on) {
3980 					check->power_on = 1;
3981 					snd_hda_power_up_pm(codec);
3982 				}
3983 				return 1;
3984 			}
3985 		}
3986 	}
3987 	if (check->power_on) {
3988 		check->power_on = 0;
3989 		snd_hda_power_down_pm(codec);
3990 	}
3991 	return 0;
3992 }
3993 EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
3994 #endif
3995 
3996 /*
3997  * input MUX helper
3998  */
3999 
4000 /**
4001  * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4002  * @imux: imux helper object
4003  * @uinfo: pointer to get/store the data
4004  */
snd_hda_input_mux_info(const struct hda_input_mux * imux,struct snd_ctl_elem_info * uinfo)4005 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4006 			   struct snd_ctl_elem_info *uinfo)
4007 {
4008 	unsigned int index;
4009 
4010 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4011 	uinfo->count = 1;
4012 	uinfo->value.enumerated.items = imux->num_items;
4013 	if (!imux->num_items)
4014 		return 0;
4015 	index = uinfo->value.enumerated.item;
4016 	if (index >= imux->num_items)
4017 		index = imux->num_items - 1;
4018 	strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4019 	return 0;
4020 }
4021 EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
4022 
4023 /**
4024  * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4025  * @codec: the HDA codec
4026  * @imux: imux helper object
4027  * @ucontrol: pointer to get/store the data
4028  * @nid: input mux NID
4029  * @cur_val: pointer to get/store the current imux value
4030  */
snd_hda_input_mux_put(struct hda_codec * codec,const struct hda_input_mux * imux,struct snd_ctl_elem_value * ucontrol,hda_nid_t nid,unsigned int * cur_val)4031 int snd_hda_input_mux_put(struct hda_codec *codec,
4032 			  const struct hda_input_mux *imux,
4033 			  struct snd_ctl_elem_value *ucontrol,
4034 			  hda_nid_t nid,
4035 			  unsigned int *cur_val)
4036 {
4037 	unsigned int idx;
4038 
4039 	if (!imux->num_items)
4040 		return 0;
4041 	idx = ucontrol->value.enumerated.item[0];
4042 	if (idx >= imux->num_items)
4043 		idx = imux->num_items - 1;
4044 	if (*cur_val == idx)
4045 		return 0;
4046 	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4047 				  imux->items[idx].index);
4048 	*cur_val = idx;
4049 	return 1;
4050 }
4051 EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
4052 
4053 
4054 /**
4055  * snd_hda_enum_helper_info - Helper for simple enum ctls
4056  * @kcontrol: ctl element
4057  * @uinfo: pointer to get/store the data
4058  * @num_items: number of enum items
4059  * @texts: enum item string array
4060  *
4061  * process kcontrol info callback of a simple string enum array
4062  * when @num_items is 0 or @texts is NULL, assume a boolean enum array
4063  */
snd_hda_enum_helper_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo,int num_items,const char * const * texts)4064 int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
4065 			     struct snd_ctl_elem_info *uinfo,
4066 			     int num_items, const char * const *texts)
4067 {
4068 	static const char * const texts_default[] = {
4069 		"Disabled", "Enabled"
4070 	};
4071 
4072 	if (!texts || !num_items) {
4073 		num_items = 2;
4074 		texts = texts_default;
4075 	}
4076 
4077 	return snd_ctl_enum_info(uinfo, 1, num_items, texts);
4078 }
4079 EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info);
4080 
4081 /*
4082  * Multi-channel / digital-out PCM helper functions
4083  */
4084 
4085 /* setup SPDIF output stream */
setup_dig_out_stream(struct hda_codec * codec,hda_nid_t nid,unsigned int stream_tag,unsigned int format)4086 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4087 				 unsigned int stream_tag, unsigned int format)
4088 {
4089 	struct hda_spdif_out *spdif;
4090 	unsigned int curr_fmt;
4091 	bool reset;
4092 
4093 	spdif = snd_hda_spdif_out_of_nid(codec, nid);
4094 	curr_fmt = snd_hda_codec_read(codec, nid, 0,
4095 				      AC_VERB_GET_STREAM_FORMAT, 0);
4096 	reset = codec->spdif_status_reset &&
4097 		(spdif->ctls & AC_DIG1_ENABLE) &&
4098 		curr_fmt != format;
4099 
4100 	/* turn off SPDIF if needed; otherwise the IEC958 bits won't be
4101 	   updated */
4102 	if (reset)
4103 		set_dig_out_convert(codec, nid,
4104 				    spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
4105 				    -1);
4106 	snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4107 	if (codec->slave_dig_outs) {
4108 		const hda_nid_t *d;
4109 		for (d = codec->slave_dig_outs; *d; d++)
4110 			snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4111 						   format);
4112 	}
4113 	/* turn on again (if needed) */
4114 	if (reset)
4115 		set_dig_out_convert(codec, nid,
4116 				    spdif->ctls & 0xff, -1);
4117 }
4118 
cleanup_dig_out_stream(struct hda_codec * codec,hda_nid_t nid)4119 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4120 {
4121 	snd_hda_codec_cleanup_stream(codec, nid);
4122 	if (codec->slave_dig_outs) {
4123 		const hda_nid_t *d;
4124 		for (d = codec->slave_dig_outs; *d; d++)
4125 			snd_hda_codec_cleanup_stream(codec, *d);
4126 	}
4127 }
4128 
4129 /**
4130  * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4131  * @codec: the HDA codec
4132  * @mout: hda_multi_out object
4133  */
snd_hda_multi_out_dig_open(struct hda_codec * codec,struct hda_multi_out * mout)4134 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4135 			       struct hda_multi_out *mout)
4136 {
4137 	mutex_lock(&codec->spdif_mutex);
4138 	if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4139 		/* already opened as analog dup; reset it once */
4140 		cleanup_dig_out_stream(codec, mout->dig_out_nid);
4141 	mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4142 	mutex_unlock(&codec->spdif_mutex);
4143 	return 0;
4144 }
4145 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
4146 
4147 /**
4148  * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4149  * @codec: the HDA codec
4150  * @mout: hda_multi_out object
4151  * @stream_tag: stream tag to assign
4152  * @format: format id to assign
4153  * @substream: PCM substream to assign
4154  */
snd_hda_multi_out_dig_prepare(struct hda_codec * codec,struct hda_multi_out * mout,unsigned int stream_tag,unsigned int format,struct snd_pcm_substream * substream)4155 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4156 				  struct hda_multi_out *mout,
4157 				  unsigned int stream_tag,
4158 				  unsigned int format,
4159 				  struct snd_pcm_substream *substream)
4160 {
4161 	mutex_lock(&codec->spdif_mutex);
4162 	setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4163 	mutex_unlock(&codec->spdif_mutex);
4164 	return 0;
4165 }
4166 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
4167 
4168 /**
4169  * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4170  * @codec: the HDA codec
4171  * @mout: hda_multi_out object
4172  */
snd_hda_multi_out_dig_cleanup(struct hda_codec * codec,struct hda_multi_out * mout)4173 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4174 				  struct hda_multi_out *mout)
4175 {
4176 	mutex_lock(&codec->spdif_mutex);
4177 	cleanup_dig_out_stream(codec, mout->dig_out_nid);
4178 	mutex_unlock(&codec->spdif_mutex);
4179 	return 0;
4180 }
4181 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
4182 
4183 /**
4184  * snd_hda_multi_out_dig_close - release the digital out stream
4185  * @codec: the HDA codec
4186  * @mout: hda_multi_out object
4187  */
snd_hda_multi_out_dig_close(struct hda_codec * codec,struct hda_multi_out * mout)4188 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4189 				struct hda_multi_out *mout)
4190 {
4191 	mutex_lock(&codec->spdif_mutex);
4192 	mout->dig_out_used = 0;
4193 	mutex_unlock(&codec->spdif_mutex);
4194 	return 0;
4195 }
4196 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
4197 
4198 /**
4199  * snd_hda_multi_out_analog_open - open analog outputs
4200  * @codec: the HDA codec
4201  * @mout: hda_multi_out object
4202  * @substream: PCM substream to assign
4203  * @hinfo: PCM information to assign
4204  *
4205  * Open analog outputs and set up the hw-constraints.
4206  * If the digital outputs can be opened as slave, open the digital
4207  * outputs, too.
4208  */
snd_hda_multi_out_analog_open(struct hda_codec * codec,struct hda_multi_out * mout,struct snd_pcm_substream * substream,struct hda_pcm_stream * hinfo)4209 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4210 				  struct hda_multi_out *mout,
4211 				  struct snd_pcm_substream *substream,
4212 				  struct hda_pcm_stream *hinfo)
4213 {
4214 	struct snd_pcm_runtime *runtime = substream->runtime;
4215 	runtime->hw.channels_max = mout->max_channels;
4216 	if (mout->dig_out_nid) {
4217 		if (!mout->analog_rates) {
4218 			mout->analog_rates = hinfo->rates;
4219 			mout->analog_formats = hinfo->formats;
4220 			mout->analog_maxbps = hinfo->maxbps;
4221 		} else {
4222 			runtime->hw.rates = mout->analog_rates;
4223 			runtime->hw.formats = mout->analog_formats;
4224 			hinfo->maxbps = mout->analog_maxbps;
4225 		}
4226 		if (!mout->spdif_rates) {
4227 			snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4228 						    &mout->spdif_rates,
4229 						    &mout->spdif_formats,
4230 						    &mout->spdif_maxbps);
4231 		}
4232 		mutex_lock(&codec->spdif_mutex);
4233 		if (mout->share_spdif) {
4234 			if ((runtime->hw.rates & mout->spdif_rates) &&
4235 			    (runtime->hw.formats & mout->spdif_formats)) {
4236 				runtime->hw.rates &= mout->spdif_rates;
4237 				runtime->hw.formats &= mout->spdif_formats;
4238 				if (mout->spdif_maxbps < hinfo->maxbps)
4239 					hinfo->maxbps = mout->spdif_maxbps;
4240 			} else {
4241 				mout->share_spdif = 0;
4242 				/* FIXME: need notify? */
4243 			}
4244 		}
4245 		mutex_unlock(&codec->spdif_mutex);
4246 	}
4247 	return snd_pcm_hw_constraint_step(substream->runtime, 0,
4248 					  SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4249 }
4250 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
4251 
4252 /**
4253  * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4254  * @codec: the HDA codec
4255  * @mout: hda_multi_out object
4256  * @stream_tag: stream tag to assign
4257  * @format: format id to assign
4258  * @substream: PCM substream to assign
4259  *
4260  * Set up the i/o for analog out.
4261  * When the digital out is available, copy the front out to digital out, too.
4262  */
snd_hda_multi_out_analog_prepare(struct hda_codec * codec,struct hda_multi_out * mout,unsigned int stream_tag,unsigned int format,struct snd_pcm_substream * substream)4263 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4264 				     struct hda_multi_out *mout,
4265 				     unsigned int stream_tag,
4266 				     unsigned int format,
4267 				     struct snd_pcm_substream *substream)
4268 {
4269 	const hda_nid_t *nids = mout->dac_nids;
4270 	int chs = substream->runtime->channels;
4271 	struct hda_spdif_out *spdif;
4272 	int i;
4273 
4274 	mutex_lock(&codec->spdif_mutex);
4275 	spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
4276 	if (mout->dig_out_nid && mout->share_spdif &&
4277 	    mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4278 		if (chs == 2 &&
4279 		    snd_hda_is_supported_format(codec, mout->dig_out_nid,
4280 						format) &&
4281 		    !(spdif->status & IEC958_AES0_NONAUDIO)) {
4282 			mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4283 			setup_dig_out_stream(codec, mout->dig_out_nid,
4284 					     stream_tag, format);
4285 		} else {
4286 			mout->dig_out_used = 0;
4287 			cleanup_dig_out_stream(codec, mout->dig_out_nid);
4288 		}
4289 	}
4290 	mutex_unlock(&codec->spdif_mutex);
4291 
4292 	/* front */
4293 	snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4294 				   0, format);
4295 	if (!mout->no_share_stream &&
4296 	    mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4297 		/* headphone out will just decode front left/right (stereo) */
4298 		snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4299 					   0, format);
4300 	/* extra outputs copied from front */
4301 	for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4302 		if (!mout->no_share_stream && mout->hp_out_nid[i])
4303 			snd_hda_codec_setup_stream(codec,
4304 						   mout->hp_out_nid[i],
4305 						   stream_tag, 0, format);
4306 
4307 	/* surrounds */
4308 	for (i = 1; i < mout->num_dacs; i++) {
4309 		if (chs >= (i + 1) * 2) /* independent out */
4310 			snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4311 						   i * 2, format);
4312 		else if (!mout->no_share_stream) /* copy front */
4313 			snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4314 						   0, format);
4315 	}
4316 
4317 	/* extra surrounds */
4318 	for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) {
4319 		int ch = 0;
4320 		if (!mout->extra_out_nid[i])
4321 			break;
4322 		if (chs >= (i + 1) * 2)
4323 			ch = i * 2;
4324 		else if (!mout->no_share_stream)
4325 			break;
4326 		snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i],
4327 					   stream_tag, ch, format);
4328 	}
4329 
4330 	return 0;
4331 }
4332 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
4333 
4334 /**
4335  * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4336  * @codec: the HDA codec
4337  * @mout: hda_multi_out object
4338  */
snd_hda_multi_out_analog_cleanup(struct hda_codec * codec,struct hda_multi_out * mout)4339 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4340 				     struct hda_multi_out *mout)
4341 {
4342 	const hda_nid_t *nids = mout->dac_nids;
4343 	int i;
4344 
4345 	for (i = 0; i < mout->num_dacs; i++)
4346 		snd_hda_codec_cleanup_stream(codec, nids[i]);
4347 	if (mout->hp_nid)
4348 		snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4349 	for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4350 		if (mout->hp_out_nid[i])
4351 			snd_hda_codec_cleanup_stream(codec,
4352 						     mout->hp_out_nid[i]);
4353 	for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4354 		if (mout->extra_out_nid[i])
4355 			snd_hda_codec_cleanup_stream(codec,
4356 						     mout->extra_out_nid[i]);
4357 	mutex_lock(&codec->spdif_mutex);
4358 	if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4359 		cleanup_dig_out_stream(codec, mout->dig_out_nid);
4360 		mout->dig_out_used = 0;
4361 	}
4362 	mutex_unlock(&codec->spdif_mutex);
4363 	return 0;
4364 }
4365 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
4366 
4367 /**
4368  * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
4369  * @codec: the HDA codec
4370  * @pin: referred pin NID
4371  *
4372  * Guess the suitable VREF pin bits to be set as the pin-control value.
4373  * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
4374  */
snd_hda_get_default_vref(struct hda_codec * codec,hda_nid_t pin)4375 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
4376 {
4377 	unsigned int pincap;
4378 	unsigned int oldval;
4379 	oldval = snd_hda_codec_read(codec, pin, 0,
4380 				    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4381 	pincap = snd_hda_query_pin_caps(codec, pin);
4382 	pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
4383 	/* Exception: if the default pin setup is vref50, we give it priority */
4384 	if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
4385 		return AC_PINCTL_VREF_80;
4386 	else if (pincap & AC_PINCAP_VREF_50)
4387 		return AC_PINCTL_VREF_50;
4388 	else if (pincap & AC_PINCAP_VREF_100)
4389 		return AC_PINCTL_VREF_100;
4390 	else if (pincap & AC_PINCAP_VREF_GRD)
4391 		return AC_PINCTL_VREF_GRD;
4392 	return AC_PINCTL_VREF_HIZ;
4393 }
4394 EXPORT_SYMBOL_GPL(snd_hda_get_default_vref);
4395 
4396 /**
4397  * snd_hda_correct_pin_ctl - correct the pin ctl value for matching with the pin cap
4398  * @codec: the HDA codec
4399  * @pin: referred pin NID
4400  * @val: pin ctl value to audit
4401  */
snd_hda_correct_pin_ctl(struct hda_codec * codec,hda_nid_t pin,unsigned int val)4402 unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
4403 				     hda_nid_t pin, unsigned int val)
4404 {
4405 	static unsigned int cap_lists[][2] = {
4406 		{ AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
4407 		{ AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
4408 		{ AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
4409 		{ AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
4410 	};
4411 	unsigned int cap;
4412 
4413 	if (!val)
4414 		return 0;
4415 	cap = snd_hda_query_pin_caps(codec, pin);
4416 	if (!cap)
4417 		return val; /* don't know what to do... */
4418 
4419 	if (val & AC_PINCTL_OUT_EN) {
4420 		if (!(cap & AC_PINCAP_OUT))
4421 			val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
4422 		else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
4423 			val &= ~AC_PINCTL_HP_EN;
4424 	}
4425 
4426 	if (val & AC_PINCTL_IN_EN) {
4427 		if (!(cap & AC_PINCAP_IN))
4428 			val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
4429 		else {
4430 			unsigned int vcap, vref;
4431 			int i;
4432 			vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
4433 			vref = val & AC_PINCTL_VREFEN;
4434 			for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
4435 				if (vref == cap_lists[i][0] &&
4436 				    !(vcap & cap_lists[i][1])) {
4437 					if (i == ARRAY_SIZE(cap_lists) - 1)
4438 						vref = AC_PINCTL_VREF_HIZ;
4439 					else
4440 						vref = cap_lists[i + 1][0];
4441 				}
4442 			}
4443 			val &= ~AC_PINCTL_VREFEN;
4444 			val |= vref;
4445 		}
4446 	}
4447 
4448 	return val;
4449 }
4450 EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl);
4451 
4452 /**
4453  * _snd_hda_pin_ctl - Helper to set pin ctl value
4454  * @codec: the HDA codec
4455  * @pin: referred pin NID
4456  * @val: pin control value to set
4457  * @cached: access over codec pinctl cache or direct write
4458  *
4459  * This function is a helper to set a pin ctl value more safely.
4460  * It corrects the pin ctl value via snd_hda_correct_pin_ctl(), stores the
4461  * value in pin target array via snd_hda_codec_set_pin_target(), then
4462  * actually writes the value via either snd_hda_codec_update_cache() or
4463  * snd_hda_codec_write() depending on @cached flag.
4464  */
_snd_hda_set_pin_ctl(struct hda_codec * codec,hda_nid_t pin,unsigned int val,bool cached)4465 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
4466 			 unsigned int val, bool cached)
4467 {
4468 	val = snd_hda_correct_pin_ctl(codec, pin, val);
4469 	snd_hda_codec_set_pin_target(codec, pin, val);
4470 	if (cached)
4471 		return snd_hda_codec_update_cache(codec, pin, 0,
4472 				AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4473 	else
4474 		return snd_hda_codec_write(codec, pin, 0,
4475 					   AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4476 }
4477 EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl);
4478 
4479 /**
4480  * snd_hda_add_imux_item - Add an item to input_mux
4481  * @codec: the HDA codec
4482  * @imux: imux helper object
4483  * @label: the name of imux item to assign
4484  * @index: index number of imux item to assign
4485  * @type_idx: pointer to store the resultant label index
4486  *
4487  * When the same label is used already in the existing items, the number
4488  * suffix is appended to the label.  This label index number is stored
4489  * to type_idx when non-NULL pointer is given.
4490  */
snd_hda_add_imux_item(struct hda_codec * codec,struct hda_input_mux * imux,const char * label,int index,int * type_idx)4491 int snd_hda_add_imux_item(struct hda_codec *codec,
4492 			  struct hda_input_mux *imux, const char *label,
4493 			  int index, int *type_idx)
4494 {
4495 	int i, label_idx = 0;
4496 	if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
4497 		codec_err(codec, "hda_codec: Too many imux items!\n");
4498 		return -EINVAL;
4499 	}
4500 	for (i = 0; i < imux->num_items; i++) {
4501 		if (!strncmp(label, imux->items[i].label, strlen(label)))
4502 			label_idx++;
4503 	}
4504 	if (type_idx)
4505 		*type_idx = label_idx;
4506 	if (label_idx > 0)
4507 		snprintf(imux->items[imux->num_items].label,
4508 			 sizeof(imux->items[imux->num_items].label),
4509 			 "%s %d", label, label_idx);
4510 	else
4511 		strlcpy(imux->items[imux->num_items].label, label,
4512 			sizeof(imux->items[imux->num_items].label));
4513 	imux->items[imux->num_items].index = index;
4514 	imux->num_items++;
4515 	return 0;
4516 }
4517 EXPORT_SYMBOL_GPL(snd_hda_add_imux_item);
4518 
4519 /**
4520  * snd_hda_bus_reset - Reset the bus
4521  * @bus: HD-audio bus
4522  */
snd_hda_bus_reset(struct hda_bus * bus)4523 void snd_hda_bus_reset(struct hda_bus *bus)
4524 {
4525 	struct hda_codec *codec;
4526 
4527 	list_for_each_codec(codec, bus) {
4528 		/* FIXME: maybe a better way needed for forced reset */
4529 		cancel_delayed_work_sync(&codec->jackpoll_work);
4530 #ifdef CONFIG_PM
4531 		if (hda_codec_is_power_on(codec)) {
4532 			hda_call_codec_suspend(codec);
4533 			hda_call_codec_resume(codec);
4534 		}
4535 #endif
4536 	}
4537 }
4538 EXPORT_SYMBOL_GPL(snd_hda_bus_reset);
4539 
4540 /**
4541  * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4542  * @pcm: PCM caps bits
4543  * @buf: the string buffer to write
4544  * @buflen: the max buffer length
4545  *
4546  * used by hda_proc.c and hda_eld.c
4547  */
snd_print_pcm_bits(int pcm,char * buf,int buflen)4548 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4549 {
4550 	static unsigned int bits[] = { 8, 16, 20, 24, 32 };
4551 	int i, j;
4552 
4553 	for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4554 		if (pcm & (AC_SUPPCM_BITS_8 << i))
4555 			j += snprintf(buf + j, buflen - j,  " %d", bits[i]);
4556 
4557 	buf[j] = '\0'; /* necessary when j == 0 */
4558 }
4559 EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
4560 
4561 MODULE_DESCRIPTION("HDA codec core");
4562 MODULE_LICENSE("GPL");
4563