projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: hda - Implement uncached version of parameter reads
[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:
aa2936f5 140 snd_hda_power_up(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);
aa2936f5 148 snd_hda_power_down(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
01751f54
TI		 810static void init_hda_cache(struct hda_cache_rec *cache,
811 unsigned int record_size);
1fcaee6e 812static void free_hda_cache(struct hda_cache_rec *cache);
01751f54 813
3fdf1469
TI		 814/* release all pincfg lists */
815static void free_init_pincfgs(struct hda_codec *codec)
3be14149 816{
346ff70f 817 snd_array_free(&codec->driver_pins);
648a8d27 818#ifdef CONFIG_SND_HDA_RECONFIG
346ff70f 819 snd_array_free(&codec->user_pins);
3be14149 820#endif
3be14149
TI		 821 snd_array_free(&codec->init_pins);
822}
823
eb541337
TI		 824/*
825 * audio-converter setup caches
826 */
827struct hda_cvt_setup {
828 hda_nid_t nid;
829 u8 stream_tag;
830 u8 channel_id;
831 u16 format_id;
832 unsigned char active; /* cvt is currently used */
833 unsigned char dirty; /* setups should be cleared */
834};
835
836/* get or create a cache entry for the given audio converter NID */
837static struct hda_cvt_setup *
838get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
839{
840 struct hda_cvt_setup *p;
841 int i;
842
843 for (i = 0; i < codec->cvt_setups.used; i++) {
844 p = snd_array_elem(&codec->cvt_setups, i);
845 if (p->nid == nid)
846 return p;
847 }
848 p = snd_array_new(&codec->cvt_setups);
849 if (p)
850 p->nid = nid;
851 return p;
852}
853
bbbc7e85
TI		 854/*
855 * PCM device
856 */
857static void release_pcm(struct kref *kref)
858{
859 struct hda_pcm *pcm = container_of(kref, struct hda_pcm, kref);
860
861 if (pcm->pcm)
862 snd_device_free(pcm->codec->card, pcm->pcm);
863 clear_bit(pcm->device, pcm->codec->bus->pcm_dev_bits);
864 kfree(pcm->name);
865 kfree(pcm);
866}
867
868void snd_hda_codec_pcm_put(struct hda_pcm *pcm)
869{
870 kref_put(&pcm->kref, release_pcm);
871}
872EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_put);
873
874struct hda_pcm *snd_hda_codec_pcm_new(struct hda_codec *codec,
875 const char *fmt, ...)
876{
877 struct hda_pcm *pcm;
878 va_list args;
879
880 va_start(args, fmt);
881 pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
882 if (!pcm)
883 return NULL;
884
885 pcm->codec = codec;
886 kref_init(&pcm->kref);
887 pcm->name = kvasprintf(GFP_KERNEL, fmt, args);
888 if (!pcm->name) {
889 kfree(pcm);
890 return NULL;
891 }
892
893 list_add_tail(&pcm->list, &codec->pcm_list_head);
894 return pcm;
895}
896EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_new);
897
9a6246ff
TI		 898/*
899 * codec destructor
900 */
bbbc7e85
TI		 901static void codec_release_pcms(struct hda_codec *codec)
902{
903 struct hda_pcm *pcm, *n;
904
905 list_for_each_entry_safe(pcm, n, &codec->pcm_list_head, list) {
906 list_del_init(&pcm->list);
9a6246ff
TI		 907 if (pcm->pcm)
908 snd_device_disconnect(codec->card, pcm->pcm);
bbbc7e85
TI		 909 snd_hda_codec_pcm_put(pcm);
910 }
911}
912
9a6246ff
TI		 913void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec)
914{
c4c2533f
TI		 915 if (codec->registered) {
916 /* pm_runtime_put() is called in snd_hdac_device_exit() */
917 pm_runtime_get_noresume(hda_codec_dev(codec));
918 pm_runtime_disable(hda_codec_dev(codec));
919 codec->registered = 0;
920 }
921
9a6246ff 922 cancel_delayed_work_sync(&codec->jackpoll_work);
9a6246ff
TI		 923 if (!codec->in_freeing)
924 snd_hda_ctls_clear(codec);
925 codec_release_pcms(codec);
926 snd_hda_detach_beep_device(codec);
927 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
928 snd_hda_jack_tbl_clear(codec);
929 codec->proc_widget_hook = NULL;
930 codec->spec = NULL;
931
932 free_hda_cache(&codec->amp_cache);
933 free_hda_cache(&codec->cmd_cache);
934 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
935 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
936
937 /* free only driver_pins so that init_pins + user_pins are restored */
938 snd_array_free(&codec->driver_pins);
939 snd_array_free(&codec->cvt_setups);
940 snd_array_free(&codec->spdif_out);
941 snd_array_free(&codec->verbs);
942 codec->preset = NULL;
943 codec->slave_dig_outs = NULL;
944 codec->spdif_status_reset = 0;
945 snd_array_free(&codec->mixers);
946 snd_array_free(&codec->nids);
947 remove_conn_list(codec);
4d75faa0 948 snd_hdac_regmap_exit(&codec->core);
9a6246ff
TI		 949}
950
d819387e 951static unsigned int hda_set_power_state(struct hda_codec *codec,
bb6ac72f
TI		 952 unsigned int power_state);
953
c4c2533f
TI		 954/* also called from hda_bind.c */
955void snd_hda_codec_register(struct hda_codec *codec)
13aeaf68 956{
c4c2533f
TI		 957 if (codec->registered)
958 return;
959 if (device_is_registered(hda_codec_dev(codec))) {
960 snd_hda_register_beep_device(codec);
cc72da7d 961 pm_runtime_enable(hda_codec_dev(codec));
c4c2533f
TI		 962 /* it was powered up in snd_hda_codec_new(), now all done */
963 snd_hda_power_down(codec);
964 codec->registered = 1;
965 }
966}
967
968static int snd_hda_codec_dev_register(struct snd_device *device)
969{
970 snd_hda_codec_register(device->device_data);
d604b399 971 return 0;
13aeaf68
TI		 972}
973
974static int snd_hda_codec_dev_disconnect(struct snd_device *device)
975{
976 struct hda_codec *codec = device->device_data;
977
d604b399 978 snd_hda_detach_beep_device(codec);
13aeaf68
TI		 979 return 0;
980}
981
2565c899
TI		 982static int snd_hda_codec_dev_free(struct snd_device *device)
983{
d56db741
TI		 984 struct hda_codec *codec = device->device_data;
985
986 codec->in_freeing = 1;
3256be65 987 snd_hdac_device_unregister(&codec->core);
d56db741 988 put_device(hda_codec_dev(codec));
2565c899
TI		 989 return 0;
990}
991
13aeaf68
TI		 992static void snd_hda_codec_dev_release(struct device *dev)
993{
d56db741
TI		 994 struct hda_codec *codec = dev_to_hda_codec(dev);
995
996 free_init_pincfgs(codec);
7639a06c 997 snd_hdac_device_exit(&codec->core);
d56db741
TI		 998 snd_hda_sysfs_clear(codec);
999 free_hda_cache(&codec->amp_cache);
1000 free_hda_cache(&codec->cmd_cache);
d56db741
TI		 1001 kfree(codec->modelname);
1002 kfree(codec->wcaps);
d56db741 1003 kfree(codec);
13aeaf68
TI		 1004}
1005
1da177e4
LT		 1006/**
1007 * snd_hda_codec_new - create a HDA codec
1008 * @bus: the bus to assign
1009 * @codec_addr: the codec address
1010 * @codecp: the pointer to store the generated codec
1011 *
1012 * Returns 0 if successful, or a negative error code.
1013 */
6efdd851
TI		 1014int snd_hda_codec_new(struct hda_bus *bus, struct snd_card *card,
1015 unsigned int codec_addr, struct hda_codec **codecp)
1da177e4
LT		 1016{
1017 struct hda_codec *codec;
ba443687 1018 char component[31];
d819387e 1019 hda_nid_t fg;
1da177e4 1020 int err;
2565c899 1021 static struct snd_device_ops dev_ops = {
13aeaf68
TI		 1022 .dev_register = snd_hda_codec_dev_register,
1023 .dev_disconnect = snd_hda_codec_dev_disconnect,
2565c899
TI		 1024 .dev_free = snd_hda_codec_dev_free,
1025 };
1da177e4 1026
da3cec35
TI		 1027 if (snd_BUG_ON(!bus))
1028 return -EINVAL;
1029 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1030 return -EINVAL;
1da177e4 1031
e560d8d8 1032 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
f4de8fe6 1033 if (!codec)
1da177e4 1034 return -ENOMEM;
1da177e4 1035
7639a06c
TI		 1036 sprintf(component, "hdaudioC%dD%d", card->number, codec_addr);
1037 err = snd_hdac_device_init(&codec->core, &bus->core, component,
1038 codec_addr);
1039 if (err < 0) {
1040 kfree(codec);
1041 return err;
1042 }
d068ebc2 1043
7639a06c
TI		 1044 codec->core.dev.release = snd_hda_codec_dev_release;
1045 codec->core.type = HDA_DEV_LEGACY;
05852448 1046 codec->core.exec_verb = codec_exec_verb;
13aeaf68 1047
1da177e4 1048 codec->bus = bus;
6efdd851 1049 codec->card = card;
1da177e4 1050 codec->addr = codec_addr;
62932df8 1051 mutex_init(&codec->spdif_mutex);
5a9e02e9 1052 mutex_init(&codec->control_mutex);
c3b6bcc2 1053 mutex_init(&codec->hash_mutex);
01751f54 1054 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
b3ac5636 1055 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
5b0cb1d8
JK		 1056 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1057 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
3be14149 1058 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
346ff70f 1059 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
eb541337 1060 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
7c935976 1061 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
361dab3e 1062 snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
c9ce6b26 1063 snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
ee8e765b 1064 INIT_LIST_HEAD(&codec->conn_list);
bbbc7e85 1065 INIT_LIST_HEAD(&codec->pcm_list_head);
ee8e765b 1066
26a6cb6c 1067 INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
7f132927 1068 codec->depop_delay = -1;
f5662e1c 1069 codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
1da177e4 1070
83012a7c 1071#ifdef CONFIG_PM
cc72da7d 1072 codec->power_jiffies = jiffies;
cb53c626
TI		 1073#endif
1074
648a8d27
TI		 1075 snd_hda_sysfs_init(codec);
1076
c382a9f0
TI		 1077 if (codec->bus->modelname) {
1078 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1079 if (!codec->modelname) {
13aeaf68
TI		 1080 err = -ENODEV;
1081 goto error;
c382a9f0
TI		 1082 }
1083 }
1084
7639a06c 1085 fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
d819387e 1086 err = read_widget_caps(codec, fg);
f4de8fe6 1087 if (err < 0)
3be14149 1088 goto error;
3be14149
TI		 1089 err = read_pin_defaults(codec);
1090 if (err < 0)
1091 goto error;
54d17403 1092
bb6ac72f 1093 /* power-up all before initialization */
d819387e 1094 hda_set_power_state(codec, AC_PWRST_D0);
bb6ac72f 1095
6c1f45ea
TI		 1096 snd_hda_codec_proc_new(codec);
1097
6c1f45ea 1098 snd_hda_create_hwdep(codec);
6c1f45ea 1099
7639a06c
TI		 1100 sprintf(component, "HDA:%08x,%08x,%08x", codec->core.vendor_id,
1101 codec->core.subsystem_id, codec->core.revision_id);
6efdd851 1102 snd_component_add(card, component);
6c1f45ea 1103
6efdd851 1104 err = snd_device_new(card, SNDRV_DEV_CODEC, codec, &dev_ops);
2565c899
TI		 1105 if (err < 0)
1106 goto error;
1107
6c1f45ea
TI		 1108 if (codecp)
1109 *codecp = codec;
1110 return 0;
3be14149
TI		 1111
1112 error:
d56db741 1113 put_device(hda_codec_dev(codec));
3be14149 1114 return err;
6c1f45ea 1115}
2698ea98 1116EXPORT_SYMBOL_GPL(snd_hda_codec_new);
6c1f45ea 1117
95a962c3
TI		 1118/**
1119 * snd_hda_codec_update_widgets - Refresh widget caps and pin defaults
1120 * @codec: the HDA codec
1121 *
1122 * Forcibly refresh the all widget caps and the init pin configurations of
1123 * the given codec.
1124 */
a15d05db
ML		 1125int snd_hda_codec_update_widgets(struct hda_codec *codec)
1126{
1127 hda_nid_t fg;
1128 int err;
1129
7639a06c
TI		 1130 err = snd_hdac_refresh_widgets(&codec->core);
1131 if (err < 0)
1132 return err;
1133
a15d05db
ML		 1134 /* Assume the function group node does not change,
1135 * only the widget nodes may change.
1136 */
1137 kfree(codec->wcaps);
7639a06c 1138 fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
a15d05db 1139 err = read_widget_caps(codec, fg);
f4de8fe6 1140 if (err < 0)
a15d05db 1141 return err;
a15d05db
ML		 1142
1143 snd_array_free(&codec->init_pins);
1144 err = read_pin_defaults(codec);
1145
1146 return err;
1147}
2698ea98 1148EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets);
a15d05db 1149
ed360813
TI		 1150/* update the stream-id if changed */
1151static void update_pcm_stream_id(struct hda_codec *codec,
1152 struct hda_cvt_setup *p, hda_nid_t nid,
1153 u32 stream_tag, int channel_id)
1154{
1155 unsigned int oldval, newval;
1156
1157 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1158 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1159 newval = (stream_tag << 4) | channel_id;
1160 if (oldval != newval)
1161 snd_hda_codec_write(codec, nid, 0,
1162 AC_VERB_SET_CHANNEL_STREAMID,
1163 newval);
1164 p->stream_tag = stream_tag;
1165 p->channel_id = channel_id;
1166 }
1167}
1168
1169/* update the format-id if changed */
1170static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1171 hda_nid_t nid, int format)
1172{
1173 unsigned int oldval;
1174
1175 if (p->format_id != format) {
1176 oldval = snd_hda_codec_read(codec, nid, 0,
1177 AC_VERB_GET_STREAM_FORMAT, 0);
1178 if (oldval != format) {
1179 msleep(1);
1180 snd_hda_codec_write(codec, nid, 0,
1181 AC_VERB_SET_STREAM_FORMAT,
1182 format);
1183 }
1184 p->format_id = format;
1185 }
1186}
1187
1da177e4
LT		 1188/**
1189 * snd_hda_codec_setup_stream - set up the codec for streaming
1190 * @codec: the CODEC to set up
1191 * @nid: the NID to set up
1192 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1193 * @channel_id: channel id to pass, zero based.
1194 * @format: stream format.
1195 */
0ba21762
TI		 1196void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1197 u32 stream_tag,
1da177e4
LT		 1198 int channel_id, int format)
1199{
3f50ac6a 1200 struct hda_codec *c;
eb541337 1201 struct hda_cvt_setup *p;
62b7e5e0 1202 int type;
eb541337
TI		 1203 int i;
1204
0ba21762 1205 if (!nid)
d21b37ea
TI		 1206 return;
1207
4e76a883
TI		 1208 codec_dbg(codec,
1209 "hda_codec_setup_stream: NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1210 nid, stream_tag, channel_id, format);
eb541337 1211 p = get_hda_cvt_setup(codec, nid);
6c35ae3c 1212 if (!p)
eb541337 1213 return;
ed360813 1214
e6feb5d0
TI		 1215 if (codec->patch_ops.stream_pm)
1216 codec->patch_ops.stream_pm(codec, nid, true);
ed360813
TI		 1217 if (codec->pcm_format_first)
1218 update_pcm_format(codec, p, nid, format);
1219 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1220 if (!codec->pcm_format_first)
1221 update_pcm_format(codec, p, nid, format);
1222
eb541337
TI		 1223 p->active = 1;
1224 p->dirty = 0;
1225
1226 /* make other inactive cvts with the same stream-tag dirty */
62b7e5e0 1227 type = get_wcaps_type(get_wcaps(codec, nid));
d068ebc2 1228 list_for_each_codec(c, codec->bus) {
3f50ac6a
TI		 1229 for (i = 0; i < c->cvt_setups.used; i++) {
1230 p = snd_array_elem(&c->cvt_setups, i);
62b7e5e0 1231 if (!p->active && p->stream_tag == stream_tag &&
54c2a89f 1232 get_wcaps_type(get_wcaps(c, p->nid)) == type)
3f50ac6a
TI		 1233 p->dirty = 1;
1234 }
eb541337 1235 }
1da177e4 1236}
2698ea98 1237EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream);
1da177e4 1238
f0cea797
TI		 1239static void really_cleanup_stream(struct hda_codec *codec,
1240 struct hda_cvt_setup *q);
1241
d5191e50 1242/**
f0cea797 1243 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
d5191e50
TI		 1244 * @codec: the CODEC to clean up
1245 * @nid: the NID to clean up
f0cea797 1246 * @do_now: really clean up the stream instead of clearing the active flag
d5191e50 1247 */
f0cea797
TI		 1248void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1249 int do_now)
888afa15 1250{
eb541337
TI		 1251 struct hda_cvt_setup *p;
1252
888afa15
TI		 1253 if (!nid)
1254 return;
1255
0e7adbe2
TI		 1256 if (codec->no_sticky_stream)
1257 do_now = 1;
1258
4e76a883 1259 codec_dbg(codec, "hda_codec_cleanup_stream: NID=0x%x\n", nid);
eb541337 1260 p = get_hda_cvt_setup(codec, nid);
6c35ae3c 1261 if (p) {
f0cea797
TI		 1262 /* here we just clear the active flag when do_now isn't set;
1263 * actual clean-ups will be done later in
1264 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1265 */
1266 if (do_now)
1267 really_cleanup_stream(codec, p);
1268 else
1269 p->active = 0;
1270 }
eb541337 1271}
2698ea98 1272EXPORT_SYMBOL_GPL(__snd_hda_codec_cleanup_stream);
eb541337
TI		 1273
1274static void really_cleanup_stream(struct hda_codec *codec,
1275 struct hda_cvt_setup *q)
1276{
1277 hda_nid_t nid = q->nid;
218264ae
TI		 1278 if (q->stream_tag || q->channel_id)
1279 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1280 if (q->format_id)
1281 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1282);
eb541337
TI		 1283 memset(q, 0, sizeof(*q));
1284 q->nid = nid;
e6feb5d0
TI		 1285 if (codec->patch_ops.stream_pm)
1286 codec->patch_ops.stream_pm(codec, nid, false);
eb541337
TI		 1287}
1288
1289/* clean up the all conflicting obsolete streams */
1290static void purify_inactive_streams(struct hda_codec *codec)
1291{
3f50ac6a 1292 struct hda_codec *c;
eb541337
TI		 1293 int i;
1294
d068ebc2 1295 list_for_each_codec(c, codec->bus) {
3f50ac6a
TI		 1296 for (i = 0; i < c->cvt_setups.used; i++) {
1297 struct hda_cvt_setup *p;
1298 p = snd_array_elem(&c->cvt_setups, i);
1299 if (p->dirty)
1300 really_cleanup_stream(c, p);
1301 }
eb541337
TI		 1302 }
1303}
1304
2a43952a 1305#ifdef CONFIG_PM
eb541337
TI		 1306/* clean up all streams; called from suspend */
1307static void hda_cleanup_all_streams(struct hda_codec *codec)
1308{
1309 int i;
1310
1311 for (i = 0; i < codec->cvt_setups.used; i++) {
1312 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1313 if (p->stream_tag)
1314 really_cleanup_stream(codec, p);
1315 }
888afa15 1316}
1c7276cf 1317#endif
888afa15 1318
1da177e4
LT		 1319/*
1320 * amp access functions
1321 */
1322
4a19faee 1323/* FIXME: more better hash key? */
28aedaf7 1324#define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1327a32b 1325#define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
92c7c8a7
TI		 1326#define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1327#define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1da177e4 1328#define INFO_AMP_CAPS (1<<0)
4a19faee 1329#define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1da177e4
LT		 1330
1331/* initialize the hash table */
6a0f56a7 1332static void init_hda_cache(struct hda_cache_rec *cache,
01751f54
TI		 1333 unsigned int record_size)
1334{
1335 memset(cache, 0, sizeof(*cache));
1336 memset(cache->hash, 0xff, sizeof(cache->hash));
603c4019 1337 snd_array_init(&cache->buf, record_size, 64);
01751f54
TI		 1338}
1339
1fcaee6e 1340static void free_hda_cache(struct hda_cache_rec *cache)
1da177e4 1341{
603c4019 1342 snd_array_free(&cache->buf);
1da177e4
LT		 1343}
1344
1345/* query the hash. allocate an entry if not found. */
a68d5a54 1346static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1da177e4 1347{
01751f54
TI		 1348 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1349 u16 cur = cache->hash[idx];
1350 struct hda_cache_head *info;
1da177e4
LT		 1351
1352 while (cur != 0xffff) {
f43aa025 1353 info = snd_array_elem(&cache->buf, cur);
1da177e4
LT		 1354 if (info->key == key)
1355 return info;
1356 cur = info->next;
1357 }
a68d5a54
TI		 1358 return NULL;
1359}
1da177e4 1360
a68d5a54
TI		 1361/* query the hash. allocate an entry if not found. */
1362static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1363 u32 key)
1364{
1365 struct hda_cache_head *info = get_hash(cache, key);
1366 if (!info) {
1367 u16 idx, cur;
1368 /* add a new hash entry */
1369 info = snd_array_new(&cache->buf);
1370 if (!info)
1371 return NULL;
1372 cur = snd_array_index(&cache->buf, info);
1373 info->key = key;
1374 info->val = 0;
c370dd6e 1375 info->dirty = 0;
a68d5a54
TI		 1376 idx = key % (u16)ARRAY_SIZE(cache->hash);
1377 info->next = cache->hash[idx];
1378 cache->hash[idx] = cur;
1379 }
1da177e4
LT		 1380 return info;
1381}
1382
01751f54
TI		 1383/* query and allocate an amp hash entry */
1384static inline struct hda_amp_info *
1385get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1386{
1387 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1388}
1389
c3b6bcc2
TI		 1390/* overwrite the value with the key in the caps hash */
1391static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1392{
1393 struct hda_amp_info *info;
1394
1395 mutex_lock(&codec->hash_mutex);
1396 info = get_alloc_amp_hash(codec, key);
1397 if (!info) {
1398 mutex_unlock(&codec->hash_mutex);
1399 return -EINVAL;
1400 }
1401 info->amp_caps = val;
1402 info->head.val |= INFO_AMP_CAPS;
1403 mutex_unlock(&codec->hash_mutex);
1404 return 0;
1405}
1406
1407/* query the value from the caps hash; if not found, fetch the current
1408 * value from the given function and store in the hash
1409 */
1410static unsigned int
1411query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1412 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1413{
1414 struct hda_amp_info *info;
1415 unsigned int val;
1416
1417 mutex_lock(&codec->hash_mutex);
1418 info = get_alloc_amp_hash(codec, key);
1419 if (!info) {
1420 mutex_unlock(&codec->hash_mutex);
1421 return 0;
1422 }
1423 if (!(info->head.val & INFO_AMP_CAPS)) {
1424 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1425 val = func(codec, nid, dir);
1426 write_caps_hash(codec, key, val);
1427 } else {
1428 val = info->amp_caps;
1429 mutex_unlock(&codec->hash_mutex);
1430 }
1431 return val;
1432}
1433
1434static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1435 int direction)
1436{
1437 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
7639a06c 1438 nid = codec->core.afg;
c3b6bcc2
TI		 1439 return snd_hda_param_read(codec, nid,
1440 direction == HDA_OUTPUT ?
1441 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1442}
1443
d5191e50
TI		 1444/**
1445 * query_amp_caps - query AMP capabilities
1446 * @codec: the HD-auio codec
1447 * @nid: the NID to query
1448 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1449 *
1450 * Query AMP capabilities for the given widget and direction.
1451 * Returns the obtained capability bits.
1452 *
1453 * When cap bits have been already read, this doesn't read again but
1454 * returns the cached value.
1da177e4 1455 */
09a99959 1456u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1da177e4 1457{
c3b6bcc2
TI		 1458 return query_caps_hash(codec, nid, direction,
1459 HDA_HASH_KEY(nid, direction, 0),
1460 read_amp_cap);
1da177e4 1461}
2698ea98 1462EXPORT_SYMBOL_GPL(query_amp_caps);
1da177e4 1463
861a04ed
DH		 1464/**
1465 * snd_hda_check_amp_caps - query AMP capabilities
1466 * @codec: the HD-audio codec
1467 * @nid: the NID to query
1468 * @dir: either #HDA_INPUT or #HDA_OUTPUT
a11e9b16 1469 * @bits: bit mask to check the result
861a04ed
DH		 1470 *
1471 * Check whether the widget has the given amp capability for the direction.
1472 */
1473bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
1474 int dir, unsigned int bits)
1475{
1476 if (!nid)
1477 return false;
1478 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
1479 if (query_amp_caps(codec, nid, dir) & bits)
1480 return true;
1481 return false;
1482}
1483EXPORT_SYMBOL_GPL(snd_hda_check_amp_caps);
1484
d5191e50
TI		 1485/**
1486 * snd_hda_override_amp_caps - Override the AMP capabilities
1487 * @codec: the CODEC to clean up
1488 * @nid: the NID to clean up
a11e9b16 1489 * @dir: either #HDA_INPUT or #HDA_OUTPUT
d5191e50
TI		 1490 * @caps: the capability bits to set
1491 *
1492 * Override the cached AMP caps bits value by the given one.
1493 * This function is useful if the driver needs to adjust the AMP ranges,
1494 * e.g. limit to 0dB, etc.
1495 *
1496 * Returns zero if successful or a negative error code.
1497 */
897cc188
TI		 1498int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1499 unsigned int caps)
1500{
c3b6bcc2 1501 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
897cc188 1502}
2698ea98 1503EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
1327a32b 1504
c3b6bcc2
TI		 1505static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1506 int dir)
92c7c8a7
TI		 1507{
1508 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1509}
1510
d5191e50
TI		 1511/**
1512 * snd_hda_query_pin_caps - Query PIN capabilities
1513 * @codec: the HD-auio codec
1514 * @nid: the NID to query
1515 *
1516 * Query PIN capabilities for the given widget.
1517 * Returns the obtained capability bits.
1518 *
1519 * When cap bits have been already read, this doesn't read again but
1520 * returns the cached value.
1521 */
92c7c8a7
TI		 1522u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1523{
c3b6bcc2 1524 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
92c7c8a7
TI		 1525 read_pin_cap);
1526}
2698ea98 1527EXPORT_SYMBOL_GPL(snd_hda_query_pin_caps);
897cc188 1528
f57c2565
TI		 1529/**
1530 * snd_hda_override_pin_caps - Override the pin capabilities
1531 * @codec: the CODEC
1532 * @nid: the NID to override
1533 * @caps: the capability bits to set
1534 *
1535 * Override the cached PIN capabilitiy bits value by the given one.
1536 *
1537 * Returns zero if successful or a negative error code.
1538 */
1539int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1540 unsigned int caps)
1541{
c3b6bcc2 1542 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
f57c2565 1543}
2698ea98 1544EXPORT_SYMBOL_GPL(snd_hda_override_pin_caps);
f57c2565 1545
c3b6bcc2
TI		 1546/* read or sync the hash value with the current value;
1547 * call within hash_mutex
1da177e4 1548 */
c3b6bcc2
TI		 1549static struct hda_amp_info *
1550update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
280e57d5 1551 int direction, int index, bool init_only)
1da177e4 1552{
c3b6bcc2
TI		 1553 struct hda_amp_info *info;
1554 unsigned int parm, val = 0;
1555 bool val_read = false;
1da177e4 1556
c3b6bcc2
TI		 1557 retry:
1558 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1559 if (!info)
1560 return NULL;
1561 if (!(info->head.val & INFO_AMP_VOL(ch))) {
1562 if (!val_read) {
1563 mutex_unlock(&codec->hash_mutex);
1564 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1565 parm |= direction == HDA_OUTPUT ?
1566 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1567 parm |= index;
1568 val = snd_hda_codec_read(codec, nid, 0,
0ba21762 1569 AC_VERB_GET_AMP_GAIN_MUTE, parm);
c3b6bcc2
TI		 1570 val &= 0xff;
1571 val_read = true;
1572 mutex_lock(&codec->hash_mutex);
1573 goto retry;
1574 }
1575 info->vol[ch] = val;
1576 info->head.val |= INFO_AMP_VOL(ch);
280e57d5
TI		 1577 } else if (init_only)
1578 return NULL;
c3b6bcc2 1579 return info;
1da177e4
LT		 1580}
1581
1582/*
c3b6bcc2 1583 * write the current volume in info to the h/w
1da177e4 1584 */
2ce4886a 1585static void put_vol_mute(struct hda_codec *codec, unsigned int amp_caps,
0ba21762
TI		 1586 hda_nid_t nid, int ch, int direction, int index,
1587 int val)
1da177e4
LT		 1588{
1589 u32 parm;
1590
1591 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1592 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1593 parm |= index << AC_AMP_SET_INDEX_SHIFT;
2ce4886a
TI		 1594 if ((val & HDA_AMP_MUTE) && !(amp_caps & AC_AMPCAP_MUTE) &&
1595 (amp_caps & AC_AMPCAP_MIN_MUTE))
3868137e
TI		 1596 ; /* set the zero value as a fake mute */
1597 else
1598 parm |= val;
1da177e4
LT		 1599 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1600}
1601
d5191e50
TI		 1602/**
1603 * snd_hda_codec_amp_read - Read AMP value
1604 * @codec: HD-audio codec
1605 * @nid: NID to read the AMP value
1606 * @ch: channel (left=0 or right=1)
1607 * @direction: #HDA_INPUT or #HDA_OUTPUT
1608 * @index: the index value (only for input direction)
1609 *
1610 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1da177e4 1611 */
834be88d
TI		 1612int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1613 int direction, int index)
1da177e4 1614{
0ba21762 1615 struct hda_amp_info *info;
c3b6bcc2
TI		 1616 unsigned int val = 0;
1617
1618 mutex_lock(&codec->hash_mutex);
280e57d5 1619 info = update_amp_hash(codec, nid, ch, direction, index, false);
c3b6bcc2
TI		 1620 if (info)
1621 val = info->vol[ch];
1622 mutex_unlock(&codec->hash_mutex);
1623 return val;
1da177e4 1624}
2698ea98 1625EXPORT_SYMBOL_GPL(snd_hda_codec_amp_read);
1da177e4 1626
280e57d5
TI		 1627static int codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1628 int direction, int idx, int mask, int val,
781c7b96 1629 bool init_only, bool cache_only)
1da177e4 1630{
0ba21762 1631 struct hda_amp_info *info;
2ce4886a 1632 unsigned int caps;
4a19faee 1633
46712646
TI		 1634 if (snd_BUG_ON(mask & ~0xff))
1635 mask &= 0xff;
4a19faee 1636 val &= mask;
c3b6bcc2
TI		 1637
1638 mutex_lock(&codec->hash_mutex);
280e57d5 1639 info = update_amp_hash(codec, nid, ch, direction, idx, init_only);
c3b6bcc2
TI		 1640 if (!info) {
1641 mutex_unlock(&codec->hash_mutex);
1642 return 0;
1643 }
1644 val |= info->vol[ch] & ~mask;
1645 if (info->vol[ch] == val) {
1646 mutex_unlock(&codec->hash_mutex);
1da177e4 1647 return 0;
c3b6bcc2
TI		 1648 }
1649 info->vol[ch] = val;
781c7b96 1650 info->head.dirty |= cache_only;
2ce4886a 1651 caps = info->amp_caps;
c3b6bcc2 1652 mutex_unlock(&codec->hash_mutex);
de1e37b7 1653 if (!cache_only)
2ce4886a 1654 put_vol_mute(codec, caps, nid, ch, direction, idx, val);
1da177e4
LT		 1655 return 1;
1656}
280e57d5
TI		 1657
1658/**
1659 * snd_hda_codec_amp_update - update the AMP value
1660 * @codec: HD-audio codec
1661 * @nid: NID to read the AMP value
1662 * @ch: channel (left=0 or right=1)
1663 * @direction: #HDA_INPUT or #HDA_OUTPUT
1664 * @idx: the index value (only for input direction)
1665 * @mask: bit mask to set
1666 * @val: the bits value to set
1667 *
1668 * Update the AMP value with a bit mask.
1669 * Returns 0 if the value is unchanged, 1 if changed.
1670 */
1671int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1672 int direction, int idx, int mask, int val)
1673{
781c7b96
TI		 1674 return codec_amp_update(codec, nid, ch, direction, idx, mask, val,
1675 false, codec->cached_write);
280e57d5 1676}
2698ea98 1677EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update);
1da177e4 1678
d5191e50
TI		 1679/**
1680 * snd_hda_codec_amp_stereo - update the AMP stereo values
1681 * @codec: HD-audio codec
1682 * @nid: NID to read the AMP value
1683 * @direction: #HDA_INPUT or #HDA_OUTPUT
1684 * @idx: the index value (only for input direction)
1685 * @mask: bit mask to set
1686 * @val: the bits value to set
1687 *
1688 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1689 * stereo widget with the same mask and value.
47fd830a
TI		 1690 */
1691int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1692 int direction, int idx, int mask, int val)
1693{
1694 int ch, ret = 0;
46712646
TI		 1695
1696 if (snd_BUG_ON(mask & ~0xff))
1697 mask &= 0xff;
47fd830a
TI		 1698 for (ch = 0; ch < 2; ch++)
1699 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1700 idx, mask, val);
1701 return ret;
1702}
2698ea98 1703EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
47fd830a 1704
95a962c3
TI		 1705/**
1706 * snd_hda_codec_amp_init - initialize the AMP value
1707 * @codec: the HDA codec
1708 * @nid: NID to read the AMP value
1709 * @ch: channel (left=0 or right=1)
1710 * @dir: #HDA_INPUT or #HDA_OUTPUT
1711 * @idx: the index value (only for input direction)
1712 * @mask: bit mask to set
1713 * @val: the bits value to set
1714 *
1715 * Works like snd_hda_codec_amp_update() but it writes the value only at
280e57d5
TI		 1716 * the first access. If the amp was already initialized / updated beforehand,
1717 * this does nothing.
1718 */
1719int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
1720 int dir, int idx, int mask, int val)
1721{
781c7b96
TI		 1722 return codec_amp_update(codec, nid, ch, dir, idx, mask, val, true,
1723 codec->cached_write);
280e57d5 1724}
2698ea98 1725EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init);
280e57d5 1726
95a962c3
TI		 1727/**
1728 * snd_hda_codec_amp_init_stereo - initialize the stereo AMP value
1729 * @codec: the HDA codec
1730 * @nid: NID to read the AMP value
1731 * @dir: #HDA_INPUT or #HDA_OUTPUT
1732 * @idx: the index value (only for input direction)
1733 * @mask: bit mask to set
1734 * @val: the bits value to set
1735 *
1736 * Call snd_hda_codec_amp_init() for both stereo channels.
1737 */
280e57d5
TI		 1738int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
1739 int dir, int idx, int mask, int val)
1740{
1741 int ch, ret = 0;
1742
1743 if (snd_BUG_ON(mask & ~0xff))
1744 mask &= 0xff;
1745 for (ch = 0; ch < 2; ch++)
1746 ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
1747 idx, mask, val);
1748 return ret;
1749}
2698ea98 1750EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo);
280e57d5 1751
d5191e50
TI		 1752/**
1753 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1754 * @codec: HD-audio codec
1755 *
1756 * Resume the all amp commands from the cache.
1757 */
b3ac5636
TI		 1758void snd_hda_codec_resume_amp(struct hda_codec *codec)
1759{
b3ac5636
TI		 1760 int i;
1761
c370dd6e 1762 mutex_lock(&codec->hash_mutex);
aa88a355 1763 codec->cached_write = 0;
c370dd6e
TI		 1764 for (i = 0; i < codec->amp_cache.buf.used; i++) {
1765 struct hda_amp_info *buffer;
1766 u32 key;
b3ac5636
TI		 1767 hda_nid_t nid;
1768 unsigned int idx, dir, ch;
2ce4886a 1769 struct hda_amp_info info;
c370dd6e
TI		 1770
1771 buffer = snd_array_elem(&codec->amp_cache.buf, i);
8565f052
TI		 1772 if (!buffer->head.dirty)
1773 continue;
1774 buffer->head.dirty = 0;
2ce4886a
TI		 1775 info = *buffer;
1776 key = info.head.key;
b3ac5636
TI		 1777 if (!key)
1778 continue;
1779 nid = key & 0xff;
1780 idx = (key >> 16) & 0xff;
1781 dir = (key >> 24) & 0xff;
1782 for (ch = 0; ch < 2; ch++) {
2ce4886a 1783 if (!(info.head.val & INFO_AMP_VOL(ch)))
b3ac5636 1784 continue;
c370dd6e 1785 mutex_unlock(&codec->hash_mutex);
2ce4886a
TI		 1786 put_vol_mute(codec, info.amp_caps, nid, ch, dir, idx,
1787 info.vol[ch]);
c370dd6e 1788 mutex_lock(&codec->hash_mutex);
b3ac5636
TI		 1789 }
1790 }
c370dd6e 1791 mutex_unlock(&codec->hash_mutex);
b3ac5636 1792}
2698ea98 1793EXPORT_SYMBOL_GPL(snd_hda_codec_resume_amp);
1da177e4 1794
afbd9b84
TI		 1795static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1796 unsigned int ofs)
1797{
1798 u32 caps = query_amp_caps(codec, nid, dir);
1799 /* get num steps */
1800 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1801 if (ofs < caps)
1802 caps -= ofs;
1803 return caps;
1804}
1805
d5191e50
TI		 1806/**
1807 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
a11e9b16
TI		 1808 * @kcontrol: referred ctl element
1809 * @uinfo: pointer to get/store the data
d5191e50
TI		 1810 *
1811 * The control element is supposed to have the private_value field
1812 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1813 */
0ba21762
TI		 1814int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1815 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 1816{
1817 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1818 u16 nid = get_amp_nid(kcontrol);
1819 u8 chs = get_amp_channels(kcontrol);
1820 int dir = get_amp_direction(kcontrol);
29fdbec2 1821 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4 1822
afbd9b84
TI		 1823 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1824 uinfo->count = chs == 3 ? 2 : 1;
1825 uinfo->value.integer.min = 0;
1826 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1827 if (!uinfo->value.integer.max) {
4e76a883
TI		 1828 codec_warn(codec,
1829 "num_steps = 0 for NID=0x%x (ctl = %s)\n",
1830 nid, kcontrol->id.name);
1da177e4
LT		 1831 return -EINVAL;
1832 }
1da177e4
LT		 1833 return 0;
1834}
2698ea98 1835EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
1da177e4 1836
29fdbec2
TI		 1837
1838static inline unsigned int
1839read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1840 int ch, int dir, int idx, unsigned int ofs)
1841{
1842 unsigned int val;
1843 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1844 val &= HDA_AMP_VOLMASK;
1845 if (val >= ofs)
1846 val -= ofs;
1847 else
1848 val = 0;
1849 return val;
1850}
1851
1852static inline int
1853update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1854 int ch, int dir, int idx, unsigned int ofs,
1855 unsigned int val)
1856{
afbd9b84
TI		 1857 unsigned int maxval;
1858
29fdbec2
TI		 1859 if (val > 0)
1860 val += ofs;
7ccc3efa
TI		 1861 /* ofs = 0: raw max value */
1862 maxval = get_amp_max_value(codec, nid, dir, 0);
afbd9b84
TI		 1863 if (val > maxval)
1864 val = maxval;
781c7b96
TI		 1865 return codec_amp_update(codec, nid, ch, dir, idx, HDA_AMP_VOLMASK, val,
1866 false, !hda_codec_is_power_on(codec));
29fdbec2
TI		 1867}
1868
d5191e50
TI		 1869/**
1870 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
a11e9b16
TI		 1871 * @kcontrol: ctl element
1872 * @ucontrol: pointer to get/store the data
d5191e50
TI		 1873 *
1874 * The control element is supposed to have the private_value field
1875 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1876 */
0ba21762
TI		 1877int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1878 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1879{
1880 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1881 hda_nid_t nid = get_amp_nid(kcontrol);
1882 int chs = get_amp_channels(kcontrol);
1883 int dir = get_amp_direction(kcontrol);
1884 int idx = get_amp_index(kcontrol);
29fdbec2 1885 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 1886 long *valp = ucontrol->value.integer.value;
1887
1888 if (chs & 1)
29fdbec2 1889 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1da177e4 1890 if (chs & 2)
29fdbec2 1891 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1da177e4
LT		 1892 return 0;
1893}
2698ea98 1894EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
1da177e4 1895
d5191e50
TI		 1896/**
1897 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
a11e9b16
TI		 1898 * @kcontrol: ctl element
1899 * @ucontrol: pointer to get/store the data
d5191e50
TI		 1900 *
1901 * The control element is supposed to have the private_value field
1902 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1903 */
0ba21762
TI		 1904int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1905 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1906{
1907 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1908 hda_nid_t nid = get_amp_nid(kcontrol);
1909 int chs = get_amp_channels(kcontrol);
1910 int dir = get_amp_direction(kcontrol);
1911 int idx = get_amp_index(kcontrol);
29fdbec2 1912 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 1913 long *valp = ucontrol->value.integer.value;
1914 int change = 0;
1915
b9f5a89c 1916 if (chs & 1) {
29fdbec2 1917 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
b9f5a89c
NG		 1918 valp++;
1919 }
4a19faee 1920 if (chs & 2)
29fdbec2 1921 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1da177e4
LT		 1922 return change;
1923}
2698ea98 1924EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
1da177e4 1925
d5191e50
TI		 1926/**
1927 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
a11e9b16
TI		 1928 * @kcontrol: ctl element
1929 * @op_flag: operation flag
1930 * @size: byte size of input TLV
1931 * @_tlv: TLV data
d5191e50
TI		 1932 *
1933 * The control element is supposed to have the private_value field
1934 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1935 */
302e9c5a
JK		 1936int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1937 unsigned int size, unsigned int __user *_tlv)
1938{
1939 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1940 hda_nid_t nid = get_amp_nid(kcontrol);
1941 int dir = get_amp_direction(kcontrol);
29fdbec2 1942 unsigned int ofs = get_amp_offset(kcontrol);
de8c85f7 1943 bool min_mute = get_amp_min_mute(kcontrol);
302e9c5a
JK		 1944 u32 caps, val1, val2;
1945
1946 if (size < 4 * sizeof(unsigned int))
1947 return -ENOMEM;
1948 caps = query_amp_caps(codec, nid, dir);
0ba21762
TI		 1949 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1950 val2 = (val2 + 1) * 25;
302e9c5a 1951 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
29fdbec2 1952 val1 += ofs;
302e9c5a 1953 val1 = ((int)val1) * ((int)val2);
3868137e 1954 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
c08d9169 1955 val2 |= TLV_DB_SCALE_MUTE;
302e9c5a
JK		 1956 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1957 return -EFAULT;
1958 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1959 return -EFAULT;
1960 if (put_user(val1, _tlv + 2))
1961 return -EFAULT;
1962 if (put_user(val2, _tlv + 3))
1963 return -EFAULT;
1964 return 0;
1965}
2698ea98 1966EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
302e9c5a 1967
d5191e50
TI		 1968/**
1969 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1970 * @codec: HD-audio codec
1971 * @nid: NID of a reference widget
1972 * @dir: #HDA_INPUT or #HDA_OUTPUT
1973 * @tlv: TLV data to be stored, at least 4 elements
1974 *
1975 * Set (static) TLV data for a virtual master volume using the AMP caps
1976 * obtained from the reference NID.
1977 * The volume range is recalculated as if the max volume is 0dB.
2134ea4f
TI		 1978 */
1979void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1980 unsigned int *tlv)
1981{
1982 u32 caps;
1983 int nums, step;
1984
1985 caps = query_amp_caps(codec, nid, dir);
1986 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1987 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1988 step = (step + 1) * 25;
1989 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1990 tlv[1] = 2 * sizeof(unsigned int);
1991 tlv[2] = -nums * step;
1992 tlv[3] = step;
1993}
2698ea98 1994EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
2134ea4f
TI		 1995
1996/* find a mixer control element with the given name */
09f99701 1997static struct snd_kcontrol *
dcda5806 1998find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
2134ea4f
TI		 1999{
2000 struct snd_ctl_elem_id id;
2001 memset(&id, 0, sizeof(id));
2002 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
dcda5806 2003 id.device = dev;
09f99701 2004 id.index = idx;
18cb7109
TI		 2005 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2006 return NULL;
2134ea4f 2007 strcpy(id.name, name);
6efdd851 2008 return snd_ctl_find_id(codec->card, &id);
2134ea4f
TI		 2009}
2010
d5191e50
TI		 2011/**
2012 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2013 * @codec: HD-audio codec
2014 * @name: ctl id name string
2015 *
2016 * Get the control element with the given id string and IFACE_MIXER.
2017 */
09f99701
TI		 2018struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2019 const char *name)
2020{
dcda5806 2021 return find_mixer_ctl(codec, name, 0, 0);
09f99701 2022}
2698ea98 2023EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
09f99701 2024
dcda5806 2025static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
ea9b43ad 2026 int start_idx)
1afe206a 2027{
ea9b43ad
TI		 2028 int i, idx;
2029 /* 16 ctlrs should be large enough */
2030 for (i = 0, idx = start_idx; i < 16; i++, idx++) {
2031 if (!find_mixer_ctl(codec, name, 0, idx))
1afe206a
TI		 2032 return idx;
2033 }
2034 return -EBUSY;
2035}
2036
d5191e50 2037/**
5b0cb1d8 2038 * snd_hda_ctl_add - Add a control element and assign to the codec
d5191e50
TI		 2039 * @codec: HD-audio codec
2040 * @nid: corresponding NID (optional)
2041 * @kctl: the control element to assign
2042 *
2043 * Add the given control element to an array inside the codec instance.
2044 * All control elements belonging to a codec are supposed to be added
2045 * by this function so that a proper clean-up works at the free or
2046 * reconfiguration time.
2047 *
2048 * If non-zero @nid is passed, the NID is assigned to the control element.
2049 * The assignment is shown in the codec proc file.
2050 *
2051 * snd_hda_ctl_add() checks the control subdev id field whether
2052 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
9e3fd871
JK		 2053 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2054 * specifies if kctl->private_value is a HDA amplifier value.
d5191e50 2055 */
3911a4c1
JK		 2056int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2057 struct snd_kcontrol *kctl)
d13bd412
TI		 2058{
2059 int err;
9e3fd871 2060 unsigned short flags = 0;
3911a4c1 2061 struct hda_nid_item *item;
d13bd412 2062
5e26dfd0 2063 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
9e3fd871 2064 flags |= HDA_NID_ITEM_AMP;
5e26dfd0
JK		 2065 if (nid == 0)
2066 nid = get_amp_nid_(kctl->private_value);
2067 }
9e3fd871
JK		 2068 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2069 nid = kctl->id.subdevice & 0xffff;
5e26dfd0 2070 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
4d02d1b6 2071 kctl->id.subdevice = 0;
6efdd851 2072 err = snd_ctl_add(codec->card, kctl);
d13bd412
TI		 2073 if (err < 0)
2074 return err;
3911a4c1
JK		 2075 item = snd_array_new(&codec->mixers);
2076 if (!item)
d13bd412 2077 return -ENOMEM;
3911a4c1
JK		 2078 item->kctl = kctl;
2079 item->nid = nid;
9e3fd871 2080 item->flags = flags;
d13bd412
TI		 2081 return 0;
2082}
2698ea98 2083EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
d13bd412 2084
5b0cb1d8
JK		 2085/**
2086 * snd_hda_add_nid - Assign a NID to a control element
2087 * @codec: HD-audio codec
2088 * @nid: corresponding NID (optional)
2089 * @kctl: the control element to assign
2090 * @index: index to kctl
2091 *
2092 * Add the given control element to an array inside the codec instance.
2093 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2094 * NID:KCTL mapping - for example "Capture Source" selector.
2095 */
2096int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2097 unsigned int index, hda_nid_t nid)
2098{
2099 struct hda_nid_item *item;
2100
2101 if (nid > 0) {
2102 item = snd_array_new(&codec->nids);
2103 if (!item)
2104 return -ENOMEM;
2105 item->kctl = kctl;
2106 item->index = index;
2107 item->nid = nid;
2108 return 0;
2109 }
4e76a883
TI		 2110 codec_err(codec, "no NID for mapping control %s:%d:%d\n",
2111 kctl->id.name, kctl->id.index, index);
5b0cb1d8
JK		 2112 return -EINVAL;
2113}
2698ea98 2114EXPORT_SYMBOL_GPL(snd_hda_add_nid);
5b0cb1d8 2115
d5191e50
TI		 2116/**
2117 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2118 * @codec: HD-audio codec
2119 */
d13bd412
TI		 2120void snd_hda_ctls_clear(struct hda_codec *codec)
2121{
2122 int i;
3911a4c1 2123 struct hda_nid_item *items = codec->mixers.list;
d13bd412 2124 for (i = 0; i < codec->mixers.used; i++)
6efdd851 2125 snd_ctl_remove(codec->card, items[i].kctl);
d13bd412 2126 snd_array_free(&codec->mixers);
5b0cb1d8 2127 snd_array_free(&codec->nids);
d13bd412
TI		 2128}
2129
95a962c3
TI		 2130/**
2131 * snd_hda_lock_devices - pseudo device locking
2132 * @bus: the BUS
2133 *
a65d629c
TI		 2134 * toggle card->shutdown to allow/disallow the device access (as a hack)
2135 */
d3d020bd 2136int snd_hda_lock_devices(struct hda_bus *bus)
6c1f45ea 2137{
d3d020bd
TI		 2138 struct snd_card *card = bus->card;
2139 struct hda_codec *codec;
2140
a65d629c 2141 spin_lock(&card->files_lock);
d3d020bd
TI		 2142 if (card->shutdown)
2143 goto err_unlock;
a65d629c 2144 card->shutdown = 1;
d3d020bd
TI		 2145 if (!list_empty(&card->ctl_files))
2146 goto err_clear;
2147
d068ebc2 2148 list_for_each_codec(codec, bus) {
bbbc7e85
TI		 2149 struct hda_pcm *cpcm;
2150 list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
d3d020bd
TI		 2151 if (!cpcm->pcm)
2152 continue;
2153 if (cpcm->pcm->streams[0].substream_opened ||
2154 cpcm->pcm->streams[1].substream_opened)
2155 goto err_clear;
2156 }
2157 }
a65d629c
TI		 2158 spin_unlock(&card->files_lock);
2159 return 0;
d3d020bd
TI		 2160
2161 err_clear:
2162 card->shutdown = 0;
2163 err_unlock:
2164 spin_unlock(&card->files_lock);
2165 return -EINVAL;
a65d629c 2166}
2698ea98 2167EXPORT_SYMBOL_GPL(snd_hda_lock_devices);
a65d629c 2168
95a962c3
TI		 2169/**
2170 * snd_hda_unlock_devices - pseudo device unlocking
2171 * @bus: the BUS
2172 */
d3d020bd 2173void snd_hda_unlock_devices(struct hda_bus *bus)
a65d629c 2174{
d3d020bd
TI		 2175 struct snd_card *card = bus->card;
2176
a65d629c
TI		 2177 spin_lock(&card->files_lock);
2178 card->shutdown = 0;
2179 spin_unlock(&card->files_lock);
2180}
2698ea98 2181EXPORT_SYMBOL_GPL(snd_hda_unlock_devices);
a65d629c 2182
d5191e50
TI		 2183/**
2184 * snd_hda_codec_reset - Clear all objects assigned to the codec
2185 * @codec: HD-audio codec
2186 *
2187 * This frees the all PCM and control elements assigned to the codec, and
2188 * clears the caches and restores the pin default configurations.
2189 *
2190 * When a device is being used, it returns -EBSY. If successfully freed,
2191 * returns zero.
2192 */
a65d629c
TI		 2193int snd_hda_codec_reset(struct hda_codec *codec)
2194{
d3d020bd 2195 struct hda_bus *bus = codec->bus;
a65d629c 2196
d3d020bd 2197 if (snd_hda_lock_devices(bus) < 0)
a65d629c 2198 return -EBUSY;
a65d629c
TI		 2199
2200 /* OK, let it free */
3256be65 2201 snd_hdac_device_unregister(&codec->core);
d8a766a1 2202
a65d629c 2203 /* allow device access again */
d3d020bd 2204 snd_hda_unlock_devices(bus);
a65d629c 2205 return 0;
6c1f45ea
TI		 2206}
2207
6194b99d 2208typedef int (*map_slave_func_t)(struct hda_codec *, void *, struct snd_kcontrol *);
aeb4b88e
TI		 2209
2210/* apply the function to all matching slave ctls in the mixer list */
2211static int map_slaves(struct hda_codec *codec, const char * const *slaves,
9322ca54 2212 const char *suffix, map_slave_func_t func, void *data)
aeb4b88e
TI		 2213{
2214 struct hda_nid_item *items;
2215 const char * const *s;
2216 int i, err;
2217
2218 items = codec->mixers.list;
2219 for (i = 0; i < codec->mixers.used; i++) {
2220 struct snd_kcontrol *sctl = items[i].kctl;
ca16ec02 2221 if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
aeb4b88e
TI		 2222 continue;
2223 for (s = slaves; *s; s++) {
9322ca54
TI		 2224 char tmpname[sizeof(sctl->id.name)];
2225 const char *name = *s;
2226 if (suffix) {
2227 snprintf(tmpname, sizeof(tmpname), "%s %s",
2228 name, suffix);
2229 name = tmpname;
2230 }
9322ca54 2231 if (!strcmp(sctl->id.name, name)) {
6194b99d 2232 err = func(codec, data, sctl);
aeb4b88e
TI		 2233 if (err)
2234 return err;
2235 break;
2236 }
2237 }
2238 }
2239 return 0;
2240}
2241
6194b99d
TI		 2242static int check_slave_present(struct hda_codec *codec,
2243 void *data, struct snd_kcontrol *sctl)
aeb4b88e
TI		 2244{
2245 return 1;
2246}
2247
18478e8b 2248/* guess the value corresponding to 0dB */
6194b99d
TI		 2249static int get_kctl_0dB_offset(struct hda_codec *codec,
2250 struct snd_kcontrol *kctl, int *step_to_check)
18478e8b
TI		 2251{
2252 int _tlv[4];
2253 const int *tlv = NULL;
2254 int val = -1;
2255
2256 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2257 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2258 mm_segment_t fs = get_fs();
2259 set_fs(get_ds());
2260 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2261 tlv = _tlv;
2262 set_fs(fs);
2263 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2264 tlv = kctl->tlv.p;
a4e7a121
TI		 2265 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE) {
2266 int step = tlv[3];
2267 step &= ~TLV_DB_SCALE_MUTE;
2268 if (!step)
2269 return -1;
485e3e0c 2270 if (*step_to_check && *step_to_check != step) {
6194b99d 2271 codec_err(codec, "Mismatching dB step for vmaster slave (%d!=%d)\n",
4e76a883 2272- *step_to_check, step);
485e3e0c
TI		 2273 return -1;
2274 }
2275 *step_to_check = step;
a4e7a121
TI		 2276 val = -tlv[2] / step;
2277 }
18478e8b
TI		 2278 return val;
2279}
2280
2281/* call kctl->put with the given value(s) */
2282static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2283{
2284 struct snd_ctl_elem_value *ucontrol;
2285 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2286 if (!ucontrol)
2287 return -ENOMEM;
2288 ucontrol->value.integer.value[0] = val;
2289 ucontrol->value.integer.value[1] = val;
2290 kctl->put(kctl, ucontrol);
2291 kfree(ucontrol);
2292 return 0;
2293}
2294
2295/* initialize the slave volume with 0dB */
6194b99d
TI		 2296static int init_slave_0dB(struct hda_codec *codec,
2297 void *data, struct snd_kcontrol *slave)
18478e8b 2298{
6194b99d 2299 int offset = get_kctl_0dB_offset(codec, slave, data);
18478e8b
TI		 2300 if (offset > 0)
2301 put_kctl_with_value(slave, offset);
2302 return 0;
2303}
2304
2305/* unmute the slave */
6194b99d
TI		 2306static int init_slave_unmute(struct hda_codec *codec,
2307 void *data, struct snd_kcontrol *slave)
18478e8b
TI		 2308{
2309 return put_kctl_with_value(slave, 1);
2310}
2311
e8750940
TI		 2312static int add_slave(struct hda_codec *codec,
2313 void *data, struct snd_kcontrol *slave)
2314{
2315 return snd_ctl_add_slave(data, slave);
2316}
2317
d5191e50 2318/**
95a962c3 2319 * __snd_hda_add_vmaster - create a virtual master control and add slaves
d5191e50
TI		 2320 * @codec: HD-audio codec
2321 * @name: vmaster control name
2322 * @tlv: TLV data (optional)
2323 * @slaves: slave control names (optional)
9322ca54 2324 * @suffix: suffix string to each slave name (optional)
18478e8b 2325 * @init_slave_vol: initialize slaves to unmute/0dB
29e5853d 2326 * @ctl_ret: store the vmaster kcontrol in return
d5191e50
TI		 2327 *
2328 * Create a virtual master control with the given name. The TLV data
2329 * must be either NULL or a valid data.
2330 *
2331 * @slaves is a NULL-terminated array of strings, each of which is a
2332 * slave control name. All controls with these names are assigned to
2333 * the new virtual master control.
2334 *
2335 * This function returns zero if successful or a negative error code.
2336 */
18478e8b 2337int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
9322ca54 2338 unsigned int *tlv, const char * const *slaves,
29e5853d
TI		 2339 const char *suffix, bool init_slave_vol,
2340 struct snd_kcontrol **ctl_ret)
2134ea4f
TI		 2341{
2342 struct snd_kcontrol *kctl;
2134ea4f
TI		 2343 int err;
2344
29e5853d
TI		 2345 if (ctl_ret)
2346 *ctl_ret = NULL;
2347
9322ca54 2348 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
aeb4b88e 2349 if (err != 1) {
4e76a883 2350 codec_dbg(codec, "No slave found for %s\n", name);
2f085549
TI		 2351 return 0;
2352 }
2134ea4f
TI		 2353 kctl = snd_ctl_make_virtual_master(name, tlv);
2354 if (!kctl)
2355 return -ENOMEM;
3911a4c1 2356 err = snd_hda_ctl_add(codec, 0, kctl);
2134ea4f
TI		 2357 if (err < 0)
2358 return err;
28aedaf7 2359
e8750940 2360 err = map_slaves(codec, slaves, suffix, add_slave, kctl);
aeb4b88e
TI		 2361 if (err < 0)
2362 return err;
18478e8b
TI		 2363
2364 /* init with master mute & zero volume */
2365 put_kctl_with_value(kctl, 0);
485e3e0c
TI		 2366 if (init_slave_vol) {
2367 int step = 0;
18478e8b 2368 map_slaves(codec, slaves, suffix,
485e3e0c
TI		 2369 tlv ? init_slave_0dB : init_slave_unmute, &step);
2370 }
18478e8b 2371
29e5853d
TI		 2372 if (ctl_ret)
2373 *ctl_ret = kctl;
2134ea4f
TI		 2374 return 0;
2375}
2698ea98 2376EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster);
2134ea4f 2377
d2f344b5
TI		 2378/*
2379 * mute-LED control using vmaster
2380 */
2381static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2382 struct snd_ctl_elem_info *uinfo)
2383{
2384 static const char * const texts[] = {
c86c2d44 2385 "On", "Off", "Follow Master"
d2f344b5 2386 };
d2f344b5 2387
3ff72219 2388 return snd_ctl_enum_info(uinfo, 1, 3, texts);
d2f344b5
TI		 2389}
2390
2391static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2392 struct snd_ctl_elem_value *ucontrol)
2393{
2394 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2395 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2396 return 0;
2397}
2398
2399static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2400 struct snd_ctl_elem_value *ucontrol)
2401{
2402 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2403 unsigned int old_mode = hook->mute_mode;
2404
2405 hook->mute_mode = ucontrol->value.enumerated.item[0];
2406 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2407 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2408 if (old_mode == hook->mute_mode)
2409 return 0;
2410 snd_hda_sync_vmaster_hook(hook);
2411 return 1;
2412}
2413
2414static struct snd_kcontrol_new vmaster_mute_mode = {
2415 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2416 .name = "Mute-LED Mode",
2417 .info = vmaster_mute_mode_info,
2418 .get = vmaster_mute_mode_get,
2419 .put = vmaster_mute_mode_put,
2420};
2421
95a962c3
TI		 2422/**
2423 * snd_hda_add_vmaster_hook - Add a vmaster hook for mute-LED
2424 * @codec: the HDA codec
2425 * @hook: the vmaster hook object
2426 * @expose_enum_ctl: flag to create an enum ctl
2427 *
2428 * Add a mute-LED hook with the given vmaster switch kctl.
2429 * When @expose_enum_ctl is set, "Mute-LED Mode" control is automatically
2430 * created and associated with the given hook.
d2f344b5
TI		 2431 */
2432int snd_hda_add_vmaster_hook(struct hda_codec *codec,
f29735cb
TI		 2433 struct hda_vmaster_mute_hook *hook,
2434 bool expose_enum_ctl)
d2f344b5
TI		 2435{
2436 struct snd_kcontrol *kctl;
2437
2438 if (!hook->hook || !hook->sw_kctl)
2439 return 0;
2440 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2441 hook->codec = codec;
2442 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
f29735cb
TI		 2443 if (!expose_enum_ctl)
2444 return 0;
d2f344b5
TI		 2445 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2446 if (!kctl)
2447 return -ENOMEM;
2448 return snd_hda_ctl_add(codec, 0, kctl);
2449}
2698ea98 2450EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook);
d2f344b5 2451
95a962c3
TI		 2452/**
2453 * snd_hda_sync_vmaster_hook - Sync vmaster hook
2454 * @hook: the vmaster hook
2455 *
2456 * Call the hook with the current value for synchronization.
2457 * Should be called in init callback.
d2f344b5
TI		 2458 */
2459void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2460{
2461 if (!hook->hook || !hook->codec)
2462 return;
594813ff
TI		 2463 /* don't call vmaster hook in the destructor since it might have
2464 * been already destroyed
2465 */
2466 if (hook->codec->bus->shutdown)
2467 return;
d2f344b5
TI		 2468 switch (hook->mute_mode) {
2469 case HDA_VMUTE_FOLLOW_MASTER:
2470 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2471 break;
2472 default:
2473 hook->hook(hook->codec, hook->mute_mode);
2474 break;
2475 }
2476}
2698ea98 2477EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook);
d2f344b5
TI		 2478
2479
d5191e50
TI		 2480/**
2481 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
a11e9b16
TI		 2482 * @kcontrol: referred ctl element
2483 * @uinfo: pointer to get/store the data
d5191e50
TI		 2484 *
2485 * The control element is supposed to have the private_value field
2486 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2487 */
0ba21762
TI		 2488int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2489 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 2490{
2491 int chs = get_amp_channels(kcontrol);
2492
2493 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2494 uinfo->count = chs == 3 ? 2 : 1;
2495 uinfo->value.integer.min = 0;
2496 uinfo->value.integer.max = 1;
2497 return 0;
2498}
2698ea98 2499EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
1da177e4 2500
d5191e50
TI		 2501/**
2502 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
a11e9b16
TI		 2503 * @kcontrol: ctl element
2504 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2505 *
2506 * The control element is supposed to have the private_value field
2507 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2508 */
0ba21762
TI		 2509int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2510 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2511{
2512 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2513 hda_nid_t nid = get_amp_nid(kcontrol);
2514 int chs = get_amp_channels(kcontrol);
2515 int dir = get_amp_direction(kcontrol);
2516 int idx = get_amp_index(kcontrol);
2517 long *valp = ucontrol->value.integer.value;
2518
2519 if (chs & 1)
0ba21762 2520 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
47fd830a 2521 HDA_AMP_MUTE) ? 0 : 1;
1da177e4 2522 if (chs & 2)
0ba21762 2523 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
47fd830a 2524 HDA_AMP_MUTE) ? 0 : 1;
1da177e4
LT		 2525 return 0;
2526}
2698ea98 2527EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
1da177e4 2528
d5191e50
TI		 2529/**
2530 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
a11e9b16
TI		 2531 * @kcontrol: ctl element
2532 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2533 *
2534 * The control element is supposed to have the private_value field
2535 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2536 */
0ba21762
TI		 2537int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2538 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2539{
2540 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2541 hda_nid_t nid = get_amp_nid(kcontrol);
2542 int chs = get_amp_channels(kcontrol);
2543 int dir = get_amp_direction(kcontrol);
2544 int idx = get_amp_index(kcontrol);
1da177e4
LT		 2545 long *valp = ucontrol->value.integer.value;
2546 int change = 0;
2547
b9f5a89c 2548 if (chs & 1) {
781c7b96
TI		 2549 change = codec_amp_update(codec, nid, 0, dir, idx,
2550 HDA_AMP_MUTE,
2551 *valp ? 0 : HDA_AMP_MUTE, false,
2552 !hda_codec_is_power_on(codec));
b9f5a89c
NG		 2553 valp++;
2554 }
4a19faee 2555 if (chs & 2)
781c7b96
TI		 2556 change |= codec_amp_update(codec, nid, 1, dir, idx,
2557 HDA_AMP_MUTE,
2558 *valp ? 0 : HDA_AMP_MUTE, false,
2559 !hda_codec_is_power_on(codec));
9e5341b9 2560 hda_call_check_power_status(codec, nid);
1da177e4
LT		 2561 return change;
2562}
2698ea98 2563EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
1da177e4 2564
985be54b
TI		 2565/*
2566 * bound volume controls
2567 *
2568 * bind multiple volumes (# indices, from 0)
2569 */
2570
2571#define AMP_VAL_IDX_SHIFT 19
2572#define AMP_VAL_IDX_MASK (0x0f<<19)
2573
d5191e50
TI		 2574/**
2575 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
a11e9b16
TI		 2576 * @kcontrol: ctl element
2577 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2578 *
2579 * The control element is supposed to have the private_value field
2580 * set up via HDA_BIND_MUTE*() macros.
2581 */
0ba21762
TI		 2582int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2583 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 2584{
2585 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2586 unsigned long pval;
2587 int err;
2588
5a9e02e9 2589 mutex_lock(&codec->control_mutex);
985be54b
TI		 2590 pval = kcontrol->private_value;
2591 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2592 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2593 kcontrol->private_value = pval;
5a9e02e9 2594 mutex_unlock(&codec->control_mutex);
985be54b
TI		 2595 return err;
2596}
2698ea98 2597EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_get);
985be54b 2598
d5191e50
TI		 2599/**
2600 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
a11e9b16
TI		 2601 * @kcontrol: ctl element
2602 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2603 *
2604 * The control element is supposed to have the private_value field
2605 * set up via HDA_BIND_MUTE*() macros.
2606 */
0ba21762
TI		 2607int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2608 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 2609{
2610 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2611 unsigned long pval;
2612 int i, indices, err = 0, change = 0;
2613
5a9e02e9 2614 mutex_lock(&codec->control_mutex);
985be54b
TI		 2615 pval = kcontrol->private_value;
2616 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2617 for (i = 0; i < indices; i++) {
0ba21762
TI		 2618 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2619 (i << AMP_VAL_IDX_SHIFT);
985be54b
TI		 2620 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2621 if (err < 0)
2622 break;
2623 change |= err;
2624 }
2625 kcontrol->private_value = pval;
5a9e02e9 2626 mutex_unlock(&codec->control_mutex);
985be54b
TI		 2627 return err < 0 ? err : change;
2628}
2698ea98 2629EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_put);
985be54b 2630
d5191e50
TI		 2631/**
2632 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
a11e9b16
TI		 2633 * @kcontrol: referred ctl element
2634 * @uinfo: pointer to get/store the data
d5191e50
TI		 2635 *
2636 * The control element is supposed to have the private_value field
2637 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
532d5381
TI		 2638 */
2639int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2640 struct snd_ctl_elem_info *uinfo)
2641{
2642 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2643 struct hda_bind_ctls *c;
2644 int err;
2645
5a9e02e9 2646 mutex_lock(&codec->control_mutex);
14c65f98 2647 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2648 kcontrol->private_value = *c->values;
2649 err = c->ops->info(kcontrol, uinfo);
2650 kcontrol->private_value = (long)c;
5a9e02e9 2651 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2652 return err;
2653}
2698ea98 2654EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_info);
532d5381 2655
d5191e50
TI		 2656/**
2657 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
a11e9b16
TI		 2658 * @kcontrol: ctl element
2659 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2660 *
2661 * The control element is supposed to have the private_value field
2662 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2663 */
532d5381
TI		 2664int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2665 struct snd_ctl_elem_value *ucontrol)
2666{
2667 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2668 struct hda_bind_ctls *c;
2669 int err;
2670
5a9e02e9 2671 mutex_lock(&codec->control_mutex);
14c65f98 2672 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2673 kcontrol->private_value = *c->values;
2674 err = c->ops->get(kcontrol, ucontrol);
2675 kcontrol->private_value = (long)c;
5a9e02e9 2676 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2677 return err;
2678}
2698ea98 2679EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_get);
532d5381 2680
d5191e50
TI		 2681/**
2682 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
a11e9b16
TI		 2683 * @kcontrol: ctl element
2684 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2685 *
2686 * The control element is supposed to have the private_value field
2687 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2688 */
532d5381
TI		 2689int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2690 struct snd_ctl_elem_value *ucontrol)
2691{
2692 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2693 struct hda_bind_ctls *c;
2694 unsigned long *vals;
2695 int err = 0, change = 0;
2696
5a9e02e9 2697 mutex_lock(&codec->control_mutex);
14c65f98 2698 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2699 for (vals = c->values; *vals; vals++) {
2700 kcontrol->private_value = *vals;
2701 err = c->ops->put(kcontrol, ucontrol);
2702 if (err < 0)
2703 break;
2704 change |= err;
2705 }
2706 kcontrol->private_value = (long)c;
5a9e02e9 2707 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2708 return err < 0 ? err : change;
2709}
2698ea98 2710EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_put);
532d5381 2711
d5191e50
TI		 2712/**
2713 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
a11e9b16
TI		 2714 * @kcontrol: ctl element
2715 * @op_flag: operation flag
2716 * @size: byte size of input TLV
2717 * @tlv: TLV data
d5191e50
TI		 2718 *
2719 * The control element is supposed to have the private_value field
2720 * set up via HDA_BIND_VOL() macro.
2721 */
532d5381
TI		 2722int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2723 unsigned int size, unsigned int __user *tlv)
2724{
2725 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2726 struct hda_bind_ctls *c;
2727 int err;
2728
5a9e02e9 2729 mutex_lock(&codec->control_mutex);
14c65f98 2730 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2731 kcontrol->private_value = *c->values;
2732 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2733 kcontrol->private_value = (long)c;
5a9e02e9 2734 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2735 return err;
2736}
2698ea98 2737EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_tlv);
532d5381
TI		 2738
2739struct hda_ctl_ops snd_hda_bind_vol = {
2740 .info = snd_hda_mixer_amp_volume_info,
2741 .get = snd_hda_mixer_amp_volume_get,
2742 .put = snd_hda_mixer_amp_volume_put,
2743 .tlv = snd_hda_mixer_amp_tlv
2744};
2698ea98 2745EXPORT_SYMBOL_GPL(snd_hda_bind_vol);
532d5381
TI		 2746
2747struct hda_ctl_ops snd_hda_bind_sw = {
2748 .info = snd_hda_mixer_amp_switch_info,
2749 .get = snd_hda_mixer_amp_switch_get,
2750 .put = snd_hda_mixer_amp_switch_put,
2751 .tlv = snd_hda_mixer_amp_tlv
2752};
2698ea98 2753EXPORT_SYMBOL_GPL(snd_hda_bind_sw);
532d5381 2754
1da177e4
LT		 2755/*
2756 * SPDIF out controls
2757 */
2758
0ba21762
TI		 2759static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2760 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 2761{
2762 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2763 uinfo->count = 1;
2764 return 0;
2765}
2766
0ba21762
TI		 2767static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2768 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2769{
2770 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2771 IEC958_AES0_NONAUDIO |
2772 IEC958_AES0_CON_EMPHASIS_5015 |
2773 IEC958_AES0_CON_NOT_COPYRIGHT;
2774 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2775 IEC958_AES1_CON_ORIGINAL;
2776 return 0;
2777}
2778
0ba21762
TI		 2779static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2780 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2781{
2782 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2783 IEC958_AES0_NONAUDIO |
2784 IEC958_AES0_PRO_EMPHASIS_5015;
2785 return 0;
2786}
2787
0ba21762
TI		 2788static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2789 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2790{
2791 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 2792 int idx = kcontrol->private_value;
e3245cdd 2793 struct hda_spdif_out *spdif;
1da177e4 2794
e3245cdd
TI		 2795 mutex_lock(&codec->spdif_mutex);
2796 spdif = snd_array_elem(&codec->spdif_out, idx);
7c935976
SW		 2797 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2798 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2799 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2800 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
e3245cdd 2801 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2802
2803 return 0;
2804}
2805
2806/* convert from SPDIF status bits to HDA SPDIF bits
2807 * bit 0 (DigEn) is always set zero (to be filled later)
2808 */
2809static unsigned short convert_from_spdif_status(unsigned int sbits)
2810{
2811 unsigned short val = 0;
2812
2813 if (sbits & IEC958_AES0_PROFESSIONAL)
0ba21762 2814 val |= AC_DIG1_PROFESSIONAL;
1da177e4 2815 if (sbits & IEC958_AES0_NONAUDIO)
0ba21762 2816 val |= AC_DIG1_NONAUDIO;
1da177e4 2817 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762
TI		 2818 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2819 IEC958_AES0_PRO_EMPHASIS_5015)
2820 val |= AC_DIG1_EMPHASIS;
1da177e4 2821 } else {
0ba21762
TI		 2822 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2823 IEC958_AES0_CON_EMPHASIS_5015)
2824 val |= AC_DIG1_EMPHASIS;
2825 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2826 val |= AC_DIG1_COPYRIGHT;
1da177e4 2827 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
0ba21762 2828 val |= AC_DIG1_LEVEL;
1da177e4
LT		 2829 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2830 }
2831 return val;
2832}
2833
2834/* convert to SPDIF status bits from HDA SPDIF bits
2835 */
2836static unsigned int convert_to_spdif_status(unsigned short val)
2837{
2838 unsigned int sbits = 0;
2839
0ba21762 2840 if (val & AC_DIG1_NONAUDIO)
1da177e4 2841 sbits |= IEC958_AES0_NONAUDIO;
0ba21762 2842 if (val & AC_DIG1_PROFESSIONAL)
1da177e4
LT		 2843 sbits |= IEC958_AES0_PROFESSIONAL;
2844 if (sbits & IEC958_AES0_PROFESSIONAL) {
a686fd14 2845 if (val & AC_DIG1_EMPHASIS)
1da177e4
LT		 2846 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2847 } else {
0ba21762 2848 if (val & AC_DIG1_EMPHASIS)
1da177e4 2849 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
0ba21762 2850 if (!(val & AC_DIG1_COPYRIGHT))
1da177e4 2851 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
0ba21762 2852 if (val & AC_DIG1_LEVEL)
1da177e4
LT		 2853 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2854 sbits |= val & (0x7f << 8);
2855 }
2856 return sbits;
2857}
2858
2f72853c
TI		 2859/* set digital convert verbs both for the given NID and its slaves */
2860static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2861 int verb, int val)
2862{
dda14410 2863 const hda_nid_t *d;
2f72853c 2864
9e976976 2865 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2f72853c
TI		 2866 d = codec->slave_dig_outs;
2867 if (!d)
2868 return;
2869 for (; *d; d++)
9e976976 2870 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2f72853c
TI		 2871}
2872
2873static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2874 int dig1, int dig2)
2875{
2876 if (dig1 != -1)
2877 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2878 if (dig2 != -1)
2879 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2880}
2881
0ba21762
TI		 2882static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2883 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2884{
2885 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 2886 int idx = kcontrol->private_value;
e3245cdd
TI		 2887 struct hda_spdif_out *spdif;
2888 hda_nid_t nid;
1da177e4
LT		 2889 unsigned short val;
2890 int change;
2891
62932df8 2892 mutex_lock(&codec->spdif_mutex);
e3245cdd
TI		 2893 spdif = snd_array_elem(&codec->spdif_out, idx);
2894 nid = spdif->nid;
7c935976 2895 spdif->status = ucontrol->value.iec958.status[0] |
1da177e4
LT		 2896 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2897 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2898 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
7c935976
SW		 2899 val = convert_from_spdif_status(spdif->status);
2900 val |= spdif->ctls & 1;
2901 change = spdif->ctls != val;
2902 spdif->ctls = val;
74b654c9 2903 if (change && nid != (u16)-1)
2f72853c 2904 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
62932df8 2905 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2906 return change;
2907}
2908
a5ce8890 2909#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1da177e4 2910
0ba21762
TI		 2911static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2912 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2913{
2914 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 2915 int idx = kcontrol->private_value;
e3245cdd 2916 struct hda_spdif_out *spdif;
1da177e4 2917
e3245cdd
TI		 2918 mutex_lock(&codec->spdif_mutex);
2919 spdif = snd_array_elem(&codec->spdif_out, idx);
7c935976 2920 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
e3245cdd 2921 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2922 return 0;
2923}
2924
74b654c9
SW		 2925static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2926 int dig1, int dig2)
2927{
2928 set_dig_out_convert(codec, nid, dig1, dig2);
2929 /* unmute amp switch (if any) */
2930 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2931 (dig1 & AC_DIG1_ENABLE))
2932 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2933 HDA_AMP_MUTE, 0);
2934}
2935
0ba21762
TI		 2936static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2937 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2938{
2939 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 2940 int idx = kcontrol->private_value;
e3245cdd
TI		 2941 struct hda_spdif_out *spdif;
2942 hda_nid_t nid;
1da177e4
LT		 2943 unsigned short val;
2944 int change;
2945
62932df8 2946 mutex_lock(&codec->spdif_mutex);
e3245cdd
TI		 2947 spdif = snd_array_elem(&codec->spdif_out, idx);
2948 nid = spdif->nid;
7c935976 2949 val = spdif->ctls & ~AC_DIG1_ENABLE;
1da177e4 2950 if (ucontrol->value.integer.value[0])
0ba21762 2951 val |= AC_DIG1_ENABLE;
7c935976 2952 change = spdif->ctls != val;
74b654c9
SW		 2953 spdif->ctls = val;
2954 if (change && nid != (u16)-1)
2955 set_spdif_ctls(codec, nid, val & 0xff, -1);
62932df8 2956 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2957 return change;
2958}
2959
c8b6bf9b 2960static struct snd_kcontrol_new dig_mixes[] = {
1da177e4
LT		 2961 {
2962 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2963 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 2964 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
1da177e4
LT		 2965 .info = snd_hda_spdif_mask_info,
2966 .get = snd_hda_spdif_cmask_get,
2967 },
2968 {
2969 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2970 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 2971 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
1da177e4
LT		 2972 .info = snd_hda_spdif_mask_info,
2973 .get = snd_hda_spdif_pmask_get,
2974 },
2975 {
2976 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 2977 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1da177e4
LT		 2978 .info = snd_hda_spdif_mask_info,
2979 .get = snd_hda_spdif_default_get,
2980 .put = snd_hda_spdif_default_put,
2981 },
2982 {
2983 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 2984 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1da177e4
LT		 2985 .info = snd_hda_spdif_out_switch_info,
2986 .get = snd_hda_spdif_out_switch_get,
2987 .put = snd_hda_spdif_out_switch_put,
2988 },
2989 { } /* end */
2990};
2991
2992/**
dcda5806 2993 * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
1da177e4 2994 * @codec: the HDA codec
dcda5806
TI		 2995 * @associated_nid: NID that new ctls associated with
2996 * @cvt_nid: converter NID
2997 * @type: HDA_PCM_TYPE_*
2998 * Creates controls related with the digital output.
2999 * Called from each patch supporting the digital out.
1da177e4
LT		 3000 *
3001 * Returns 0 if successful, or a negative error code.
3002 */
dcda5806
TI		 3003int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
3004 hda_nid_t associated_nid,
3005 hda_nid_t cvt_nid,
3006 int type)
1da177e4
LT		 3007{
3008 int err;
c8b6bf9b
TI		 3009 struct snd_kcontrol *kctl;
3010 struct snd_kcontrol_new *dig_mix;
ea9b43ad
TI		 3011 int idx = 0;
3012 const int spdif_index = 16;
7c935976 3013 struct hda_spdif_out *spdif;
ea9b43ad 3014 struct hda_bus *bus = codec->bus;
1da177e4 3015
ea9b43ad 3016 if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
dcda5806 3017 type == HDA_PCM_TYPE_SPDIF) {
ea9b43ad
TI		 3018 idx = spdif_index;
3019 } else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
dcda5806 3020 type == HDA_PCM_TYPE_HDMI) {
ea9b43ad
TI		 3021 /* suppose a single SPDIF device */
3022 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3023 kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
3024 if (!kctl)
3025 break;
3026 kctl->id.index = spdif_index;
dcda5806 3027 }
ea9b43ad 3028 bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
dcda5806 3029 }
ea9b43ad
TI		 3030 if (!bus->primary_dig_out_type)
3031 bus->primary_dig_out_type = type;
dcda5806 3032
ea9b43ad 3033 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
1afe206a 3034 if (idx < 0) {
4e76a883 3035 codec_err(codec, "too many IEC958 outputs\n");
09f99701
TI		 3036 return -EBUSY;
3037 }
7c935976 3038 spdif = snd_array_new(&codec->spdif_out);
25336e8a
ML		 3039 if (!spdif)
3040 return -ENOMEM;
1da177e4
LT		 3041 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3042 kctl = snd_ctl_new1(dig_mix, codec);
b91f080f
TI		 3043 if (!kctl)
3044 return -ENOMEM;
09f99701 3045 kctl->id.index = idx;
7c935976 3046 kctl->private_value = codec->spdif_out.used - 1;
74b654c9 3047 err = snd_hda_ctl_add(codec, associated_nid, kctl);
0ba21762 3048 if (err < 0)
1da177e4
LT		 3049 return err;
3050 }
74b654c9
SW		 3051 spdif->nid = cvt_nid;
3052 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
7c935976
SW		 3053 AC_VERB_GET_DIGI_CONVERT_1, 0);
3054 spdif->status = convert_to_spdif_status(spdif->ctls);
1da177e4
LT		 3055 return 0;
3056}
2698ea98 3057EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls);
1da177e4 3058
95a962c3
TI		 3059/**
3060 * snd_hda_spdif_out_of_nid - get the hda_spdif_out entry from the given NID
3061 * @codec: the HDA codec
3062 * @nid: widget NID
3063 *
e3245cdd
TI		 3064 * call within spdif_mutex lock
3065 */
7c935976
SW		 3066struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3067 hda_nid_t nid)
3068{
3069 int i;
3070 for (i = 0; i < codec->spdif_out.used; i++) {
3071 struct hda_spdif_out *spdif =
3072 snd_array_elem(&codec->spdif_out, i);
3073 if (spdif->nid == nid)
3074 return spdif;
3075 }
3076 return NULL;
3077}
2698ea98 3078EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_nid);
7c935976 3079
95a962c3
TI		 3080/**
3081 * snd_hda_spdif_ctls_unassign - Unassign the given SPDIF ctl
3082 * @codec: the HDA codec
3083 * @idx: the SPDIF ctl index
3084 *
3085 * Unassign the widget from the given SPDIF control.
3086 */
74b654c9
SW		 3087void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3088{
e3245cdd 3089 struct hda_spdif_out *spdif;
74b654c9
SW		 3090
3091 mutex_lock(&codec->spdif_mutex);
e3245cdd 3092 spdif = snd_array_elem(&codec->spdif_out, idx);
74b654c9
SW		 3093 spdif->nid = (u16)-1;
3094 mutex_unlock(&codec->spdif_mutex);
3095}
2698ea98 3096EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
74b654c9 3097
95a962c3
TI		 3098/**
3099 * snd_hda_spdif_ctls_assign - Assign the SPDIF controls to the given NID
3100 * @codec: the HDA codec
3101 * @idx: the SPDIF ctl idx
3102 * @nid: widget NID
3103 *
3104 * Assign the widget to the SPDIF control with the given index.
3105 */
74b654c9
SW		 3106void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3107{
e3245cdd 3108 struct hda_spdif_out *spdif;
74b654c9
SW		 3109 unsigned short val;
3110
3111 mutex_lock(&codec->spdif_mutex);
e3245cdd 3112 spdif = snd_array_elem(&codec->spdif_out, idx);
74b654c9
SW		 3113 if (spdif->nid != nid) {
3114 spdif->nid = nid;
3115 val = spdif->ctls;
3116 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3117 }
3118 mutex_unlock(&codec->spdif_mutex);
3119}
2698ea98 3120EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
74b654c9 3121
9a08160b
TI		 3122/*
3123 * SPDIF sharing with analog output
3124 */
3125static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3126 struct snd_ctl_elem_value *ucontrol)
3127{
3128 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3129 ucontrol->value.integer.value[0] = mout->share_spdif;
3130 return 0;
3131}
3132
3133static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3134 struct snd_ctl_elem_value *ucontrol)
3135{
3136 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3137 mout->share_spdif = !!ucontrol->value.integer.value[0];
3138 return 0;
3139}
3140
3141static struct snd_kcontrol_new spdif_share_sw = {
3142 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3143 .name = "IEC958 Default PCM Playback Switch",
3144 .info = snd_ctl_boolean_mono_info,
3145 .get = spdif_share_sw_get,
3146 .put = spdif_share_sw_put,
3147};
3148
d5191e50
TI		 3149/**
3150 * snd_hda_create_spdif_share_sw - create Default PCM switch
3151 * @codec: the HDA codec
3152 * @mout: multi-out instance
3153 */
9a08160b
TI		 3154int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3155 struct hda_multi_out *mout)
3156{
4c7a548a
ML		 3157 struct snd_kcontrol *kctl;
3158
9a08160b
TI		 3159 if (!mout->dig_out_nid)
3160 return 0;
4c7a548a
ML		 3161
3162 kctl = snd_ctl_new1(&spdif_share_sw, mout);
3163 if (!kctl)
3164 return -ENOMEM;
9a08160b 3165 /* ATTENTION: here mout is passed as private_data, instead of codec */
4c7a548a 3166 return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
9a08160b 3167}
2698ea98 3168EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
9a08160b 3169
1da177e4
LT		 3170/*
3171 * SPDIF input
3172 */
3173
3174#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3175
0ba21762
TI		 3176static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3177 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3178{
3179 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3180
3181 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3182 return 0;
3183}
3184
0ba21762
TI		 3185static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3186 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3187{
3188 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3189 hda_nid_t nid = kcontrol->private_value;
3190 unsigned int val = !!ucontrol->value.integer.value[0];
3191 int change;
3192
62932df8 3193 mutex_lock(&codec->spdif_mutex);
1da177e4 3194 change = codec->spdif_in_enable != val;
82beb8fd 3195 if (change) {
1da177e4 3196 codec->spdif_in_enable = val;
82beb8fd
TI		 3197 snd_hda_codec_write_cache(codec, nid, 0,
3198 AC_VERB_SET_DIGI_CONVERT_1, val);
1da177e4 3199 }
62932df8 3200 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3201 return change;
3202}
3203
0ba21762
TI		 3204static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3205 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3206{
3207 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3208 hda_nid_t nid = kcontrol->private_value;
3209 unsigned short val;
3210 unsigned int sbits;
3211
3982d17e 3212 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1da177e4
LT		 3213 sbits = convert_to_spdif_status(val);
3214 ucontrol->value.iec958.status[0] = sbits;
3215 ucontrol->value.iec958.status[1] = sbits >> 8;
3216 ucontrol->value.iec958.status[2] = sbits >> 16;
3217 ucontrol->value.iec958.status[3] = sbits >> 24;
3218 return 0;
3219}
3220
c8b6bf9b 3221static struct snd_kcontrol_new dig_in_ctls[] = {
1da177e4
LT		 3222 {
3223 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3224 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
1da177e4
LT		 3225 .info = snd_hda_spdif_in_switch_info,
3226 .get = snd_hda_spdif_in_switch_get,
3227 .put = snd_hda_spdif_in_switch_put,
3228 },
3229 {
3230 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3231 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3232 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
1da177e4
LT		 3233 .info = snd_hda_spdif_mask_info,
3234 .get = snd_hda_spdif_in_status_get,
3235 },
3236 { } /* end */
3237};
3238
3239/**
3240 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3241 * @codec: the HDA codec
3242 * @nid: audio in widget NID
3243 *
3244 * Creates controls related with the SPDIF input.
3245 * Called from each patch supporting the SPDIF in.
3246 *
3247 * Returns 0 if successful, or a negative error code.
3248 */
12f288bf 3249int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1da177e4
LT		 3250{
3251 int err;
c8b6bf9b
TI		 3252 struct snd_kcontrol *kctl;
3253 struct snd_kcontrol_new *dig_mix;
09f99701 3254 int idx;
1da177e4 3255
dcda5806 3256 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
1afe206a 3257 if (idx < 0) {
4e76a883 3258 codec_err(codec, "too many IEC958 inputs\n");
09f99701
TI		 3259 return -EBUSY;
3260 }
1da177e4
LT		 3261 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3262 kctl = snd_ctl_new1(dig_mix, codec);
c8dcdf82
TI		 3263 if (!kctl)
3264 return -ENOMEM;
1da177e4 3265 kctl->private_value = nid;
3911a4c1 3266 err = snd_hda_ctl_add(codec, nid, kctl);
0ba21762 3267 if (err < 0)
1da177e4
LT		 3268 return err;
3269 }
0ba21762 3270 codec->spdif_in_enable =
3982d17e
AP		 3271 snd_hda_codec_read(codec, nid, 0,
3272 AC_VERB_GET_DIGI_CONVERT_1, 0) &
0ba21762 3273 AC_DIG1_ENABLE;
1da177e4
LT		 3274 return 0;
3275}
2698ea98 3276EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
1da177e4 3277
82beb8fd
TI		 3278/*
3279 * command cache
3280 */
1da177e4 3281
c370dd6e 3282/* build a 31bit cache key with the widget id and the command parameter */
b3ac5636
TI		 3283#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3284#define get_cmd_cache_nid(key) ((key) & 0xff)
3285#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3286
3287/**
3288 * snd_hda_codec_write_cache - send a single command with caching
3289 * @codec: the HDA codec
3290 * @nid: NID to send the command
e7ecc27e 3291 * @flags: optional bit flags
b3ac5636
TI		 3292 * @verb: the verb to send
3293 * @parm: the parameter for the verb
3294 *
3295 * Send a single command without waiting for response.
3296 *
3297 * Returns 0 if successful, or a negative error code.
3298 */
3299int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
e7ecc27e 3300 int flags, unsigned int verb, unsigned int parm)
b3ac5636 3301{
c370dd6e 3302 int err;
aa2936f5
TI		 3303 struct hda_cache_head *c;
3304 u32 key;
de1e37b7 3305 unsigned int cache_only;
33fa35ed 3306
de1e37b7
TI		 3307 cache_only = codec->cached_write;
3308 if (!cache_only) {
e7ecc27e 3309 err = snd_hda_codec_write(codec, nid, flags, verb, parm);
c370dd6e
TI		 3310 if (err < 0)
3311 return err;
3312 }
3313
aa2936f5
TI		 3314 /* parm may contain the verb stuff for get/set amp */
3315 verb = verb | (parm >> 8);
3316 parm &= 0xff;
3317 key = build_cmd_cache_key(nid, verb);
d068ebc2 3318 mutex_lock(&codec->bus->core.cmd_mutex);
aa2936f5 3319 c = get_alloc_hash(&codec->cmd_cache, key);
c370dd6e 3320 if (c) {
aa2936f5 3321 c->val = parm;
de1e37b7 3322 c->dirty = cache_only;
c370dd6e 3323 }
d068ebc2 3324 mutex_unlock(&codec->bus->core.cmd_mutex);
aa2936f5 3325 return 0;
b3ac5636 3326}
2698ea98 3327EXPORT_SYMBOL_GPL(snd_hda_codec_write_cache);
b3ac5636 3328
a68d5a54
TI		 3329/**
3330 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3331 * @codec: the HDA codec
3332 * @nid: NID to send the command
e7ecc27e 3333 * @flags: optional bit flags
a68d5a54
TI		 3334 * @verb: the verb to send
3335 * @parm: the parameter for the verb
3336 *
3337 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3338 * command if the parameter is already identical with the cached value.
3339 * If not, it sends the command and refreshes the cache.
3340 *
3341 * Returns 0 if successful, or a negative error code.
3342 */
3343int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
e7ecc27e 3344 int flags, unsigned int verb, unsigned int parm)
a68d5a54
TI		 3345{
3346 struct hda_cache_head *c;
3347 u32 key;
3348
3349 /* parm may contain the verb stuff for get/set amp */
3350 verb = verb | (parm >> 8);
3351 parm &= 0xff;
3352 key = build_cmd_cache_key(nid, verb);
d068ebc2 3353 mutex_lock(&codec->bus->core.cmd_mutex);
a68d5a54
TI		 3354 c = get_hash(&codec->cmd_cache, key);
3355 if (c && c->val == parm) {
d068ebc2 3356 mutex_unlock(&codec->bus->core.cmd_mutex);
a68d5a54
TI		 3357 return 0;
3358 }
d068ebc2 3359 mutex_unlock(&codec->bus->core.cmd_mutex);
e7ecc27e 3360 return snd_hda_codec_write_cache(codec, nid, flags, verb, parm);
a68d5a54 3361}
2698ea98 3362EXPORT_SYMBOL_GPL(snd_hda_codec_update_cache);
a68d5a54 3363
d5191e50
TI		 3364/**
3365 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3366 * @codec: HD-audio codec
3367 *
3368 * Execute all verbs recorded in the command caches to resume.
3369 */
b3ac5636
TI		 3370void snd_hda_codec_resume_cache(struct hda_codec *codec)
3371{
b3ac5636
TI		 3372 int i;
3373
c370dd6e 3374 mutex_lock(&codec->hash_mutex);
aa88a355 3375 codec->cached_write = 0;
c370dd6e
TI		 3376 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3377 struct hda_cache_head *buffer;
3378 u32 key;
3379
3380 buffer = snd_array_elem(&codec->cmd_cache.buf, i);
3381 key = buffer->key;
b3ac5636
TI		 3382 if (!key)
3383 continue;
c370dd6e
TI		 3384 if (!buffer->dirty)
3385 continue;
3386 buffer->dirty = 0;
3387 mutex_unlock(&codec->hash_mutex);
b3ac5636
TI		 3388 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3389 get_cmd_cache_cmd(key), buffer->val);
c370dd6e 3390 mutex_lock(&codec->hash_mutex);
b3ac5636 3391 }
c370dd6e 3392 mutex_unlock(&codec->hash_mutex);
b3ac5636 3393}
2698ea98 3394EXPORT_SYMBOL_GPL(snd_hda_codec_resume_cache);
b3ac5636
TI		 3395
3396/**
3397 * snd_hda_sequence_write_cache - sequence writes with caching
3398 * @codec: the HDA codec
3399 * @seq: VERB array to send
3400 *
3401 * Send the commands sequentially from the given array.
3402 * Thte commands are recorded on cache for power-save and resume.
3403 * The array must be terminated with NID=0.
3404 */
3405void snd_hda_sequence_write_cache(struct hda_codec *codec,
3406 const struct hda_verb *seq)
3407{
3408 for (; seq->nid; seq++)
3409 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3410 seq->param);
3411}
2698ea98 3412EXPORT_SYMBOL_GPL(snd_hda_sequence_write_cache);
b3ac5636 3413
dc870f38
TI		 3414/**
3415 * snd_hda_codec_flush_cache - Execute all pending (cached) amps / verbs
3416 * @codec: HD-audio codec
3417 */
3418void snd_hda_codec_flush_cache(struct hda_codec *codec)
3419{
3420 snd_hda_codec_resume_amp(codec);
3421 snd_hda_codec_resume_cache(codec);
3422}
2698ea98 3423EXPORT_SYMBOL_GPL(snd_hda_codec_flush_cache);
dc870f38 3424
95a962c3
TI		 3425/**
3426 * snd_hda_codec_set_power_to_all - Set the power state to all widgets
3427 * @codec: the HDA codec
3428 * @fg: function group (not used now)
3429 * @power_state: the power state to set (AC_PWRST_*)
3430 *
3431 * Set the given power state to all widgets that have the power control.
3432 * If the codec has power_filter set, it evaluates the power state and
3433 * filter out if it's unchanged as D3.
3434 */
4d7fbdbc 3435void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
9419ab6b 3436 unsigned int power_state)
54d17403 3437{
7639a06c 3438 hda_nid_t nid;
54d17403 3439
7639a06c 3440 for_each_hda_codec_node(nid, codec) {
7eba5c9d 3441 unsigned int wcaps = get_wcaps(codec, nid);
9419ab6b 3442 unsigned int state = power_state;
4d7fbdbc
TI		 3443 if (!(wcaps & AC_WCAP_POWER))
3444 continue;
9419ab6b
TI		 3445 if (codec->power_filter) {
3446 state = codec->power_filter(codec, nid, power_state);
3447 if (state != power_state && power_state == AC_PWRST_D3)
4d7fbdbc 3448 continue;
1194b5b7 3449 }
4d7fbdbc 3450 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
9419ab6b 3451 state);
54d17403 3452 }
cb53c626 3453}
2698ea98 3454EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all);
4d7fbdbc 3455
432c641e
TI		 3456/*
3457 * wait until the state is reached, returns the current state
3458 */
3459static unsigned int hda_sync_power_state(struct hda_codec *codec,
3460 hda_nid_t fg,
3461 unsigned int power_state)
3462{
3463 unsigned long end_time = jiffies + msecs_to_jiffies(500);
3464 unsigned int state, actual_state;
3465
3466 for (;;) {
3467 state = snd_hda_codec_read(codec, fg, 0,
3468 AC_VERB_GET_POWER_STATE, 0);
3469 if (state & AC_PWRST_ERROR)
3470 break;
3471 actual_state = (state >> 4) & 0x0f;
3472 if (actual_state == power_state)
3473 break;
3474 if (time_after_eq(jiffies, end_time))
3475 break;
3476 /* wait until the codec reachs to the target state */
3477 msleep(1);
3478 }
3479 return state;
3480}
3481
95a962c3
TI		 3482/**
3483 * snd_hda_codec_eapd_power_filter - A power filter callback for EAPD
3484 * @codec: the HDA codec
3485 * @nid: widget NID
3486 * @power_state: power state to evalue
3487 *
3488 * Don't power down the widget if it controls eapd and EAPD_BTLENABLE is set.
3489 * This can be used a codec power_filter callback.
3490 */
ba615b86
TI		 3491unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
3492 hda_nid_t nid,
3493 unsigned int power_state)
9419ab6b 3494{
7639a06c 3495 if (nid == codec->core.afg || nid == codec->core.mfg)
dfc6e469 3496 return power_state;
9419ab6b
TI		 3497 if (power_state == AC_PWRST_D3 &&
3498 get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
3499 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3500 int eapd = snd_hda_codec_read(codec, nid, 0,
3501 AC_VERB_GET_EAPD_BTLENABLE, 0);
3502 if (eapd & 0x02)
3503 return AC_PWRST_D0;
3504 }
3505 return power_state;
3506}
2698ea98 3507EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter);
9419ab6b 3508
4d7fbdbc 3509/*
08fa20ae 3510 * set power state of the codec, and return the power state
4d7fbdbc 3511 */
d819387e 3512static unsigned int hda_set_power_state(struct hda_codec *codec,
08fa20ae 3513 unsigned int power_state)
4d7fbdbc 3514{
7639a06c 3515 hda_nid_t fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
09617ce4
WX		 3516 int count;
3517 unsigned int state;
63e51fd7 3518 int flags = 0;
09617ce4 3519
4d7fbdbc 3520 /* this delay seems necessary to avoid click noise at power-down */
0f4ccbb0 3521 if (power_state == AC_PWRST_D3) {
7f132927 3522 if (codec->depop_delay < 0)
7639a06c 3523 msleep(codec_has_epss(codec) ? 10 : 100);
7f132927
ML		 3524 else if (codec->depop_delay > 0)
3525 msleep(codec->depop_delay);
63e51fd7 3526 flags = HDA_RW_NO_RESPONSE_FALLBACK;
0f4ccbb0 3527 }
09617ce4
WX		 3528
3529 /* repeat power states setting at most 10 times*/
3530 for (count = 0; count < 10; count++) {
432c641e
TI		 3531 if (codec->patch_ops.set_power_state)
3532 codec->patch_ops.set_power_state(codec, fg,
3533 power_state);
3534 else {
dfc6e469
TI		 3535 state = power_state;
3536 if (codec->power_filter)
3537 state = codec->power_filter(codec, fg, state);
3538 if (state == power_state || power_state != AC_PWRST_D3)
3539 snd_hda_codec_read(codec, fg, flags,
3540 AC_VERB_SET_POWER_STATE,
3541 state);
9419ab6b 3542 snd_hda_codec_set_power_to_all(codec, fg, power_state);
432c641e
TI		 3543 }
3544 state = hda_sync_power_state(codec, fg, power_state);
09617ce4
WX		 3545 if (!(state & AC_PWRST_ERROR))
3546 break;
3547 }
b8dfc462 3548
08fa20ae 3549 return state;
4d7fbdbc 3550}
cb53c626 3551
b9c590bb
TI		 3552/* sync power states of all widgets;
3553 * this is called at the end of codec parsing
3554 */
3555static void sync_power_up_states(struct hda_codec *codec)
3556{
7639a06c 3557 hda_nid_t nid;
b9c590bb 3558
ba615b86
TI		 3559 /* don't care if no filter is used */
3560 if (!codec->power_filter)
b9c590bb
TI		 3561 return;
3562
7639a06c 3563 for_each_hda_codec_node(nid, codec) {
b9c590bb 3564 unsigned int wcaps = get_wcaps(codec, nid);
9040d102 3565 unsigned int target;
b9c590bb
TI		 3566 if (!(wcaps & AC_WCAP_POWER))
3567 continue;
3568 target = codec->power_filter(codec, nid, AC_PWRST_D0);
3569 if (target == AC_PWRST_D0)
3570 continue;
9040d102 3571 if (!snd_hda_check_power_state(codec, nid, target))
b9c590bb
TI		 3572 snd_hda_codec_write(codec, nid, 0,
3573 AC_VERB_SET_POWER_STATE, target);
3574 }
3575}
3576
648a8d27 3577#ifdef CONFIG_SND_HDA_RECONFIG
11aeff08
TI		 3578/* execute additional init verbs */
3579static void hda_exec_init_verbs(struct hda_codec *codec)
3580{
3581 if (codec->init_verbs.list)
3582 snd_hda_sequence_write(codec, codec->init_verbs.list);
3583}
3584#else
3585static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3586#endif
3587
2a43952a 3588#ifdef CONFIG_PM
cc72da7d
TI		 3589/* update the power on/off account with the current jiffies */
3590static void update_power_acct(struct hda_codec *codec, bool on)
3591{
3592 unsigned long delta = jiffies - codec->power_jiffies;
3593
3594 if (on)
3595 codec->power_on_acct += delta;
3596 else
3597 codec->power_off_acct += delta;
3598 codec->power_jiffies += delta;
3599}
3600
3601void snd_hda_update_power_acct(struct hda_codec *codec)
3602{
3603 update_power_acct(codec, hda_codec_is_power_on(codec));
3604}
3605
cb53c626
TI		 3606/*
3607 * call suspend and power-down; used both from PM and power-save
08fa20ae 3608 * this function returns the power state in the end
cb53c626 3609 */
cc72da7d 3610static unsigned int hda_call_codec_suspend(struct hda_codec *codec)
cb53c626 3611{
08fa20ae
TI		 3612 unsigned int state;
3613
7639a06c 3614 atomic_inc(&codec->core.in_pm);
989c3187 3615
cb53c626 3616 if (codec->patch_ops.suspend)
68cb2b55 3617 codec->patch_ops.suspend(codec);
eb541337 3618 hda_cleanup_all_streams(codec);
d819387e 3619 state = hda_set_power_state(codec, AC_PWRST_D3);
cc72da7d 3620 update_power_acct(codec, true);
7639a06c 3621 atomic_dec(&codec->core.in_pm);
08fa20ae 3622 return state;
54d17403
TI		 3623}
3624
c370dd6e
TI		 3625/* mark all entries of cmd and amp caches dirty */
3626static void hda_mark_cmd_cache_dirty(struct hda_codec *codec)
3627{
3628 int i;
3629 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3630 struct hda_cache_head *cmd;
3631 cmd = snd_array_elem(&codec->cmd_cache.buf, i);
3632 cmd->dirty = 1;
3633 }
3634 for (i = 0; i < codec->amp_cache.buf.used; i++) {
3635 struct hda_amp_info *amp;
f038fcac 3636 amp = snd_array_elem(&codec->amp_cache.buf, i);
c370dd6e
TI		 3637 amp->head.dirty = 1;
3638 }
3639}
3640
cb53c626
TI		 3641/*
3642 * kick up codec; used both from PM and power-save
3643 */
3644static void hda_call_codec_resume(struct hda_codec *codec)
3645{
7639a06c 3646 atomic_inc(&codec->core.in_pm);
989c3187 3647
c370dd6e
TI		 3648 hda_mark_cmd_cache_dirty(codec);
3649
cc72da7d 3650 codec->power_jiffies = jiffies;
cc72da7d 3651
d819387e 3652 hda_set_power_state(codec, AC_PWRST_D0);
ac0547dc 3653 restore_shutup_pins(codec);
11aeff08 3654 hda_exec_init_verbs(codec);
31614bb8 3655 snd_hda_jack_set_dirty_all(codec);
cb53c626
TI		 3656 if (codec->patch_ops.resume)
3657 codec->patch_ops.resume(codec);
3658 else {
9d99f312
TI		 3659 if (codec->patch_ops.init)
3660 codec->patch_ops.init(codec);
cb53c626
TI		 3661 snd_hda_codec_resume_amp(codec);
3662 snd_hda_codec_resume_cache(codec);
3663 }
26a6cb6c
DH		 3664
3665 if (codec->jackpoll_interval)
3666 hda_jackpoll_work(&codec->jackpoll_work.work);
31614bb8 3667 else
26a6cb6c 3668 snd_hda_jack_report_sync(codec);
7639a06c 3669 atomic_dec(&codec->core.in_pm);
cb53c626 3670}
59ed1ead 3671
cc72da7d 3672static int hda_codec_runtime_suspend(struct device *dev)
59ed1ead
TI		 3673{
3674 struct hda_codec *codec = dev_to_hda_codec(dev);
bbbc7e85 3675 struct hda_pcm *pcm;
cc72da7d 3676 unsigned int state;
59ed1ead
TI		 3677
3678 cancel_delayed_work_sync(&codec->jackpoll_work);
bbbc7e85
TI		 3679 list_for_each_entry(pcm, &codec->pcm_list_head, list)
3680 snd_pcm_suspend_all(pcm->pcm);
cc72da7d 3681 state = hda_call_codec_suspend(codec);
7639a06c
TI		 3682 if (codec_has_clkstop(codec) && codec_has_epss(codec) &&
3683 (state & AC_PWRST_CLK_STOP_OK))
3684 snd_hdac_codec_link_down(&codec->core);
59ed1ead
TI		 3685 return 0;
3686}
3687
cc72da7d 3688static int hda_codec_runtime_resume(struct device *dev)
59ed1ead 3689{
55ed9cd1
TI		 3690 struct hda_codec *codec = dev_to_hda_codec(dev);
3691
7639a06c 3692 snd_hdac_codec_link_up(&codec->core);
55ed9cd1 3693 hda_call_codec_resume(codec);
cc72da7d 3694 pm_runtime_mark_last_busy(dev);
59ed1ead
TI		 3695 return 0;
3696}
2a43952a 3697#endif /* CONFIG_PM */
cb53c626 3698
59ed1ead
TI		 3699/* referred in hda_bind.c */
3700const struct dev_pm_ops hda_codec_driver_pm = {
cc72da7d
TI		 3701 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
3702 pm_runtime_force_resume)
3703 SET_RUNTIME_PM_OPS(hda_codec_runtime_suspend, hda_codec_runtime_resume,
3704 NULL)
59ed1ead 3705};
54d17403 3706
9c9a5175
TI		 3707/*
3708 * add standard channel maps if not specified
3709 */
3710static int add_std_chmaps(struct hda_codec *codec)
3711{
bbbc7e85
TI		 3712 struct hda_pcm *pcm;
3713 int str, err;
9c9a5175 3714
bbbc7e85 3715 list_for_each_entry(pcm, &codec->pcm_list_head, list) {
9c9a5175 3716 for (str = 0; str < 2; str++) {
bbbc7e85 3717 struct hda_pcm_stream *hinfo = &pcm->stream[str];
9c9a5175 3718 struct snd_pcm_chmap *chmap;
ee81abb6 3719 const struct snd_pcm_chmap_elem *elem;
9c9a5175 3720
bbbc7e85 3721 if (pcm->own_chmap)
9c9a5175
TI		 3722 continue;
3723 if (!pcm || !hinfo->substreams)
3724 continue;
ee81abb6 3725 elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
bbbc7e85 3726 err = snd_pcm_add_chmap_ctls(pcm->pcm, str, elem,
9c9a5175
TI		 3727 hinfo->channels_max,
3728 0, &chmap);
3729 if (err < 0)
3730 return err;
3731 chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
3732 }
3733 }
3734 return 0;
3735}
3736
ee81abb6
TI		 3737/* default channel maps for 2.1 speakers;
3738 * since HD-audio supports only stereo, odd number channels are omitted
3739 */
3740const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
3741 { .channels = 2,
3742 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
3743 { .channels = 4,
3744 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
3745 SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
3746 { }
3747};
3748EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
3749
6c1f45ea
TI		 3750int snd_hda_codec_build_controls(struct hda_codec *codec)
3751{
3752 int err = 0;
11aeff08 3753 hda_exec_init_verbs(codec);
6c1f45ea
TI		 3754 /* continue to initialize... */
3755 if (codec->patch_ops.init)
3756 err = codec->patch_ops.init(codec);
3757 if (!err && codec->patch_ops.build_controls)
3758 err = codec->patch_ops.build_controls(codec);
6c1f45ea
TI		 3759 if (err < 0)
3760 return err;
9c9a5175
TI		 3761
3762 /* we create chmaps here instead of build_pcms */
3763 err = add_std_chmaps(codec);
3764 if (err < 0)
3765 return err;
3766
26a6cb6c
DH		 3767 if (codec->jackpoll_interval)
3768 hda_jackpoll_work(&codec->jackpoll_work.work);
3769 else
3770 snd_hda_jack_report_sync(codec); /* call at the last init point */
b9c590bb 3771 sync_power_up_states(codec);
1da177e4
LT		 3772 return 0;
3773}
3774
1da177e4
LT		 3775/*
3776 * stream formats
3777 */
befdf316
TI		 3778struct hda_rate_tbl {
3779 unsigned int hz;
3780 unsigned int alsa_bits;
3781 unsigned int hda_fmt;
3782};
3783
92f10b3f
TI		 3784/* rate = base * mult / div */
3785#define HDA_RATE(base, mult, div) \
3786 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3787 (((div) - 1) << AC_FMT_DIV_SHIFT))
3788
befdf316 3789static struct hda_rate_tbl rate_bits[] = {
1da177e4 3790 /* rate in Hz, ALSA rate bitmask, HDA format value */
9d8f53f2
NG		 3791
3792 /* autodetected value used in snd_hda_query_supported_pcm */
92f10b3f
TI		 3793 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3794 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3795 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3796 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3797 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3798 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3799 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3800 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3801 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3802 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3803 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
a961f9fe
TI		 3804#define AC_PAR_PCM_RATE_BITS 11
3805 /* up to bits 10, 384kHZ isn't supported properly */
3806
3807 /* not autodetected value */
92f10b3f 3808 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
9d8f53f2 3809
befdf316 3810 { 0 } /* terminator */
1da177e4
LT		 3811};
3812
3813/**
3814 * snd_hda_calc_stream_format - calculate format bitset
6194b99d 3815 * @codec: HD-audio codec
1da177e4
LT		 3816 * @rate: the sample rate
3817 * @channels: the number of channels
3818 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3819 * @maxbps: the max. bps
a11e9b16 3820 * @spdif_ctls: HD-audio SPDIF status bits (0 if irrelevant)
1da177e4
LT		 3821 *
3822 * Calculate the format bitset from the given rate, channels and th PCM format.
3823 *
3824 * Return zero if invalid.
3825 */
6194b99d
TI		 3826unsigned int snd_hda_calc_stream_format(struct hda_codec *codec,
3827 unsigned int rate,
1da177e4
LT		 3828 unsigned int channels,
3829 unsigned int format,
32c168c8
AH		 3830 unsigned int maxbps,
3831 unsigned short spdif_ctls)
1da177e4
LT		 3832{
3833 int i;
3834 unsigned int val = 0;
3835
befdf316
TI		 3836 for (i = 0; rate_bits[i].hz; i++)
3837 if (rate_bits[i].hz == rate) {
3838 val = rate_bits[i].hda_fmt;
1da177e4
LT		 3839 break;
3840 }
0ba21762 3841 if (!rate_bits[i].hz) {
6194b99d 3842 codec_dbg(codec, "invalid rate %d\n", rate);
1da177e4
LT		 3843 return 0;
3844 }
3845
3846 if (channels == 0 || channels > 8) {
6194b99d 3847 codec_dbg(codec, "invalid channels %d\n", channels);
1da177e4
LT		 3848 return 0;
3849 }
3850 val |= channels - 1;
3851
3852 switch (snd_pcm_format_width(format)) {
28aedaf7 3853 case 8:
92f10b3f 3854 val |= AC_FMT_BITS_8;
28aedaf7
NL		 3855 break;
3856 case 16:
92f10b3f 3857 val |= AC_FMT_BITS_16;
28aedaf7 3858 break;
1da177e4
LT		 3859 case 20:
3860 case 24:
3861 case 32:
b0bb3aa6 3862 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
92f10b3f 3863 val |= AC_FMT_BITS_32;
1da177e4 3864 else if (maxbps >= 24)
92f10b3f 3865 val |= AC_FMT_BITS_24;
1da177e4 3866 else
92f10b3f 3867 val |= AC_FMT_BITS_20;
1da177e4
LT		 3868 break;
3869 default:
6194b99d 3870 codec_dbg(codec, "invalid format width %d\n",
4e76a883 3871 snd_pcm_format_width(format));
1da177e4
LT		 3872 return 0;
3873 }
3874
32c168c8 3875 if (spdif_ctls & AC_DIG1_NONAUDIO)
92f10b3f 3876 val |= AC_FMT_TYPE_NON_PCM;
32c168c8 3877
1da177e4
LT		 3878 return val;
3879}
2698ea98 3880EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format);
1da177e4 3881
c3b6bcc2
TI		 3882static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
3883 int dir)
92c7c8a7
TI		 3884{
3885 unsigned int val = 0;
7639a06c 3886 if (nid != codec->core.afg &&
92c7c8a7
TI		 3887 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3888 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3889 if (!val || val == -1)
7639a06c 3890 val = snd_hda_param_read(codec, codec->core.afg, AC_PAR_PCM);
92c7c8a7
TI		 3891 if (!val || val == -1)
3892 return 0;
3893 return val;
3894}
3895
3896static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3897{
c3b6bcc2 3898 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
92c7c8a7
TI		 3899 get_pcm_param);
3900}
3901
c3b6bcc2
TI		 3902static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
3903 int dir)
92c7c8a7
TI		 3904{
3905 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3906 if (!streams || streams == -1)
7639a06c 3907 streams = snd_hda_param_read(codec, codec->core.afg, AC_PAR_STREAM);
92c7c8a7
TI		 3908 if (!streams || streams == -1)
3909 return 0;
3910 return streams;
3911}
3912
3913static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3914{
c3b6bcc2 3915 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
92c7c8a7
TI		 3916 get_stream_param);
3917}
3918
1da177e4
LT		 3919/**
3920 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3921 * @codec: the HDA codec
3922 * @nid: NID to query
3923 * @ratesp: the pointer to store the detected rate bitflags
3924 * @formatsp: the pointer to store the detected formats
3925 * @bpsp: the pointer to store the detected format widths
3926 *
3927 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3928 * or @bsps argument is ignored.
3929 *
3930 * Returns 0 if successful, otherwise a negative error code.
3931 */
384a48d7 3932int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
1da177e4
LT		 3933 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3934{
ee504710 3935 unsigned int i, val, wcaps;
1da177e4 3936
ee504710 3937 wcaps = get_wcaps(codec, nid);
92c7c8a7 3938 val = query_pcm_param(codec, nid);
1da177e4
LT		 3939
3940 if (ratesp) {
3941 u32 rates = 0;
a961f9fe 3942 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
1da177e4 3943 if (val & (1 << i))
befdf316 3944 rates |= rate_bits[i].alsa_bits;
1da177e4 3945 }
ee504710 3946 if (rates == 0) {
4e76a883
TI		 3947 codec_err(codec,
3948 "rates == 0 (nid=0x%x, val=0x%x, ovrd=%i)\n",
3949 nid, val,
3950 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
ee504710
JK		 3951 return -EIO;
3952 }
1da177e4
LT		 3953 *ratesp = rates;
3954 }
3955
3956 if (formatsp || bpsp) {
3957 u64 formats = 0;
ee504710 3958 unsigned int streams, bps;
1da177e4 3959
92c7c8a7
TI		 3960 streams = query_stream_param(codec, nid);
3961 if (!streams)
1da177e4 3962 return -EIO;
1da177e4
LT		 3963
3964 bps = 0;
3965 if (streams & AC_SUPFMT_PCM) {
3966 if (val & AC_SUPPCM_BITS_8) {
3967 formats |= SNDRV_PCM_FMTBIT_U8;
3968 bps = 8;
3969 }
3970 if (val & AC_SUPPCM_BITS_16) {
3971 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3972 bps = 16;
3973 }
3974 if (wcaps & AC_WCAP_DIGITAL) {
3975 if (val & AC_SUPPCM_BITS_32)
3976 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3977 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3978 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3979 if (val & AC_SUPPCM_BITS_24)
3980 bps = 24;
3981 else if (val & AC_SUPPCM_BITS_20)
3982 bps = 20;
0ba21762
TI		 3983 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3984 AC_SUPPCM_BITS_32)) {
1da177e4
LT		 3985 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3986 if (val & AC_SUPPCM_BITS_32)
3987 bps = 32;
1da177e4
LT		 3988 else if (val & AC_SUPPCM_BITS_24)
3989 bps = 24;
33ef7651
NG		 3990 else if (val & AC_SUPPCM_BITS_20)
3991 bps = 20;
1da177e4
LT		 3992 }
3993 }
8c7dd890 3994#if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
b5025c50 3995 if (streams & AC_SUPFMT_FLOAT32) {
1da177e4 3996 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
b0bb3aa6
TI		 3997 if (!bps)
3998 bps = 32;
b5025c50 3999 }
8c7dd890 4000#endif
b5025c50 4001 if (streams == AC_SUPFMT_AC3) {
0ba21762 4002 /* should be exclusive */
1da177e4
LT		 4003 /* temporary hack: we have still no proper support
4004 * for the direct AC3 stream...
4005 */
4006 formats |= SNDRV_PCM_FMTBIT_U8;
4007 bps = 8;
4008 }
ee504710 4009 if (formats == 0) {
4e76a883
TI		 4010 codec_err(codec,
4011 "formats == 0 (nid=0x%x, val=0x%x, ovrd=%i, streams=0x%x)\n",
4012 nid, val,
4013 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
4014 streams);
ee504710
JK		 4015 return -EIO;
4016 }
1da177e4
LT		 4017 if (formatsp)
4018 *formatsp = formats;
4019 if (bpsp)
4020 *bpsp = bps;
4021 }
4022
4023 return 0;
4024}
2698ea98 4025EXPORT_SYMBOL_GPL(snd_hda_query_supported_pcm);
1da177e4
LT		 4026
4027/**
d5191e50
TI		 4028 * snd_hda_is_supported_format - Check the validity of the format
4029 * @codec: HD-audio codec
4030 * @nid: NID to check
4031 * @format: the HD-audio format value to check
4032 *
4033 * Check whether the given node supports the format value.
1da177e4
LT		 4034 *
4035 * Returns 1 if supported, 0 if not.
4036 */
4037int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
4038 unsigned int format)
4039{
4040 int i;
4041 unsigned int val = 0, rate, stream;
4042
92c7c8a7
TI		 4043 val = query_pcm_param(codec, nid);
4044 if (!val)
4045 return 0;
1da177e4
LT		 4046
4047 rate = format & 0xff00;
a961f9fe 4048 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
befdf316 4049 if (rate_bits[i].hda_fmt == rate) {
1da177e4
LT		 4050 if (val & (1 << i))
4051 break;
4052 return 0;
4053 }
a961f9fe 4054 if (i >= AC_PAR_PCM_RATE_BITS)
1da177e4
LT		 4055 return 0;
4056
92c7c8a7
TI		 4057 stream = query_stream_param(codec, nid);
4058 if (!stream)
1da177e4
LT		 4059 return 0;
4060
4061 if (stream & AC_SUPFMT_PCM) {
4062 switch (format & 0xf0) {
4063 case 0x00:
0ba21762 4064 if (!(val & AC_SUPPCM_BITS_8))
1da177e4
LT		 4065 return 0;
4066 break;
4067 case 0x10:
0ba21762 4068 if (!(val & AC_SUPPCM_BITS_16))
1da177e4
LT		 4069 return 0;
4070 break;
4071 case 0x20:
0ba21762 4072 if (!(val & AC_SUPPCM_BITS_20))
1da177e4
LT		 4073 return 0;
4074 break;
4075 case 0x30:
0ba21762 4076 if (!(val & AC_SUPPCM_BITS_24))
1da177e4
LT		 4077 return 0;
4078 break;
4079 case 0x40:
0ba21762 4080 if (!(val & AC_SUPPCM_BITS_32))
1da177e4
LT		 4081 return 0;
4082 break;
4083 default:
4084 return 0;
4085 }
4086 } else {
4087 /* FIXME: check for float32 and AC3? */
4088 }
4089
4090 return 1;
4091}
2698ea98 4092EXPORT_SYMBOL_GPL(snd_hda_is_supported_format);
1da177e4
LT		 4093
4094/*
4095 * PCM stuff
4096 */
4097static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
4098 struct hda_codec *codec,
c8b6bf9b 4099 struct snd_pcm_substream *substream)
1da177e4
LT		 4100{
4101 return 0;
4102}
4103
4104static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
4105 struct hda_codec *codec,
4106 unsigned int stream_tag,
4107 unsigned int format,
c8b6bf9b 4108 struct snd_pcm_substream *substream)
1da177e4
LT		 4109{
4110 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4111 return 0;
4112}
4113
4114static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
4115 struct hda_codec *codec,
c8b6bf9b 4116 struct snd_pcm_substream *substream)
1da177e4 4117{
888afa15 4118 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
1da177e4
LT		 4119 return 0;
4120}
4121
6c1f45ea
TI		 4122static int set_pcm_default_values(struct hda_codec *codec,
4123 struct hda_pcm_stream *info)
1da177e4 4124{
ee504710
JK		 4125 int err;
4126
0ba21762
TI		 4127 /* query support PCM information from the given NID */
4128 if (info->nid && (!info->rates || !info->formats)) {
ee504710 4129 err = snd_hda_query_supported_pcm(codec, info->nid,
0ba21762
TI		 4130 info->rates ? NULL : &info->rates,
4131 info->formats ? NULL : &info->formats,
4132 info->maxbps ? NULL : &info->maxbps);
ee504710
JK		 4133 if (err < 0)
4134 return err;
1da177e4
LT		 4135 }
4136 if (info->ops.open == NULL)
4137 info->ops.open = hda_pcm_default_open_close;
4138 if (info->ops.close == NULL)
4139 info->ops.close = hda_pcm_default_open_close;
4140 if (info->ops.prepare == NULL) {
da3cec35
TI		 4141 if (snd_BUG_ON(!info->nid))
4142 return -EINVAL;
1da177e4
LT		 4143 info->ops.prepare = hda_pcm_default_prepare;
4144 }
1da177e4 4145 if (info->ops.cleanup == NULL) {
da3cec35
TI		 4146 if (snd_BUG_ON(!info->nid))
4147 return -EINVAL;
1da177e4
LT		 4148 info->ops.cleanup = hda_pcm_default_cleanup;
4149 }
4150 return 0;
4151}
4152
eb541337
TI		 4153/*
4154 * codec prepare/cleanup entries
4155 */
95a962c3
TI		 4156/**
4157 * snd_hda_codec_prepare - Prepare a stream
4158 * @codec: the HDA codec
4159 * @hinfo: PCM information
4160 * @stream: stream tag to assign
4161 * @format: format id to assign
4162 * @substream: PCM substream to assign
4163 *
4164 * Calls the prepare callback set by the codec with the given arguments.
4165 * Clean up the inactive streams when successful.
4166 */
eb541337
TI		 4167int snd_hda_codec_prepare(struct hda_codec *codec,
4168 struct hda_pcm_stream *hinfo,
4169 unsigned int stream,
4170 unsigned int format,
4171 struct snd_pcm_substream *substream)
4172{
4173 int ret;
3f50ac6a 4174 mutex_lock(&codec->bus->prepare_mutex);
61ca4107
TI		 4175 if (hinfo->ops.prepare)
4176 ret = hinfo->ops.prepare(hinfo, codec, stream, format,
4177 substream);
4178 else
4179 ret = -ENODEV;
eb541337
TI		 4180 if (ret >= 0)
4181 purify_inactive_streams(codec);
3f50ac6a 4182 mutex_unlock(&codec->bus->prepare_mutex);
eb541337
TI		 4183 return ret;
4184}
2698ea98 4185EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
eb541337 4186
95a962c3
TI		 4187/**
4188 * snd_hda_codec_cleanup - Prepare a stream
4189 * @codec: the HDA codec
4190 * @hinfo: PCM information
4191 * @substream: PCM substream
4192 *
4193 * Calls the cleanup callback set by the codec with the given arguments.
4194 */
eb541337
TI		 4195void snd_hda_codec_cleanup(struct hda_codec *codec,
4196 struct hda_pcm_stream *hinfo,
4197 struct snd_pcm_substream *substream)
4198{
3f50ac6a 4199 mutex_lock(&codec->bus->prepare_mutex);
61ca4107
TI		 4200 if (hinfo->ops.cleanup)
4201 hinfo->ops.cleanup(hinfo, codec, substream);
3f50ac6a 4202 mutex_unlock(&codec->bus->prepare_mutex);
eb541337 4203}
2698ea98 4204EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
eb541337 4205
d5191e50 4206/* global */
e3303235
JK		 4207const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4208 "Audio", "SPDIF", "HDMI", "Modem"
4209};
4210
529bd6c4
TI		 4211/*
4212 * get the empty PCM device number to assign
4213 */
36bb00d4 4214static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type)
529bd6c4 4215{
f5d6def5 4216 /* audio device indices; not linear to keep compatibility */
36bb00d4
TI		 4217 /* assigned to static slots up to dev#10; if more needed, assign
4218 * the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y)
4219 */
f5d6def5
WF		 4220 static int audio_idx[HDA_PCM_NTYPES][5] = {
4221 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4222 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
92608bad 4223 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
f5d6def5 4224 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
529bd6c4 4225 };
f5d6def5
WF		 4226 int i;
4227
4228 if (type >= HDA_PCM_NTYPES) {
4e76a883 4229 dev_err(bus->card->dev, "Invalid PCM type %d\n", type);
529bd6c4
TI		 4230 return -EINVAL;
4231 }
f5d6def5 4232
36bb00d4
TI		 4233 for (i = 0; audio_idx[type][i] >= 0; i++) {
4234#ifndef CONFIG_SND_DYNAMIC_MINORS
4235 if (audio_idx[type][i] >= 8)
4236 break;
4237#endif
f5d6def5
WF		 4238 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4239 return audio_idx[type][i];
36bb00d4 4240 }
f5d6def5 4241
36bb00d4 4242#ifdef CONFIG_SND_DYNAMIC_MINORS
01b65bfb
TI		 4243 /* non-fixed slots starting from 10 */
4244 for (i = 10; i < 32; i++) {
4245 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4246 return i;
4247 }
36bb00d4 4248#endif
01b65bfb 4249
4e76a883 4250 dev_warn(bus->card->dev, "Too many %s devices\n",
28aedaf7 4251 snd_hda_pcm_type_name[type]);
36bb00d4 4252#ifndef CONFIG_SND_DYNAMIC_MINORS
4e76a883
TI		 4253 dev_warn(bus->card->dev,
4254 "Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n");
36bb00d4 4255#endif
f5d6def5 4256 return -EAGAIN;
529bd6c4
TI		 4257}
4258
1a4ba30c
TI		 4259/* call build_pcms ops of the given codec and set up the default parameters */
4260int snd_hda_codec_parse_pcms(struct hda_codec *codec)
176d5335 4261{
bbbc7e85 4262 struct hda_pcm *cpcm;
1a4ba30c 4263 int err;
176d5335 4264
bbbc7e85 4265 if (!list_empty(&codec->pcm_list_head))
1a4ba30c
TI		 4266 return 0; /* already parsed */
4267
4268 if (!codec->patch_ops.build_pcms)
4269 return 0;
4270
4271 err = codec->patch_ops.build_pcms(codec);
4272 if (err < 0) {
4273 codec_err(codec, "cannot build PCMs for #%d (error %d)\n",
d068ebc2 4274 codec->core.addr, err);
1a4ba30c
TI		 4275 return err;
4276 }
4277
bbbc7e85 4278 list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
1a4ba30c
TI		 4279 int stream;
4280
4281 for (stream = 0; stream < 2; stream++) {
4282 struct hda_pcm_stream *info = &cpcm->stream[stream];
4283
4284 if (!info->substreams)
4285 continue;
176d5335 4286 err = set_pcm_default_values(codec, info);
1a4ba30c
TI		 4287 if (err < 0) {
4288 codec_warn(codec,
4289 "fail to setup default for PCM %s\n",
4290 cpcm->name);
176d5335 4291 return err;
1a4ba30c 4292 }
176d5335
TI		 4293 }
4294 }
1a4ba30c
TI		 4295
4296 return 0;
176d5335
TI		 4297}
4298
529bd6c4
TI		 4299/* assign all PCMs of the given codec */
4300int snd_hda_codec_build_pcms(struct hda_codec *codec)
4301{
1a4ba30c 4302 struct hda_bus *bus = codec->bus;
bbbc7e85 4303 struct hda_pcm *cpcm;
1a4ba30c 4304 int dev, err;
529bd6c4 4305
1a4ba30c
TI		 4306 if (snd_BUG_ON(!bus->ops.attach_pcm))
4307 return -EINVAL;
4308
4309 err = snd_hda_codec_parse_pcms(codec);
4310 if (err < 0) {
4311 snd_hda_codec_reset(codec);
4312 return err;
529bd6c4 4313 }
1a4ba30c
TI		 4314
4315 /* attach a new PCM streams */
bbbc7e85 4316 list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
1a4ba30c
TI		 4317 if (cpcm->pcm)
4318 continue; /* already attached */
529bd6c4 4319 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
41b5b01a 4320 continue; /* no substreams assigned */
529bd6c4 4321
1a4ba30c
TI		 4322 dev = get_empty_pcm_device(bus, cpcm->pcm_type);
4323 if (dev < 0)
4324 continue; /* no fatal error */
4325 cpcm->device = dev;
4326 err = bus->ops.attach_pcm(bus, codec, cpcm);
4327 if (err < 0) {
4328 codec_err(codec,
4329 "cannot attach PCM stream %d for codec #%d\n",
d068ebc2 4330 dev, codec->core.addr);
1a4ba30c 4331 continue; /* no fatal error */
529bd6c4
TI		 4332 }
4333 }
1a4ba30c 4334
529bd6c4
TI		 4335 return 0;
4336}
4337
1da177e4
LT		 4338/**
4339 * snd_hda_add_new_ctls - create controls from the array
4340 * @codec: the HDA codec
c8b6bf9b 4341 * @knew: the array of struct snd_kcontrol_new
1da177e4
LT		 4342 *
4343 * This helper function creates and add new controls in the given array.
4344 * The array must be terminated with an empty entry as terminator.
4345 *
4346 * Returns 0 if successful, or a negative error code.
4347 */
031024ee
TI		 4348int snd_hda_add_new_ctls(struct hda_codec *codec,
4349 const struct snd_kcontrol_new *knew)
1da177e4 4350{
4d02d1b6 4351 int err;
1da177e4
LT		 4352
4353 for (; knew->name; knew++) {
54d17403 4354 struct snd_kcontrol *kctl;
1afe206a 4355 int addr = 0, idx = 0;
5b0cb1d8
JK		 4356 if (knew->iface == -1) /* skip this codec private value */
4357 continue;
1afe206a 4358 for (;;) {
54d17403 4359 kctl = snd_ctl_new1(knew, codec);
0ba21762 4360 if (!kctl)
54d17403 4361 return -ENOMEM;
1afe206a
TI		 4362 if (addr > 0)
4363 kctl->id.device = addr;
4364 if (idx > 0)
4365 kctl->id.index = idx;
3911a4c1 4366 err = snd_hda_ctl_add(codec, 0, kctl);
1afe206a
TI		 4367 if (!err)
4368 break;
4369 /* try first with another device index corresponding to
4370 * the codec addr; if it still fails (or it's the
4371 * primary codec), then try another control index
4372 */
d068ebc2
TI		 4373 if (!addr && codec->core.addr)
4374 addr = codec->core.addr;
1afe206a
TI		 4375 else if (!idx && !knew->index) {
4376 idx = find_empty_mixer_ctl_idx(codec,
dcda5806 4377 knew->name, 0);
1afe206a
TI		 4378 if (idx <= 0)
4379 return err;
4380 } else
54d17403
TI		 4381 return err;
4382 }
1da177e4
LT		 4383 }
4384 return 0;
4385}
2698ea98 4386EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
1da177e4 4387
83012a7c 4388#ifdef CONFIG_PM
bb573928 4389static void codec_set_power_save(struct hda_codec *codec, int delay)
cb53c626 4390{
cc72da7d 4391 struct device *dev = hda_codec_dev(codec);
cc72da7d 4392
cc72da7d
TI		 4393 if (delay > 0) {
4394 pm_runtime_set_autosuspend_delay(dev, delay);
4395 pm_runtime_use_autosuspend(dev);
4396 pm_runtime_allow(dev);
4397 if (!pm_runtime_suspended(dev))
4398 pm_runtime_mark_last_busy(dev);
4399 } else {
4400 pm_runtime_dont_use_autosuspend(dev);
4401 pm_runtime_forbid(dev);
4402 }
cb53c626 4403}
bb573928
TI		 4404
4405/**
4406 * snd_hda_set_power_save - reprogram autosuspend for the given delay
4407 * @bus: HD-audio bus
4408 * @delay: autosuspend delay in msec, 0 = off
4409 *
4410 * Synchronize the runtime PM autosuspend state from the power_save option.
4411 */
4412void snd_hda_set_power_save(struct hda_bus *bus, int delay)
4413{
4414 struct hda_codec *c;
4415
d068ebc2 4416 list_for_each_codec(c, bus)
bb573928
TI		 4417 codec_set_power_save(c, delay);
4418}
4419EXPORT_SYMBOL_GPL(snd_hda_set_power_save);
cb53c626 4420
d5191e50
TI		 4421/**
4422 * snd_hda_check_amp_list_power - Check the amp list and update the power
4423 * @codec: HD-audio codec
4424 * @check: the object containing an AMP list and the status
4425 * @nid: NID to check / update
4426 *
4427 * Check whether the given NID is in the amp list. If it's in the list,
4428 * check the current AMP status, and update the the power-status according
4429 * to the mute status.
4430 *
4431 * This function is supposed to be set or called from the check_power_status
4432 * patch ops.
28aedaf7 4433 */
cb53c626
TI		 4434int snd_hda_check_amp_list_power(struct hda_codec *codec,
4435 struct hda_loopback_check *check,
4436 hda_nid_t nid)
4437{
031024ee 4438 const struct hda_amp_list *p;
cb53c626
TI		 4439 int ch, v;
4440
4441 if (!check->amplist)
4442 return 0;
4443 for (p = check->amplist; p->nid; p++) {
4444 if (p->nid == nid)
4445 break;
4446 }
4447 if (!p->nid)
4448 return 0; /* nothing changed */
4449
4450 for (p = check->amplist; p->nid; p++) {
4451 for (ch = 0; ch < 2; ch++) {
4452 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4453 p->idx);
4454 if (!(v & HDA_AMP_MUTE) && v > 0) {
4455 if (!check->power_on) {
4456 check->power_on = 1;
4457 snd_hda_power_up(codec);
4458 }
4459 return 1;
4460 }
4461 }
4462 }
4463 if (check->power_on) {
4464 check->power_on = 0;
4465 snd_hda_power_down(codec);
4466 }
4467 return 0;
4468}
2698ea98 4469EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
cb53c626 4470#endif
1da177e4
LT		 4471
4472/*
4473 * input MUX helper
4474 */
d5191e50
TI		 4475
4476/**
4477 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
a11e9b16
TI		 4478 * @imux: imux helper object
4479 * @uinfo: pointer to get/store the data
d5191e50 4480 */
0ba21762
TI		 4481int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4482 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 4483{
4484 unsigned int index;
4485
4486 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4487 uinfo->count = 1;
4488 uinfo->value.enumerated.items = imux->num_items;
5513b0c5
TI		 4489 if (!imux->num_items)
4490 return 0;
1da177e4
LT		 4491 index = uinfo->value.enumerated.item;
4492 if (index >= imux->num_items)
4493 index = imux->num_items - 1;
4494 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4495 return 0;
4496}
2698ea98 4497EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
1da177e4 4498
d5191e50
TI		 4499/**
4500 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
a11e9b16
TI		 4501 * @codec: the HDA codec
4502 * @imux: imux helper object
4503 * @ucontrol: pointer to get/store the data
4504 * @nid: input mux NID
4505 * @cur_val: pointer to get/store the current imux value
d5191e50 4506 */
0ba21762
TI		 4507int snd_hda_input_mux_put(struct hda_codec *codec,
4508 const struct hda_input_mux *imux,
4509 struct snd_ctl_elem_value *ucontrol,
4510 hda_nid_t nid,
1da177e4
LT		 4511 unsigned int *cur_val)
4512{
4513 unsigned int idx;
4514
5513b0c5
TI		 4515 if (!imux->num_items)
4516 return 0;
1da177e4
LT		 4517 idx = ucontrol->value.enumerated.item[0];
4518 if (idx >= imux->num_items)
4519 idx = imux->num_items - 1;
82beb8fd 4520 if (*cur_val == idx)
1da177e4 4521 return 0;
82beb8fd
TI		 4522 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4523 imux->items[idx].index);
1da177e4
LT		 4524 *cur_val = idx;
4525 return 1;
4526}
2698ea98 4527EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
1da177e4
LT		 4528
4529
a11e9b16
TI		 4530/**
4531 * snd_hda_enum_helper_info - Helper for simple enum ctls
4532 * @kcontrol: ctl element
4533 * @uinfo: pointer to get/store the data
4534 * @num_items: number of enum items
4535 * @texts: enum item string array
4536 *
dda415d4
TI		 4537 * process kcontrol info callback of a simple string enum array
4538 * when @num_items is 0 or @texts is NULL, assume a boolean enum array
4539 */
4540int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
4541 struct snd_ctl_elem_info *uinfo,
4542 int num_items, const char * const *texts)
4543{
4544 static const char * const texts_default[] = {
4545 "Disabled", "Enabled"
4546 };
4547
4548 if (!texts || !num_items) {
4549 num_items = 2;
4550 texts = texts_default;
4551 }
4552
3ff72219 4553 return snd_ctl_enum_info(uinfo, 1, num_items, texts);
dda415d4 4554}
2698ea98 4555EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info);
dda415d4 4556
1da177e4
LT		 4557/*
4558 * Multi-channel / digital-out PCM helper functions
4559 */
4560
6b97eb45
TI		 4561/* setup SPDIF output stream */
4562static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4563 unsigned int stream_tag, unsigned int format)
4564{
3bef1c37
LD		 4565 struct hda_spdif_out *spdif;
4566 unsigned int curr_fmt;
4567 bool reset;
4568
4569 spdif = snd_hda_spdif_out_of_nid(codec, nid);
4570 curr_fmt = snd_hda_codec_read(codec, nid, 0,
4571 AC_VERB_GET_STREAM_FORMAT, 0);
4572 reset = codec->spdif_status_reset &&
4573 (spdif->ctls & AC_DIG1_ENABLE) &&
4574 curr_fmt != format;
4575
4576 /* turn off SPDIF if needed; otherwise the IEC958 bits won't be
4577 updated */
4578 if (reset)
28aedaf7 4579 set_dig_out_convert(codec, nid,
7c935976 4580 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
2f72853c 4581 -1);
6b97eb45 4582 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2f72853c 4583 if (codec->slave_dig_outs) {
dda14410 4584 const hda_nid_t *d;
2f72853c
TI		 4585 for (d = codec->slave_dig_outs; *d; d++)
4586 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4587 format);
4588 }
6b97eb45 4589 /* turn on again (if needed) */
3bef1c37 4590 if (reset)
2f72853c 4591 set_dig_out_convert(codec, nid,
7c935976 4592 spdif->ctls & 0xff, -1);
2f72853c 4593}
de51ca12 4594
2f72853c
TI		 4595static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4596{
4597 snd_hda_codec_cleanup_stream(codec, nid);
4598 if (codec->slave_dig_outs) {
dda14410 4599 const hda_nid_t *d;
2f72853c
TI		 4600 for (d = codec->slave_dig_outs; *d; d++)
4601 snd_hda_codec_cleanup_stream(codec, *d);
de51ca12 4602 }
6b97eb45
TI		 4603}
4604
d5191e50
TI		 4605/**
4606 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
a11e9b16
TI		 4607 * @codec: the HDA codec
4608 * @mout: hda_multi_out object
1da177e4 4609 */
0ba21762
TI		 4610int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4611 struct hda_multi_out *mout)
1da177e4 4612{
62932df8 4613 mutex_lock(&codec->spdif_mutex);
5930ca41
TI		 4614 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4615 /* already opened as analog dup; reset it once */
2f72853c 4616 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4 4617 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
62932df8 4618 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4619 return 0;
4620}
2698ea98 4621EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
1da177e4 4622
d5191e50
TI		 4623/**
4624 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
a11e9b16
TI		 4625 * @codec: the HDA codec
4626 * @mout: hda_multi_out object
4627 * @stream_tag: stream tag to assign
4628 * @format: format id to assign
4629 * @substream: PCM substream to assign
d5191e50 4630 */
6b97eb45
TI		 4631int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4632 struct hda_multi_out *mout,
4633 unsigned int stream_tag,
4634 unsigned int format,
4635 struct snd_pcm_substream *substream)
4636{
4637 mutex_lock(&codec->spdif_mutex);
4638 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4639 mutex_unlock(&codec->spdif_mutex);
4640 return 0;
4641}
2698ea98 4642EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
6b97eb45 4643
d5191e50
TI		 4644/**
4645 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
a11e9b16
TI		 4646 * @codec: the HDA codec
4647 * @mout: hda_multi_out object
d5191e50 4648 */
9411e21c
TI		 4649int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4650 struct hda_multi_out *mout)
4651{
4652 mutex_lock(&codec->spdif_mutex);
4653 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4654 mutex_unlock(&codec->spdif_mutex);
4655 return 0;
4656}
2698ea98 4657EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
9411e21c 4658
d5191e50
TI		 4659/**
4660 * snd_hda_multi_out_dig_close - release the digital out stream
a11e9b16
TI		 4661 * @codec: the HDA codec
4662 * @mout: hda_multi_out object
1da177e4 4663 */
0ba21762
TI		 4664int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4665 struct hda_multi_out *mout)
1da177e4 4666{
62932df8 4667 mutex_lock(&codec->spdif_mutex);
1da177e4 4668 mout->dig_out_used = 0;
62932df8 4669 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4670 return 0;
4671}
2698ea98 4672EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
1da177e4 4673
d5191e50
TI		 4674/**
4675 * snd_hda_multi_out_analog_open - open analog outputs
a11e9b16
TI		 4676 * @codec: the HDA codec
4677 * @mout: hda_multi_out object
4678 * @substream: PCM substream to assign
4679 * @hinfo: PCM information to assign
d5191e50
TI		 4680 *
4681 * Open analog outputs and set up the hw-constraints.
4682 * If the digital outputs can be opened as slave, open the digital
4683 * outputs, too.
1da177e4 4684 */
0ba21762
TI		 4685int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4686 struct hda_multi_out *mout,
9a08160b
TI		 4687 struct snd_pcm_substream *substream,
4688 struct hda_pcm_stream *hinfo)
4689{
4690 struct snd_pcm_runtime *runtime = substream->runtime;
4691 runtime->hw.channels_max = mout->max_channels;
4692 if (mout->dig_out_nid) {
4693 if (!mout->analog_rates) {
4694 mout->analog_rates = hinfo->rates;
4695 mout->analog_formats = hinfo->formats;
4696 mout->analog_maxbps = hinfo->maxbps;
4697 } else {
4698 runtime->hw.rates = mout->analog_rates;
4699 runtime->hw.formats = mout->analog_formats;
4700 hinfo->maxbps = mout->analog_maxbps;
4701 }
4702 if (!mout->spdif_rates) {
4703 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4704 &mout->spdif_rates,
4705 &mout->spdif_formats,
4706 &mout->spdif_maxbps);
4707 }
4708 mutex_lock(&codec->spdif_mutex);
4709 if (mout->share_spdif) {
022b466f
TI		 4710 if ((runtime->hw.rates & mout->spdif_rates) &&
4711 (runtime->hw.formats & mout->spdif_formats)) {
4712 runtime->hw.rates &= mout->spdif_rates;
4713 runtime->hw.formats &= mout->spdif_formats;
4714 if (mout->spdif_maxbps < hinfo->maxbps)
4715 hinfo->maxbps = mout->spdif_maxbps;
4716 } else {
4717 mout->share_spdif = 0;
4718 /* FIXME: need notify? */
4719 }
9a08160b 4720 }
eaa9985b 4721 mutex_unlock(&codec->spdif_mutex);
9a08160b 4722 }
1da177e4
LT		 4723 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4724 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4725}
2698ea98 4726EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
1da177e4 4727
d5191e50
TI		 4728/**
4729 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
a11e9b16
TI		 4730 * @codec: the HDA codec
4731 * @mout: hda_multi_out object
4732 * @stream_tag: stream tag to assign
4733 * @format: format id to assign
4734 * @substream: PCM substream to assign
d5191e50
TI		 4735 *
4736 * Set up the i/o for analog out.
4737 * When the digital out is available, copy the front out to digital out, too.
1da177e4 4738 */
0ba21762
TI		 4739int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4740 struct hda_multi_out *mout,
1da177e4
LT		 4741 unsigned int stream_tag,
4742 unsigned int format,
c8b6bf9b 4743 struct snd_pcm_substream *substream)
1da177e4 4744{
dda14410 4745 const hda_nid_t *nids = mout->dac_nids;
1da177e4 4746 int chs = substream->runtime->channels;
e3245cdd 4747 struct hda_spdif_out *spdif;
1da177e4
LT		 4748 int i;
4749
62932df8 4750 mutex_lock(&codec->spdif_mutex);
e3245cdd 4751 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
9a08160b
TI		 4752 if (mout->dig_out_nid && mout->share_spdif &&
4753 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
1da177e4 4754 if (chs == 2 &&
0ba21762
TI		 4755 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4756 format) &&
7c935976 4757 !(spdif->status & IEC958_AES0_NONAUDIO)) {
1da177e4 4758 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
6b97eb45
TI		 4759 setup_dig_out_stream(codec, mout->dig_out_nid,
4760 stream_tag, format);
1da177e4
LT		 4761 } else {
4762 mout->dig_out_used = 0;
2f72853c 4763 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 4764 }
4765 }
62932df8 4766 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4767
4768 /* front */
0ba21762
TI		 4769 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4770 0, format);
d29240ce
TI		 4771 if (!mout->no_share_stream &&
4772 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
1da177e4 4773 /* headphone out will just decode front left/right (stereo) */
0ba21762
TI		 4774 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4775 0, format);
82bc955f 4776 /* extra outputs copied from front */
a06dbfc2
TI		 4777 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4778 if (!mout->no_share_stream && mout->hp_out_nid[i])
4779 snd_hda_codec_setup_stream(codec,
4780 mout->hp_out_nid[i],
4781 stream_tag, 0, format);
82bc955f 4782
1da177e4
LT		 4783 /* surrounds */
4784 for (i = 1; i < mout->num_dacs; i++) {
4b3acaf5 4785 if (chs >= (i + 1) * 2) /* independent out */
0ba21762
TI		 4786 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4787 i * 2, format);
d29240ce 4788 else if (!mout->no_share_stream) /* copy front */
0ba21762
TI		 4789 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4790 0, format);
1da177e4 4791 }
cd4035e8
DH		 4792
4793 /* extra surrounds */
4794 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) {
4795 int ch = 0;
4796 if (!mout->extra_out_nid[i])
4797 break;
4798 if (chs >= (i + 1) * 2)
4799 ch = i * 2;
4800 else if (!mout->no_share_stream)
4801 break;
4802 snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i],
4803 stream_tag, ch, format);
4804 }
4805
1da177e4
LT		 4806 return 0;
4807}
2698ea98 4808EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
1da177e4 4809
d5191e50
TI		 4810/**
4811 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
a11e9b16
TI		 4812 * @codec: the HDA codec
4813 * @mout: hda_multi_out object
1da177e4 4814 */
0ba21762
TI		 4815int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4816 struct hda_multi_out *mout)
1da177e4 4817{
dda14410 4818 const hda_nid_t *nids = mout->dac_nids;
1da177e4
LT		 4819 int i;
4820
4821 for (i = 0; i < mout->num_dacs; i++)
888afa15 4822 snd_hda_codec_cleanup_stream(codec, nids[i]);
1da177e4 4823 if (mout->hp_nid)
888afa15 4824 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
a06dbfc2
TI		 4825 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4826 if (mout->hp_out_nid[i])
4827 snd_hda_codec_cleanup_stream(codec,
4828 mout->hp_out_nid[i]);
82bc955f
TI		 4829 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4830 if (mout->extra_out_nid[i])
888afa15
TI		 4831 snd_hda_codec_cleanup_stream(codec,
4832 mout->extra_out_nid[i]);
62932df8 4833 mutex_lock(&codec->spdif_mutex);
1da177e4 4834 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
2f72853c 4835 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 4836 mout->dig_out_used = 0;
4837 }
62932df8 4838 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4839 return 0;
4840}
2698ea98 4841EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
1da177e4 4842
4740860b
TI		 4843/**
4844 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
a11e9b16
TI		 4845 * @codec: the HDA codec
4846 * @pin: referred pin NID
4740860b
TI		 4847 *
4848 * Guess the suitable VREF pin bits to be set as the pin-control value.
4849 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
4850 */
4851unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
4852{
4853 unsigned int pincap;
4854 unsigned int oldval;
4855 oldval = snd_hda_codec_read(codec, pin, 0,
4856 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4857 pincap = snd_hda_query_pin_caps(codec, pin);
4858 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
4859 /* Exception: if the default pin setup is vref50, we give it priority */
4860 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
4861 return AC_PINCTL_VREF_80;
4862 else if (pincap & AC_PINCAP_VREF_50)
4863 return AC_PINCTL_VREF_50;
4864 else if (pincap & AC_PINCAP_VREF_100)
4865 return AC_PINCTL_VREF_100;
4866 else if (pincap & AC_PINCAP_VREF_GRD)
4867 return AC_PINCTL_VREF_GRD;
4868 return AC_PINCTL_VREF_HIZ;
4869}
2698ea98 4870EXPORT_SYMBOL_GPL(snd_hda_get_default_vref);
4740860b 4871
a11e9b16
TI		 4872/**
4873 * snd_hda_correct_pin_ctl - correct the pin ctl value for matching with the pin cap
4874 * @codec: the HDA codec
4875 * @pin: referred pin NID
4876 * @val: pin ctl value to audit
4877 */
62f3a2f7
TI		 4878unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
4879 hda_nid_t pin, unsigned int val)
4880{
4881 static unsigned int cap_lists[][2] = {
4882 { AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
4883 { AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
4884 { AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
4885 { AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
4886 };
4887 unsigned int cap;
4888
4889 if (!val)
4890 return 0;
4891 cap = snd_hda_query_pin_caps(codec, pin);
4892 if (!cap)
4893 return val; /* don't know what to do... */
4894
4895 if (val & AC_PINCTL_OUT_EN) {
4896 if (!(cap & AC_PINCAP_OUT))
4897 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
4898 else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
4899 val &= ~AC_PINCTL_HP_EN;
4900 }
4901
4902 if (val & AC_PINCTL_IN_EN) {
4903 if (!(cap & AC_PINCAP_IN))
4904 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
4905 else {
4906 unsigned int vcap, vref;
4907 int i;
4908 vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
4909 vref = val & AC_PINCTL_VREFEN;
4910 for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
4911 if (vref == cap_lists[i][0] &&
4912 !(vcap & cap_lists[i][1])) {
4913 if (i == ARRAY_SIZE(cap_lists) - 1)
4914 vref = AC_PINCTL_VREF_HIZ;
4915 else
4916 vref = cap_lists[i + 1][0];
4917 }
4918 }
4919 val &= ~AC_PINCTL_VREFEN;
4920 val |= vref;
4921 }
4922 }
4923
4924 return val;
4925}
2698ea98 4926EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl);
62f3a2f7 4927
a11e9b16
TI		 4928/**
4929 * _snd_hda_pin_ctl - Helper to set pin ctl value
4930 * @codec: the HDA codec
4931 * @pin: referred pin NID
4932 * @val: pin control value to set
4933 * @cached: access over codec pinctl cache or direct write
4934 *
4935 * This function is a helper to set a pin ctl value more safely.
4936 * It corrects the pin ctl value via snd_hda_correct_pin_ctl(), stores the
4937 * value in pin target array via snd_hda_codec_set_pin_target(), then
4938 * actually writes the value via either snd_hda_codec_update_cache() or
4939 * snd_hda_codec_write() depending on @cached flag.
4940 */
cdd03ced
TI		 4941int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
4942 unsigned int val, bool cached)
4943{
62f3a2f7 4944 val = snd_hda_correct_pin_ctl(codec, pin, val);
d7fdc00a 4945 snd_hda_codec_set_pin_target(codec, pin, val);
cdd03ced
TI		 4946 if (cached)
4947 return snd_hda_codec_update_cache(codec, pin, 0,
4948 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4949 else
4950 return snd_hda_codec_write(codec, pin, 0,
4951 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4952}
2698ea98 4953EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl);
cdd03ced 4954
990061c2
TI		 4955/**
4956 * snd_hda_add_imux_item - Add an item to input_mux
a11e9b16
TI		 4957 * @codec: the HDA codec
4958 * @imux: imux helper object
4959 * @label: the name of imux item to assign
4960 * @index: index number of imux item to assign
4961 * @type_idx: pointer to store the resultant label index
990061c2
TI		 4962 *
4963 * When the same label is used already in the existing items, the number
4964 * suffix is appended to the label. This label index number is stored
4965 * to type_idx when non-NULL pointer is given.
4966 */
6194b99d
TI		 4967int snd_hda_add_imux_item(struct hda_codec *codec,
4968 struct hda_input_mux *imux, const char *label,
10a20af7
TI		 4969 int index, int *type_idx)
4970{
4971 int i, label_idx = 0;
4972 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
6194b99d 4973 codec_err(codec, "hda_codec: Too many imux items!\n");
10a20af7
TI		 4974 return -EINVAL;
4975 }
4976 for (i = 0; i < imux->num_items; i++) {
4977 if (!strncmp(label, imux->items[i].label, strlen(label)))
4978 label_idx++;
d7b1ae9d 4979 }
10a20af7
TI		 4980 if (type_idx)
4981 *type_idx = label_idx;
4982 if (label_idx > 0)
4983 snprintf(imux->items[imux->num_items].label,
4984 sizeof(imux->items[imux->num_items].label),
4985 "%s %d", label, label_idx);
b5786e85 4986 else
10a20af7
TI		 4987 strlcpy(imux->items[imux->num_items].label, label,
4988 sizeof(imux->items[imux->num_items].label));
4989 imux->items[imux->num_items].index = index;
4990 imux->num_items++;
4991 return 0;
d7b1ae9d 4992}
2698ea98 4993EXPORT_SYMBOL_GPL(snd_hda_add_imux_item);
d7b1ae9d 4994
1da177e4 4995/**
59ed1ead
TI		 4996 * snd_hda_bus_reset - Reset the bus
4997 * @bus: HD-audio bus
1da177e4 4998 */
59ed1ead 4999void snd_hda_bus_reset(struct hda_bus *bus)
1da177e4 5000{
0ba21762 5001 struct hda_codec *codec;
1da177e4 5002
d068ebc2 5003 list_for_each_codec(codec, bus) {
59ed1ead 5004 /* FIXME: maybe a better way needed for forced reset */
26a6cb6c 5005 cancel_delayed_work_sync(&codec->jackpoll_work);
59ed1ead 5006#ifdef CONFIG_PM
0e24dbb7 5007 if (hda_codec_is_power_on(codec)) {
cc72da7d 5008 hda_call_codec_suspend(codec);
12edb893 5009 hda_call_codec_resume(codec);
59ed1ead
TI		 5010 }
5011#endif
1da177e4 5012 }
1da177e4 5013}
59ed1ead 5014EXPORT_SYMBOL_GPL(snd_hda_bus_reset);
b2e18597 5015
d5191e50
TI		 5016/**
5017 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5018 * @pcm: PCM caps bits
5019 * @buf: the string buffer to write
5020 * @buflen: the max buffer length
5021 *
5022 * used by hda_proc.c and hda_eld.c
5023 */
b2022266
TI		 5024void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5025{
5026 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5027 int i, j;
5028
5029 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5030 if (pcm & (AC_SUPPCM_BITS_8 << i))
5031 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5032
5033 buf[j] = '\0'; /* necessary when j == 0 */
5034}
2698ea98 5035EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
1289e9e8
TI		 5036
5037MODULE_DESCRIPTION("HDA codec core");
5038MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)