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