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