projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: usb - Don't trust the channel config if the channel count changed
[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>
26#include <linux/pci.h>
62932df8 27#include <linux/mutex.h>
da155d5b 28#include <linux/module.h>
1da177e4
LT		 29#include <sound/core.h>
30#include "hda_codec.h"
31#include <sound/asoundef.h>
302e9c5a 32#include <sound/tlv.h>
1da177e4 33#include <sound/initval.h>
cd372fb3 34#include <sound/jack.h>
1da177e4 35#include "hda_local.h"
123c07ae 36#include "hda_beep.h"
1835a0f9 37#include "hda_jack.h"
2807314d 38#include <sound/hda_hwdep.h>
1da177e4 39
d66fee5d
TI		 40#define CREATE_TRACE_POINTS
41#include "hda_trace.h"
42
1da177e4
LT		 43/*
44 * vendor / preset table
45 */
46
47struct hda_vendor_id {
48 unsigned int id;
49 const char *name;
50};
51
52/* codec vendor labels */
53static struct hda_vendor_id hda_vendor_ids[] = {
c8cd1281 54 { 0x1002, "ATI" },
e5f14248 55 { 0x1013, "Cirrus Logic" },
a9226251 56 { 0x1057, "Motorola" },
c8cd1281 57 { 0x1095, "Silicon Image" },
31117b78 58 { 0x10de, "Nvidia" },
c8cd1281 59 { 0x10ec, "Realtek" },
4e01f54b 60 { 0x1102, "Creative" },
c577b8a1 61 { 0x1106, "VIA" },
7f16859a 62 { 0x111d, "IDT" },
c8cd1281 63 { 0x11c1, "LSI" },
54b903ec 64 { 0x11d4, "Analog Devices" },
1da177e4 65 { 0x13f6, "C-Media" },
a9226251 66 { 0x14f1, "Conexant" },
c8cd1281
TI		 67 { 0x17e8, "Chrontel" },
68 { 0x1854, "LG" },
8199de3b 69 { 0x1aec, "Wolfson Microelectronics" },
1da177e4 70 { 0x434d, "C-Media" },
74c61133 71 { 0x8086, "Intel" },
2f2f4251 72 { 0x8384, "SigmaTel" },
1da177e4
LT		 73 {} /* terminator */
74};
75
1289e9e8
TI		 76static DEFINE_MUTEX(preset_mutex);
77static LIST_HEAD(hda_preset_tables);
78
79int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
80{
81 mutex_lock(&preset_mutex);
82 list_add_tail(&preset->list, &hda_preset_tables);
83 mutex_unlock(&preset_mutex);
84 return 0;
85}
ff7a3267 86EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
1289e9e8
TI		 87
88int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
89{
90 mutex_lock(&preset_mutex);
91 list_del(&preset->list);
92 mutex_unlock(&preset_mutex);
93 return 0;
94}
ff7a3267 95EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
1da177e4 96
83012a7c 97#ifdef CONFIG_PM
d846b174 98#define codec_in_pm(codec) ((codec)->in_pm)
cb53c626
TI		 99static void hda_power_work(struct work_struct *work);
100static void hda_keep_power_on(struct hda_codec *codec);
e581f3db 101#define hda_codec_is_power_on(codec) ((codec)->power_on)
68467f51
TI		 102static inline void hda_call_pm_notify(struct hda_bus *bus, bool power_up)
103{
104 if (bus->ops.pm_notify)
105 bus->ops.pm_notify(bus, power_up);
106}
cb53c626 107#else
d846b174 108#define codec_in_pm(codec) 0
cb53c626 109static inline void hda_keep_power_on(struct hda_codec *codec) {}
e581f3db 110#define hda_codec_is_power_on(codec) 1
68467f51 111#define hda_call_pm_notify(bus, state) {}
cb53c626
TI		 112#endif
113
d5191e50
TI		 114/**
115 * snd_hda_get_jack_location - Give a location string of the jack
116 * @cfg: pin default config value
117 *
118 * Parse the pin default config value and returns the string of the
119 * jack location, e.g. "Rear", "Front", etc.
120 */
50a9f790
MR		 121const char *snd_hda_get_jack_location(u32 cfg)
122{
123 static char *bases[7] = {
124 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
125 };
126 static unsigned char specials_idx[] = {
127 0x07, 0x08,
128 0x17, 0x18, 0x19,
129 0x37, 0x38
130 };
131 static char *specials[] = {
132 "Rear Panel", "Drive Bar",
133 "Riser", "HDMI", "ATAPI",
134 "Mobile-In", "Mobile-Out"
135 };
136 int i;
137 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
138 if ((cfg & 0x0f) < 7)
139 return bases[cfg & 0x0f];
140 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
141 if (cfg == specials_idx[i])
142 return specials[i];
143 }
144 return "UNKNOWN";
145}
ff7a3267 146EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
50a9f790 147
d5191e50
TI		 148/**
149 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
150 * @cfg: pin default config value
151 *
152 * Parse the pin default config value and returns the string of the
153 * jack connectivity, i.e. external or internal connection.
154 */
50a9f790
MR		 155const char *snd_hda_get_jack_connectivity(u32 cfg)
156{
157 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
158
159 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
160}
ff7a3267 161EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
50a9f790 162
d5191e50
TI		 163/**
164 * snd_hda_get_jack_type - Give a type string of the jack
165 * @cfg: pin default config value
166 *
167 * Parse the pin default config value and returns the string of the
168 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
169 */
50a9f790
MR		 170const char *snd_hda_get_jack_type(u32 cfg)
171{
172 static char *jack_types[16] = {
173 "Line Out", "Speaker", "HP Out", "CD",
174 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
175 "Line In", "Aux", "Mic", "Telephony",
aeb3a972 176 "SPDIF In", "Digital In", "Reserved", "Other"
50a9f790
MR		 177 };
178
179 return jack_types[(cfg & AC_DEFCFG_DEVICE)
180 >> AC_DEFCFG_DEVICE_SHIFT];
181}
ff7a3267 182EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
50a9f790 183
33fa35ed
TI		 184/*
185 * Compose a 32bit command word to be sent to the HD-audio controller
186 */
187static inline unsigned int
e7ecc27e 188make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int flags,
33fa35ed
TI		 189 unsigned int verb, unsigned int parm)
190{
191 u32 val;
192
e7ecc27e 193 if ((codec->addr & ~0xf) || (nid & ~0x7f) ||
82e1b804 194 (verb & ~0xfff) || (parm & ~0xffff)) {
e7ecc27e
TI		 195 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x\n",
196 codec->addr, nid, verb, parm);
6430aeeb
WF		 197 return ~0;
198 }
199
200 val = (u32)codec->addr << 28;
33fa35ed
TI		 201 val |= (u32)nid << 20;
202 val |= verb << 8;
203 val |= parm;
204 return val;
205}
206
aa2936f5
TI		 207/*
208 * Send and receive a verb
209 */
210static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
e7ecc27e 211 int flags, unsigned int *res)
aa2936f5
TI		 212{
213 struct hda_bus *bus = codec->bus;
8dd78330 214 int err;
aa2936f5 215
6430aeeb
WF		 216 if (cmd == ~0)
217 return -1;
218
aa2936f5
TI		 219 if (res)
220 *res = -1;
8dd78330 221 again:
aa2936f5
TI		 222 snd_hda_power_up(codec);
223 mutex_lock(&bus->cmd_mutex);
63e51fd7
TI		 224 if (flags & HDA_RW_NO_RESPONSE_FALLBACK)
225 bus->no_response_fallback = 1;
3bcce5c0
TI		 226 for (;;) {
227 trace_hda_send_cmd(codec, cmd);
228 err = bus->ops.command(bus, cmd);
229 if (err != -EAGAIN)
230 break;
231 /* process pending verbs */
232 bus->ops.get_response(bus, codec->addr);
233 }
d66fee5d 234 if (!err && res) {
deadff16 235 *res = bus->ops.get_response(bus, codec->addr);
d66fee5d
TI		 236 trace_hda_get_response(codec, *res);
237 }
63e51fd7 238 bus->no_response_fallback = 0;
aa2936f5
TI		 239 mutex_unlock(&bus->cmd_mutex);
240 snd_hda_power_down(codec);
d846b174 241 if (!codec_in_pm(codec) && res && *res == -1 && bus->rirb_error) {
8dd78330
TI		 242 if (bus->response_reset) {
243 snd_printd("hda_codec: resetting BUS due to "
244 "fatal communication error\n");
d66fee5d 245 trace_hda_bus_reset(bus);
8dd78330
TI		 246 bus->ops.bus_reset(bus);
247 }
248 goto again;
249 }
250 /* clear reset-flag when the communication gets recovered */
d846b174 251 if (!err || codec_in_pm(codec))
8dd78330 252 bus->response_reset = 0;
aa2936f5
TI		 253 return err;
254}
255
1da177e4
LT		 256/**
257 * snd_hda_codec_read - send a command and get the response
258 * @codec: the HDA codec
259 * @nid: NID to send the command
e7ecc27e 260 * @flags: optional bit flags
1da177e4
LT		 261 * @verb: the verb to send
262 * @parm: the parameter for the verb
263 *
264 * Send a single command and read the corresponding response.
265 *
266 * Returns the obtained response value, or -1 for an error.
267 */
0ba21762 268unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
e7ecc27e 269 int flags,
1da177e4
LT		 270 unsigned int verb, unsigned int parm)
271{
e7ecc27e 272 unsigned cmd = make_codec_cmd(codec, nid, flags, verb, parm);
aa2936f5 273 unsigned int res;
e7ecc27e 274 if (codec_exec_verb(codec, cmd, flags, &res))
9857edfd 275 return -1;
1da177e4
LT		 276 return res;
277}
ff7a3267 278EXPORT_SYMBOL_HDA(snd_hda_codec_read);
1da177e4
LT		 279
280/**
281 * snd_hda_codec_write - send a single command without waiting for response
282 * @codec: the HDA codec
283 * @nid: NID to send the command
e7ecc27e 284 * @flags: optional bit flags
1da177e4
LT		 285 * @verb: the verb to send
286 * @parm: the parameter for the verb
287 *
288 * Send a single command without waiting for response.
289 *
290 * Returns 0 if successful, or a negative error code.
291 */
e7ecc27e
TI		 292int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags,
293 unsigned int verb, unsigned int parm)
1da177e4 294{
e7ecc27e 295 unsigned int cmd = make_codec_cmd(codec, nid, flags, verb, parm);
33fa35ed 296 unsigned int res;
e7ecc27e 297 return codec_exec_verb(codec, cmd, flags,
b20f3b83 298 codec->bus->sync_write ? &res : NULL);
1da177e4 299}
ff7a3267 300EXPORT_SYMBOL_HDA(snd_hda_codec_write);
1da177e4
LT		 301
302/**
303 * snd_hda_sequence_write - sequence writes
304 * @codec: the HDA codec
305 * @seq: VERB array to send
306 *
307 * Send the commands sequentially from the given array.
308 * The array must be terminated with NID=0.
309 */
310void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
311{
312 for (; seq->nid; seq++)
313 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
314}
ff7a3267 315EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
1da177e4
LT		 316
317/**
318 * snd_hda_get_sub_nodes - get the range of sub nodes
319 * @codec: the HDA codec
320 * @nid: NID to parse
321 * @start_id: the pointer to store the start NID
322 *
323 * Parse the NID and store the start NID of its sub-nodes.
324 * Returns the number of sub-nodes.
325 */
0ba21762
TI		 326int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
327 hda_nid_t *start_id)
1da177e4
LT		 328{
329 unsigned int parm;
330
331 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
e8a7f136
DT		 332 if (parm == -1)
333 return 0;
1da177e4
LT		 334 *start_id = (parm >> 16) & 0x7fff;
335 return (int)(parm & 0x7fff);
336}
ff7a3267 337EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
1da177e4 338
ee8e765b
TI		 339/* connection list element */
340struct hda_conn_list {
341 struct list_head list;
342 int len;
343 hda_nid_t nid;
344 hda_nid_t conns[0];
345};
346
b2f934a0 347/* look up the cached results */
ee8e765b
TI		 348static struct hda_conn_list *
349lookup_conn_list(struct hda_codec *codec, hda_nid_t nid)
b2f934a0 350{
ee8e765b
TI		 351 struct hda_conn_list *p;
352 list_for_each_entry(p, &codec->conn_list, list) {
353 if (p->nid == nid)
b2f934a0 354 return p;
b2f934a0
TI		 355 }
356 return NULL;
357}
a12d3e1e 358
ee8e765b
TI		 359static int add_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
360 const hda_nid_t *list)
361{
362 struct hda_conn_list *p;
363
364 p = kmalloc(sizeof(*p) + len * sizeof(hda_nid_t), GFP_KERNEL);
365 if (!p)
366 return -ENOMEM;
367 p->len = len;
368 p->nid = nid;
369 memcpy(p->conns, list, len * sizeof(hda_nid_t));
370 list_add(&p->list, &codec->conn_list);
371 return 0;
372}
373
374static void remove_conn_list(struct hda_codec *codec)
375{
376 while (!list_empty(&codec->conn_list)) {
377 struct hda_conn_list *p;
378 p = list_first_entry(&codec->conn_list, typeof(*p), list);
379 list_del(&p->list);
380 kfree(p);
381 }
382}
383
09cf03b8
TI		 384/* read the connection and add to the cache */
385static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
386{
4eea3091
TI		 387 hda_nid_t list[32];
388 hda_nid_t *result = list;
09cf03b8
TI		 389 int len;
390
391 len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
4eea3091
TI		 392 if (len == -ENOSPC) {
393 len = snd_hda_get_num_raw_conns(codec, nid);
394 result = kmalloc(sizeof(hda_nid_t) * len, GFP_KERNEL);
395 if (!result)
396 return -ENOMEM;
397 len = snd_hda_get_raw_connections(codec, nid, result, len);
398 }
399 if (len >= 0)
400 len = snd_hda_override_conn_list(codec, nid, len, result);
401 if (result != list)
402 kfree(result);
403 return len;
09cf03b8
TI		 404}
405
ee8e765b
TI		 406/**
407 * snd_hda_get_conn_list - get connection list
408 * @codec: the HDA codec
409 * @nid: NID to parse
410 * @len: number of connection list entries
411 * @listp: the pointer to store NID list
412 *
413 * Parses the connection list of the given widget and stores the pointer
414 * to the list of NIDs.
415 *
416 * Returns the number of connections, or a negative error code.
417 *
418 * Note that the returned pointer isn't protected against the list
419 * modification. If snd_hda_override_conn_list() might be called
420 * concurrently, protect with a mutex appropriately.
421 */
422int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
423 const hda_nid_t **listp)
424{
425 bool added = false;
426
427 for (;;) {
428 int err;
429 const struct hda_conn_list *p;
430
431 /* if the connection-list is already cached, read it */
432 p = lookup_conn_list(codec, nid);
433 if (p) {
434 if (listp)
435 *listp = p->conns;
436 return p->len;
437 }
438 if (snd_BUG_ON(added))
439 return -EINVAL;
440
441 err = read_and_add_raw_conns(codec, nid);
442 if (err < 0)
443 return err;
444 added = true;
445 }
446}
447EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
448
1da177e4 449/**
09cf03b8 450 * snd_hda_get_connections - copy connection list
1da177e4
LT		 451 * @codec: the HDA codec
452 * @nid: NID to parse
09cf03b8
TI		 453 * @conn_list: connection list array; when NULL, checks only the size
454 * @max_conns: max. number of connections to store
1da177e4
LT		 455 *
456 * Parses the connection list of the given widget and stores the list
457 * of NIDs.
458 *
459 * Returns the number of connections, or a negative error code.
460 */
09cf03b8
TI		 461int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
462 hda_nid_t *conn_list, int max_conns)
a12d3e1e 463{
ee8e765b
TI		 464 const hda_nid_t *list;
465 int len = snd_hda_get_conn_list(codec, nid, &list);
a12d3e1e 466
ee8e765b
TI		 467 if (len > 0 && conn_list) {
468 if (len > max_conns) {
09cf03b8
TI		 469 snd_printk(KERN_ERR "hda_codec: "
470 "Too many connections %d for NID 0x%x\n",
471 len, nid);
09cf03b8
TI		 472 return -EINVAL;
473 }
ee8e765b 474 memcpy(conn_list, list, len * sizeof(hda_nid_t));
a12d3e1e
TI		 475 }
476
ee8e765b 477 return len;
a12d3e1e
TI		 478}
479EXPORT_SYMBOL_HDA(snd_hda_get_connections);
480
4eea3091
TI		 481/* return CONNLIST_LEN parameter of the given widget */
482static unsigned int get_num_conns(struct hda_codec *codec, hda_nid_t nid)
483{
484 unsigned int wcaps = get_wcaps(codec, nid);
485 unsigned int parm;
486
487 if (!(wcaps & AC_WCAP_CONN_LIST) &&
488 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
489 return 0;
490
491 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
492 if (parm == -1)
493 parm = 0;
494 return parm;
495}
496
497int snd_hda_get_num_raw_conns(struct hda_codec *codec, hda_nid_t nid)
498{
b5f82b10 499 return snd_hda_get_raw_connections(codec, nid, NULL, 0);
4eea3091
TI		 500}
501
9e7717c9
TI		 502/**
503 * snd_hda_get_raw_connections - copy connection list without cache
504 * @codec: the HDA codec
505 * @nid: NID to parse
506 * @conn_list: connection list array
507 * @max_conns: max. number of connections to store
508 *
509 * Like snd_hda_get_connections(), copy the connection list but without
510 * checking through the connection-list cache.
511 * Currently called only from hda_proc.c, so not exported.
512 */
513int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
514 hda_nid_t *conn_list, int max_conns)
1da177e4
LT		 515{
516 unsigned int parm;
54d17403 517 int i, conn_len, conns;
1da177e4 518 unsigned int shift, num_elems, mask;
54d17403 519 hda_nid_t prev_nid;
5fdaecdb 520 int null_count = 0;
1da177e4 521
4eea3091
TI		 522 parm = get_num_conns(codec, nid);
523 if (!parm)
8d087c76 524 return 0;
16a433d8 525
1da177e4
LT		 526 if (parm & AC_CLIST_LONG) {
527 /* long form */
528 shift = 16;
529 num_elems = 2;
530 } else {
531 /* short form */
532 shift = 8;
533 num_elems = 4;
534 }
535 conn_len = parm & AC_CLIST_LENGTH;
1da177e4
LT		 536 mask = (1 << (shift-1)) - 1;
537
0ba21762 538 if (!conn_len)
1da177e4
LT		 539 return 0; /* no connection */
540
541 if (conn_len == 1) {
542 /* single connection */
0ba21762
TI		 543 parm = snd_hda_codec_read(codec, nid, 0,
544 AC_VERB_GET_CONNECT_LIST, 0);
3c6aae44
TI		 545 if (parm == -1 && codec->bus->rirb_error)
546 return -EIO;
b5f82b10
TI		 547 if (conn_list)
548 conn_list[0] = parm & mask;
1da177e4
LT		 549 return 1;
550 }
551
552 /* multi connection */
553 conns = 0;
54d17403
TI		 554 prev_nid = 0;
555 for (i = 0; i < conn_len; i++) {
556 int range_val;
557 hda_nid_t val, n;
558
3c6aae44 559 if (i % num_elems == 0) {
54d17403
TI		 560 parm = snd_hda_codec_read(codec, nid, 0,
561 AC_VERB_GET_CONNECT_LIST, i);
3c6aae44
TI		 562 if (parm == -1 && codec->bus->rirb_error)
563 return -EIO;
564 }
0ba21762 565 range_val = !!(parm & (1 << (shift-1))); /* ranges */
54d17403 566 val = parm & mask;
5fdaecdb 567 if (val == 0 && null_count++) { /* no second chance */
4758fed9 568 snd_printdd("hda_codec: "
2e9bf247
JK		 569 "invalid CONNECT_LIST verb %x[%i]:%x\n",
570 nid, i, parm);
571 return 0;
572 }
54d17403
TI		 573 parm >>= shift;
574 if (range_val) {
575 /* ranges between the previous and this one */
0ba21762
TI		 576 if (!prev_nid || prev_nid >= val) {
577 snd_printk(KERN_WARNING "hda_codec: "
578 "invalid dep_range_val %x:%x\n",
579 prev_nid, val);
54d17403
TI		 580 continue;
581 }
582 for (n = prev_nid + 1; n <= val; n++) {
b5f82b10
TI		 583 if (conn_list) {
584 if (conns >= max_conns)
585 return -ENOSPC;
586 conn_list[conns] = n;
587 }
588 conns++;
589 }
590 } else {
591 if (conn_list) {
4eea3091
TI		 592 if (conns >= max_conns)
593 return -ENOSPC;
b5f82b10 594 conn_list[conns] = val;
1da177e4 595 }
b5f82b10 596 conns++;
1da177e4 597 }
54d17403 598 prev_nid = val;
1da177e4
LT		 599 }
600 return conns;
601}
602
b2f934a0
TI		 603/**
604 * snd_hda_override_conn_list - add/modify the connection-list to cache
605 * @codec: the HDA codec
606 * @nid: NID to parse
607 * @len: number of connection list entries
608 * @list: the list of connection entries
609 *
610 * Add or modify the given connection-list to the cache. If the corresponding
611 * cache already exists, invalidate it and append a new one.
612 *
613 * Returns zero or a negative error code.
614 */
615int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
616 const hda_nid_t *list)
617{
ee8e765b 618 struct hda_conn_list *p;
b2f934a0 619
ee8e765b
TI		 620 p = lookup_conn_list(codec, nid);
621 if (p) {
622 list_del(&p->list);
623 kfree(p);
624 }
b2f934a0 625
ee8e765b 626 return add_conn_list(codec, nid, len, list);
b2f934a0
TI		 627}
628EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
629
8d087c76
TI		 630/**
631 * snd_hda_get_conn_index - get the connection index of the given NID
632 * @codec: the HDA codec
633 * @mux: NID containing the list
634 * @nid: NID to select
635 * @recursive: 1 when searching NID recursively, otherwise 0
636 *
637 * Parses the connection list of the widget @mux and checks whether the
638 * widget @nid is present. If it is, return the connection index.
639 * Otherwise it returns -1.
640 */
641int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
642 hda_nid_t nid, int recursive)
a12d3e1e 643{
ee8e765b 644 const hda_nid_t *conn;
8d087c76
TI		 645 int i, nums;
646
ee8e765b 647 nums = snd_hda_get_conn_list(codec, mux, &conn);
8d087c76
TI		 648 for (i = 0; i < nums; i++)
649 if (conn[i] == nid)
650 return i;
651 if (!recursive)
652 return -1;
d94ddd85 653 if (recursive > 10) {
8d087c76
TI		 654 snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
655 return -1;
a12d3e1e 656 }
8d087c76 657 recursive++;
99e14c9d
TI		 658 for (i = 0; i < nums; i++) {
659 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
660 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
661 continue;
8d087c76
TI		 662 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
663 return i;
99e14c9d 664 }
8d087c76 665 return -1;
a12d3e1e 666}
8d087c76 667EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
1da177e4 668
f1aa0684
ML		 669
670/* return DEVLIST_LEN parameter of the given widget */
671static unsigned int get_num_devices(struct hda_codec *codec, hda_nid_t nid)
672{
673 unsigned int wcaps = get_wcaps(codec, nid);
674 unsigned int parm;
675
676 if (!codec->dp_mst || !(wcaps & AC_WCAP_DIGITAL) ||
677 get_wcaps_type(wcaps) != AC_WID_PIN)
678 return 0;
679
680 parm = snd_hda_param_read(codec, nid, AC_PAR_DEVLIST_LEN);
681 if (parm == -1 && codec->bus->rirb_error)
682 parm = 0;
683 return parm & AC_DEV_LIST_LEN_MASK;
684}
685
686/**
687 * snd_hda_get_devices - copy device list without cache
688 * @codec: the HDA codec
689 * @nid: NID of the pin to parse
690 * @dev_list: device list array
691 * @max_devices: max. number of devices to store
692 *
693 * Copy the device list. This info is dynamic and so not cached.
694 * Currently called only from hda_proc.c, so not exported.
695 */
696int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
697 u8 *dev_list, int max_devices)
698{
699 unsigned int parm;
700 int i, dev_len, devices;
701
702 parm = get_num_devices(codec, nid);
703 if (!parm) /* not multi-stream capable */
704 return 0;
705
706 dev_len = parm + 1;
707 dev_len = dev_len < max_devices ? dev_len : max_devices;
708
709 devices = 0;
710 while (devices < dev_len) {
711 parm = snd_hda_codec_read(codec, nid, 0,
712 AC_VERB_GET_DEVICE_LIST, devices);
713 if (parm == -1 && codec->bus->rirb_error)
714 break;
715
716 for (i = 0; i < 8; i++) {
717 dev_list[devices] = (u8)parm;
718 parm >>= 4;
719 devices++;
720 if (devices >= dev_len)
721 break;
722 }
723 }
724 return devices;
725}
726
1da177e4
LT		 727/**
728 * snd_hda_queue_unsol_event - add an unsolicited event to queue
729 * @bus: the BUS
730 * @res: unsolicited event (lower 32bit of RIRB entry)
731 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
732 *
733 * Adds the given event to the queue. The events are processed in
734 * the workqueue asynchronously. Call this function in the interrupt
735 * hanlder when RIRB receives an unsolicited event.
736 *
737 * Returns 0 if successful, or a negative error code.
738 */
739int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
740{
741 struct hda_bus_unsolicited *unsol;
742 unsigned int wp;
743
2195b063
WY		 744 if (!bus || !bus->workq)
745 return 0;
746
ecf726f5 747 trace_hda_unsol_event(bus, res, res_ex);
0ba21762
TI		 748 unsol = bus->unsol;
749 if (!unsol)
1da177e4
LT		 750 return 0;
751
752 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
753 unsol->wp = wp;
754
755 wp <<= 1;
756 unsol->queue[wp] = res;
757 unsol->queue[wp + 1] = res_ex;
758
6acaed38 759 queue_work(bus->workq, &unsol->work);
1da177e4
LT		 760
761 return 0;
762}
ff7a3267 763EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
1da177e4
LT		 764
765/*
5c1d1a98 766 * process queued unsolicited events
1da177e4 767 */
c4028958 768static void process_unsol_events(struct work_struct *work)
1da177e4 769{
c4028958
DH		 770 struct hda_bus_unsolicited *unsol =
771 container_of(work, struct hda_bus_unsolicited, work);
772 struct hda_bus *bus = unsol->bus;
1da177e4
LT		 773 struct hda_codec *codec;
774 unsigned int rp, caddr, res;
775
776 while (unsol->rp != unsol->wp) {
777 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
778 unsol->rp = rp;
779 rp <<= 1;
780 res = unsol->queue[rp];
781 caddr = unsol->queue[rp + 1];
0ba21762 782 if (!(caddr & (1 << 4))) /* no unsolicited event? */
1da177e4
LT		 783 continue;
784 codec = bus->caddr_tbl[caddr & 0x0f];
785 if (codec && codec->patch_ops.unsol_event)
786 codec->patch_ops.unsol_event(codec, res);
787 }
788}
789
790/*
791 * initialize unsolicited queue
792 */
6c1f45ea 793static int init_unsol_queue(struct hda_bus *bus)
1da177e4
LT		 794{
795 struct hda_bus_unsolicited *unsol;
796
9f146bb6
TI		 797 if (bus->unsol) /* already initialized */
798 return 0;
799
e560d8d8 800 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
0ba21762
TI		 801 if (!unsol) {
802 snd_printk(KERN_ERR "hda_codec: "
803 "can't allocate unsolicited queue\n");
1da177e4
LT		 804 return -ENOMEM;
805 }
c4028958
DH		 806 INIT_WORK(&unsol->work, process_unsol_events);
807 unsol->bus = bus;
1da177e4
LT		 808 bus->unsol = unsol;
809 return 0;
810}
811
812/*
813 * destructor
814 */
815static void snd_hda_codec_free(struct hda_codec *codec);
816
817static int snd_hda_bus_free(struct hda_bus *bus)
818{
0ba21762 819 struct hda_codec *codec, *n;
1da177e4 820
0ba21762 821 if (!bus)
1da177e4 822 return 0;
6acaed38
TI		 823 if (bus->workq)
824 flush_workqueue(bus->workq);
825 if (bus->unsol)
1da177e4 826 kfree(bus->unsol);
0ba21762 827 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
1da177e4
LT		 828 snd_hda_codec_free(codec);
829 }
830 if (bus->ops.private_free)
831 bus->ops.private_free(bus);
6acaed38
TI		 832 if (bus->workq)
833 destroy_workqueue(bus->workq);
1da177e4
LT		 834 kfree(bus);
835 return 0;
836}
837
c8b6bf9b 838static int snd_hda_bus_dev_free(struct snd_device *device)
1da177e4
LT		 839{
840 struct hda_bus *bus = device->device_data;
b94d3539 841 bus->shutdown = 1;
1da177e4
LT		 842 return snd_hda_bus_free(bus);
843}
844
d7ffba19
TI		 845#ifdef CONFIG_SND_HDA_HWDEP
846static int snd_hda_bus_dev_register(struct snd_device *device)
847{
848 struct hda_bus *bus = device->device_data;
849 struct hda_codec *codec;
850 list_for_each_entry(codec, &bus->codec_list, list) {
851 snd_hda_hwdep_add_sysfs(codec);
a2f6309e 852 snd_hda_hwdep_add_power_sysfs(codec);
d7ffba19
TI		 853 }
854 return 0;
855}
856#else
857#define snd_hda_bus_dev_register NULL
858#endif
859
1da177e4
LT		 860/**
861 * snd_hda_bus_new - create a HDA bus
862 * @card: the card entry
863 * @temp: the template for hda_bus information
864 * @busp: the pointer to store the created bus instance
865 *
866 * Returns 0 if successful, or a negative error code.
867 */
6a0f56a7 868int snd_hda_bus_new(struct snd_card *card,
756e2b01
TI		 869 const struct hda_bus_template *temp,
870 struct hda_bus **busp)
1da177e4
LT		 871{
872 struct hda_bus *bus;
873 int err;
c8b6bf9b 874 static struct snd_device_ops dev_ops = {
d7ffba19 875 .dev_register = snd_hda_bus_dev_register,
1da177e4
LT		 876 .dev_free = snd_hda_bus_dev_free,
877 };
878
da3cec35
TI		 879 if (snd_BUG_ON(!temp))
880 return -EINVAL;
881 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
882 return -EINVAL;
1da177e4
LT		 883
884 if (busp)
885 *busp = NULL;
886
e560d8d8 887 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
1da177e4
LT		 888 if (bus == NULL) {
889 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
890 return -ENOMEM;
891 }
892
893 bus->card = card;
894 bus->private_data = temp->private_data;
895 bus->pci = temp->pci;
896 bus->modelname = temp->modelname;
fee2fba3 897 bus->power_save = temp->power_save;
1da177e4
LT		 898 bus->ops = temp->ops;
899
62932df8 900 mutex_init(&bus->cmd_mutex);
3f50ac6a 901 mutex_init(&bus->prepare_mutex);
1da177e4
LT		 902 INIT_LIST_HEAD(&bus->codec_list);
903
e8c0ee5d
TI		 904 snprintf(bus->workq_name, sizeof(bus->workq_name),
905 "hd-audio%d", card->number);
906 bus->workq = create_singlethread_workqueue(bus->workq_name);
6acaed38 907 if (!bus->workq) {
e8c0ee5d
TI		 908 snd_printk(KERN_ERR "cannot create workqueue %s\n",
909 bus->workq_name);
6acaed38
TI		 910 kfree(bus);
911 return -ENOMEM;
912 }
913
0ba21762
TI		 914 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
915 if (err < 0) {
1da177e4
LT		 916 snd_hda_bus_free(bus);
917 return err;
918 }
919 if (busp)
920 *busp = bus;
921 return 0;
922}
ff7a3267 923EXPORT_SYMBOL_HDA(snd_hda_bus_new);
1da177e4 924
82467611
TI		 925#ifdef CONFIG_SND_HDA_GENERIC
926#define is_generic_config(codec) \
f44ac837 927 (codec->modelname && !strcmp(codec->modelname, "generic"))
82467611
TI		 928#else
929#define is_generic_config(codec) 0
930#endif
931
645f10c1 932#ifdef MODULE
1289e9e8
TI		 933#define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
934#else
645f10c1 935#define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
1289e9e8
TI		 936#endif
937
1da177e4
LT		 938/*
939 * find a matching codec preset
940 */
6c1f45ea 941static const struct hda_codec_preset *
756e2b01 942find_codec_preset(struct hda_codec *codec)
1da177e4 943{
1289e9e8
TI		 944 struct hda_codec_preset_list *tbl;
945 const struct hda_codec_preset *preset;
5d908ab9 946 unsigned int mod_requested = 0;
1da177e4 947
82467611 948 if (is_generic_config(codec))
d5ad630b
TI		 949 return NULL; /* use the generic parser */
950
1289e9e8
TI		 951 again:
952 mutex_lock(&preset_mutex);
953 list_for_each_entry(tbl, &hda_preset_tables, list) {
954 if (!try_module_get(tbl->owner)) {
955 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
956 continue;
957 }
958 for (preset = tbl->preset; preset->id; preset++) {
1da177e4 959 u32 mask = preset->mask;
ca7cfae9
MB		 960 if (preset->afg && preset->afg != codec->afg)
961 continue;
962 if (preset->mfg && preset->mfg != codec->mfg)
963 continue;
0ba21762 964 if (!mask)
1da177e4 965 mask = ~0;
9c7f852e 966 if (preset->id == (codec->vendor_id & mask) &&
0ba21762 967 (!preset->rev ||
1289e9e8
TI		 968 preset->rev == codec->revision_id)) {
969 mutex_unlock(&preset_mutex);
970 codec->owner = tbl->owner;
1da177e4 971 return preset;
1289e9e8 972 }
1da177e4 973 }
1289e9e8
TI		 974 module_put(tbl->owner);
975 }
976 mutex_unlock(&preset_mutex);
977
978 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
979 char name[32];
980 if (!mod_requested)
981 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
982 codec->vendor_id);
983 else
984 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
985 (codec->vendor_id >> 16) & 0xffff);
986 request_module(name);
987 mod_requested++;
988 goto again;
1da177e4
LT		 989 }
990 return NULL;
991}
992
993/*
f44ac837 994 * get_codec_name - store the codec name
1da177e4 995 */
f44ac837 996static int get_codec_name(struct hda_codec *codec)
1da177e4
LT		 997{
998 const struct hda_vendor_id *c;
999 const char *vendor = NULL;
1000 u16 vendor_id = codec->vendor_id >> 16;
812a2cca
TI		 1001 char tmp[16];
1002
1003 if (codec->vendor_name)
1004 goto get_chip_name;
1da177e4
LT		 1005
1006 for (c = hda_vendor_ids; c->id; c++) {
1007 if (c->id == vendor_id) {
1008 vendor = c->name;
1009 break;
1010 }
1011 }
0ba21762 1012 if (!vendor) {
1da177e4
LT		 1013 sprintf(tmp, "Generic %04x", vendor_id);
1014 vendor = tmp;
1015 }
812a2cca
TI		 1016 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
1017 if (!codec->vendor_name)
1018 return -ENOMEM;
1019
1020 get_chip_name:
1021 if (codec->chip_name)
1022 return 0;
1023
1da177e4 1024 if (codec->preset && codec->preset->name)
812a2cca
TI		 1025 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
1026 else {
1027 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
1028 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
1029 }
1030 if (!codec->chip_name)
f44ac837
TI		 1031 return -ENOMEM;
1032 return 0;
1da177e4
LT		 1033}
1034
1035/*
673b683a 1036 * look for an AFG and MFG nodes
1da177e4 1037 */
6a0f56a7 1038static void setup_fg_nodes(struct hda_codec *codec)
1da177e4 1039{
93e82ae7 1040 int i, total_nodes, function_id;
1da177e4
LT		 1041 hda_nid_t nid;
1042
1043 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
1044 for (i = 0; i < total_nodes; i++, nid++) {
93e82ae7 1045 function_id = snd_hda_param_read(codec, nid,
79c944ad 1046 AC_PAR_FUNCTION_TYPE);
cd7643bf 1047 switch (function_id & 0xff) {
673b683a
SK		 1048 case AC_GRP_AUDIO_FUNCTION:
1049 codec->afg = nid;
79c944ad
JK		 1050 codec->afg_function_id = function_id & 0xff;
1051 codec->afg_unsol = (function_id >> 8) & 1;
673b683a
SK		 1052 break;
1053 case AC_GRP_MODEM_FUNCTION:
1054 codec->mfg = nid;
79c944ad
JK		 1055 codec->mfg_function_id = function_id & 0xff;
1056 codec->mfg_unsol = (function_id >> 8) & 1;
673b683a
SK		 1057 break;
1058 default:
1059 break;
1060 }
1da177e4 1061 }
1da177e4
LT		 1062}
1063
54d17403
TI		 1064/*
1065 * read widget caps for each widget and store in cache
1066 */
1067static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
1068{
1069 int i;
1070 hda_nid_t nid;
1071
1072 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
1073 &codec->start_nid);
1074 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
0ba21762 1075 if (!codec->wcaps)
54d17403
TI		 1076 return -ENOMEM;
1077 nid = codec->start_nid;
1078 for (i = 0; i < codec->num_nodes; i++, nid++)
1079 codec->wcaps[i] = snd_hda_param_read(codec, nid,
1080 AC_PAR_AUDIO_WIDGET_CAP);
1081 return 0;
1082}
1083
3be14149
TI		 1084/* read all pin default configurations and save codec->init_pins */
1085static int read_pin_defaults(struct hda_codec *codec)
1086{
1087 int i;
1088 hda_nid_t nid = codec->start_nid;
1089
1090 for (i = 0; i < codec->num_nodes; i++, nid++) {
1091 struct hda_pincfg *pin;
1092 unsigned int wcaps = get_wcaps(codec, nid);
a22d543a 1093 unsigned int wid_type = get_wcaps_type(wcaps);
3be14149
TI		 1094 if (wid_type != AC_WID_PIN)
1095 continue;
1096 pin = snd_array_new(&codec->init_pins);
1097 if (!pin)
1098 return -ENOMEM;
1099 pin->nid = nid;
1100 pin->cfg = snd_hda_codec_read(codec, nid, 0,
1101 AC_VERB_GET_CONFIG_DEFAULT, 0);
ac0547dc
TI		 1102 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
1103 AC_VERB_GET_PIN_WIDGET_CONTROL,
1104 0);
3be14149
TI		 1105 }
1106 return 0;
1107}
1108
1109/* look up the given pin config list and return the item matching with NID */
1110static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
1111 struct snd_array *array,
1112 hda_nid_t nid)
1113{
1114 int i;
1115 for (i = 0; i < array->used; i++) {
1116 struct hda_pincfg *pin = snd_array_elem(array, i);
1117 if (pin->nid == nid)
1118 return pin;
1119 }
1120 return NULL;
1121}
1122
3be14149
TI		 1123/* set the current pin config value for the given NID.
1124 * the value is cached, and read via snd_hda_codec_get_pincfg()
1125 */
1126int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1127 hda_nid_t nid, unsigned int cfg)
1128{
1129 struct hda_pincfg *pin;
1130
d5657ec9
TI		 1131 /* the check below may be invalid when pins are added by a fixup
1132 * dynamically (e.g. via snd_hda_codec_update_widgets()), so disabled
1133 * for now
1134 */
1135 /*
b82855a0
TI		 1136 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1137 return -EINVAL;
d5657ec9 1138 */
b82855a0 1139
3be14149
TI		 1140 pin = look_up_pincfg(codec, list, nid);
1141 if (!pin) {
1142 pin = snd_array_new(list);
1143 if (!pin)
1144 return -ENOMEM;
1145 pin->nid = nid;
1146 }
1147 pin->cfg = cfg;
3be14149
TI		 1148 return 0;
1149}
1150
d5191e50
TI		 1151/**
1152 * snd_hda_codec_set_pincfg - Override a pin default configuration
1153 * @codec: the HDA codec
1154 * @nid: NID to set the pin config
1155 * @cfg: the pin default config value
1156 *
1157 * Override a pin default configuration value in the cache.
1158 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1159 * priority than the real hardware value.
1160 */
3be14149
TI		 1161int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1162 hda_nid_t nid, unsigned int cfg)
1163{
346ff70f 1164 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
3be14149
TI		 1165}
1166EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
1167
d5191e50
TI		 1168/**
1169 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1170 * @codec: the HDA codec
1171 * @nid: NID to get the pin config
1172 *
1173 * Get the current pin config value of the given pin NID.
1174 * If the pincfg value is cached or overridden via sysfs or driver,
1175 * returns the cached value.
1176 */
3be14149
TI		 1177unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1178{
1179 struct hda_pincfg *pin;
1180
3be14149 1181#ifdef CONFIG_SND_HDA_HWDEP
09b70e85
TI		 1182 {
1183 unsigned int cfg = 0;
1184 mutex_lock(&codec->user_mutex);
1185 pin = look_up_pincfg(codec, &codec->user_pins, nid);
1186 if (pin)
1187 cfg = pin->cfg;
1188 mutex_unlock(&codec->user_mutex);
1189 if (cfg)
1190 return cfg;
1191 }
3be14149 1192#endif
5e7b8e0d
TI		 1193 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1194 if (pin)
1195 return pin->cfg;
3be14149
TI		 1196 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1197 if (pin)
1198 return pin->cfg;
1199 return 0;
1200}
1201EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
1202
d7fdc00a
TI		 1203/* remember the current pinctl target value */
1204int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
1205 unsigned int val)
1206{
1207 struct hda_pincfg *pin;
1208
1209 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1210 if (!pin)
1211 return -EINVAL;
1212 pin->target = val;
1213 return 0;
1214}
1215EXPORT_SYMBOL_HDA(snd_hda_codec_set_pin_target);
1216
1217/* return the current pinctl target value */
1218int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
1219{
1220 struct hda_pincfg *pin;
1221
1222 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1223 if (!pin)
1224 return 0;
1225 return pin->target;
1226}
1227EXPORT_SYMBOL_HDA(snd_hda_codec_get_pin_target);
1228
92ee6162
TI		 1229/**
1230 * snd_hda_shutup_pins - Shut up all pins
1231 * @codec: the HDA codec
1232 *
1233 * Clear all pin controls to shup up before suspend for avoiding click noise.
1234 * The controls aren't cached so that they can be resumed properly.
1235 */
1236void snd_hda_shutup_pins(struct hda_codec *codec)
1237{
1238 int i;
ac0547dc
TI		 1239 /* don't shut up pins when unloading the driver; otherwise it breaks
1240 * the default pin setup at the next load of the driver
1241 */
1242 if (codec->bus->shutdown)
1243 return;
92ee6162
TI		 1244 for (i = 0; i < codec->init_pins.used; i++) {
1245 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1246 /* use read here for syncing after issuing each verb */
1247 snd_hda_codec_read(codec, pin->nid, 0,
1248 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1249 }
ac0547dc 1250 codec->pins_shutup = 1;
92ee6162
TI		 1251}
1252EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
1253
2a43952a 1254#ifdef CONFIG_PM
ac0547dc
TI		 1255/* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1256static void restore_shutup_pins(struct hda_codec *codec)
1257{
1258 int i;
1259 if (!codec->pins_shutup)
1260 return;
1261 if (codec->bus->shutdown)
1262 return;
1263 for (i = 0; i < codec->init_pins.used; i++) {
1264 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1265 snd_hda_codec_write(codec, pin->nid, 0,
1266 AC_VERB_SET_PIN_WIDGET_CONTROL,
1267 pin->ctrl);
1268 }
1269 codec->pins_shutup = 0;
1270}
1c7276cf 1271#endif
ac0547dc 1272
26a6cb6c
DH		 1273static void hda_jackpoll_work(struct work_struct *work)
1274{
1275 struct hda_codec *codec =
1276 container_of(work, struct hda_codec, jackpoll_work.work);
26a6cb6c
DH		 1277
1278 snd_hda_jack_set_dirty_all(codec);
1279 snd_hda_jack_poll_all(codec);
18e60627
WX		 1280
1281 if (!codec->jackpoll_interval)
1282 return;
1283
26a6cb6c
DH		 1284 queue_delayed_work(codec->bus->workq, &codec->jackpoll_work,
1285 codec->jackpoll_interval);
1286}
1287
01751f54
TI		 1288static void init_hda_cache(struct hda_cache_rec *cache,
1289 unsigned int record_size);
1fcaee6e 1290static void free_hda_cache(struct hda_cache_rec *cache);
01751f54 1291
3fdf1469
TI		 1292/* release all pincfg lists */
1293static void free_init_pincfgs(struct hda_codec *codec)
3be14149 1294{
346ff70f 1295 snd_array_free(&codec->driver_pins);
3be14149 1296#ifdef CONFIG_SND_HDA_HWDEP
346ff70f 1297 snd_array_free(&codec->user_pins);
3be14149 1298#endif
3be14149
TI		 1299 snd_array_free(&codec->init_pins);
1300}
1301
eb541337
TI		 1302/*
1303 * audio-converter setup caches
1304 */
1305struct hda_cvt_setup {
1306 hda_nid_t nid;
1307 u8 stream_tag;
1308 u8 channel_id;
1309 u16 format_id;
1310 unsigned char active; /* cvt is currently used */
1311 unsigned char dirty; /* setups should be cleared */
1312};
1313
1314/* get or create a cache entry for the given audio converter NID */
1315static struct hda_cvt_setup *
1316get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1317{
1318 struct hda_cvt_setup *p;
1319 int i;
1320
1321 for (i = 0; i < codec->cvt_setups.used; i++) {
1322 p = snd_array_elem(&codec->cvt_setups, i);
1323 if (p->nid == nid)
1324 return p;
1325 }
1326 p = snd_array_new(&codec->cvt_setups);
1327 if (p)
1328 p->nid = nid;
1329 return p;
1330}
1331
1da177e4
LT		 1332/*
1333 * codec destructor
1334 */
1335static void snd_hda_codec_free(struct hda_codec *codec)
1336{
0ba21762 1337 if (!codec)
1da177e4 1338 return;
26a6cb6c 1339 cancel_delayed_work_sync(&codec->jackpoll_work);
59cad16b 1340 snd_hda_jack_tbl_clear(codec);
3fdf1469 1341 free_init_pincfgs(codec);
83012a7c 1342#ifdef CONFIG_PM
cb53c626 1343 cancel_delayed_work(&codec->power_work);
6acaed38 1344 flush_workqueue(codec->bus->workq);
cb53c626 1345#endif
1da177e4 1346 list_del(&codec->list);
d13bd412 1347 snd_array_free(&codec->mixers);
5b0cb1d8 1348 snd_array_free(&codec->nids);
59cad16b 1349 snd_array_free(&codec->cvt_setups);
7c935976 1350 snd_array_free(&codec->spdif_out);
ee8e765b 1351 remove_conn_list(codec);
1da177e4
LT		 1352 codec->bus->caddr_tbl[codec->addr] = NULL;
1353 if (codec->patch_ops.free)
1354 codec->patch_ops.free(codec);
83012a7c 1355#ifdef CONFIG_PM
08fa20ae 1356 if (!codec->pm_down_notified) /* cancel leftover refcounts */
68467f51
TI		 1357 hda_call_pm_notify(codec->bus, false);
1358#endif
1289e9e8 1359 module_put(codec->owner);
01751f54 1360 free_hda_cache(&codec->amp_cache);
b3ac5636 1361 free_hda_cache(&codec->cmd_cache);
812a2cca
TI		 1362 kfree(codec->vendor_name);
1363 kfree(codec->chip_name);
f44ac837 1364 kfree(codec->modelname);
54d17403 1365 kfree(codec->wcaps);
1da177e4
LT		 1366 kfree(codec);
1367}
1368
b8dfc462
ML		 1369static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec,
1370 hda_nid_t fg, unsigned int power_state);
1371
d819387e 1372static unsigned int hda_set_power_state(struct hda_codec *codec,
bb6ac72f
TI		 1373 unsigned int power_state);
1374
1da177e4
LT		 1375/**
1376 * snd_hda_codec_new - create a HDA codec
1377 * @bus: the bus to assign
1378 * @codec_addr: the codec address
1379 * @codecp: the pointer to store the generated codec
1380 *
1381 * Returns 0 if successful, or a negative error code.
1382 */
6a0f56a7 1383int snd_hda_codec_new(struct hda_bus *bus,
28aedaf7
NL		 1384 unsigned int codec_addr,
1385 struct hda_codec **codecp)
1da177e4
LT		 1386{
1387 struct hda_codec *codec;
ba443687 1388 char component[31];
d819387e 1389 hda_nid_t fg;
1da177e4
LT		 1390 int err;
1391
da3cec35
TI		 1392 if (snd_BUG_ON(!bus))
1393 return -EINVAL;
1394 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1395 return -EINVAL;
1da177e4
LT		 1396
1397 if (bus->caddr_tbl[codec_addr]) {
0ba21762
TI		 1398 snd_printk(KERN_ERR "hda_codec: "
1399 "address 0x%x is already occupied\n", codec_addr);
1da177e4
LT		 1400 return -EBUSY;
1401 }
1402
e560d8d8 1403 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1da177e4
LT		 1404 if (codec == NULL) {
1405 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1406 return -ENOMEM;
1407 }
1408
1409 codec->bus = bus;
1410 codec->addr = codec_addr;
62932df8 1411 mutex_init(&codec->spdif_mutex);
5a9e02e9 1412 mutex_init(&codec->control_mutex);
c3b6bcc2 1413 mutex_init(&codec->hash_mutex);
01751f54 1414 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
b3ac5636 1415 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
5b0cb1d8
JK		 1416 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1417 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
3be14149 1418 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
346ff70f 1419 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
eb541337 1420 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
7c935976 1421 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
361dab3e 1422 snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
c9ce6b26 1423 snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
ee8e765b
TI		 1424 INIT_LIST_HEAD(&codec->conn_list);
1425
26a6cb6c 1426 INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
1da177e4 1427
83012a7c 1428#ifdef CONFIG_PM
5536c6d6 1429 spin_lock_init(&codec->power_lock);
cb53c626
TI		 1430 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1431 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1432 * the caller has to power down appropriatley after initialization
1433 * phase.
1434 */
1435 hda_keep_power_on(codec);
68467f51 1436 hda_call_pm_notify(bus, true);
cb53c626
TI		 1437#endif
1438
c382a9f0
TI		 1439 if (codec->bus->modelname) {
1440 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1441 if (!codec->modelname) {
1442 snd_hda_codec_free(codec);
1443 return -ENODEV;
1444 }
1445 }
1446
1da177e4
LT		 1447 list_add_tail(&codec->list, &bus->codec_list);
1448 bus->caddr_tbl[codec_addr] = codec;
1449
0ba21762
TI		 1450 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1451 AC_PAR_VENDOR_ID);
111d3af5
TI		 1452 if (codec->vendor_id == -1)
1453 /* read again, hopefully the access method was corrected
1454 * in the last read...
1455 */
1456 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1457 AC_PAR_VENDOR_ID);
0ba21762
TI		 1458 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1459 AC_PAR_SUBSYSTEM_ID);
1460 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1461 AC_PAR_REV_ID);
1da177e4 1462
673b683a 1463 setup_fg_nodes(codec);
0ba21762 1464 if (!codec->afg && !codec->mfg) {
673b683a 1465 snd_printdd("hda_codec: no AFG or MFG node found\n");
3be14149
TI		 1466 err = -ENODEV;
1467 goto error;
1da177e4
LT		 1468 }
1469
d819387e
TI		 1470 fg = codec->afg ? codec->afg : codec->mfg;
1471 err = read_widget_caps(codec, fg);
3be14149 1472 if (err < 0) {
54d17403 1473 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
3be14149 1474 goto error;
54d17403 1475 }
3be14149
TI		 1476 err = read_pin_defaults(codec);
1477 if (err < 0)
1478 goto error;
54d17403 1479
0ba21762 1480 if (!codec->subsystem_id) {
0ba21762 1481 codec->subsystem_id =
d819387e 1482 snd_hda_codec_read(codec, fg, 0,
0ba21762 1483 AC_VERB_GET_SUBSYSTEM_ID, 0);
86284e45
TI		 1484 }
1485
83012a7c 1486#ifdef CONFIG_PM
d819387e 1487 codec->d3_stop_clk = snd_hda_codec_get_supported_ps(codec, fg,
b8dfc462
ML		 1488 AC_PWRST_CLKSTOP);
1489 if (!codec->d3_stop_clk)
1490 bus->power_keep_link_on = 1;
5d6147f1 1491#endif
d819387e 1492 codec->epss = snd_hda_codec_get_supported_ps(codec, fg,
983f6b93 1493 AC_PWRST_EPSS);
b8dfc462 1494
bb6ac72f 1495 /* power-up all before initialization */
d819387e 1496 hda_set_power_state(codec, AC_PWRST_D0);
bb6ac72f 1497
6c1f45ea
TI		 1498 snd_hda_codec_proc_new(codec);
1499
6c1f45ea 1500 snd_hda_create_hwdep(codec);
6c1f45ea
TI		 1501
1502 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1503 codec->subsystem_id, codec->revision_id);
1504 snd_component_add(codec->bus->card, component);
1505
1506 if (codecp)
1507 *codecp = codec;
1508 return 0;
3be14149
TI		 1509
1510 error:
1511 snd_hda_codec_free(codec);
1512 return err;
6c1f45ea 1513}
ff7a3267 1514EXPORT_SYMBOL_HDA(snd_hda_codec_new);
6c1f45ea 1515
a15d05db
ML		 1516int snd_hda_codec_update_widgets(struct hda_codec *codec)
1517{
1518 hda_nid_t fg;
1519 int err;
1520
1521 /* Assume the function group node does not change,
1522 * only the widget nodes may change.
1523 */
1524 kfree(codec->wcaps);
1525 fg = codec->afg ? codec->afg : codec->mfg;
1526 err = read_widget_caps(codec, fg);
1527 if (err < 0) {
1528 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1529 return err;
1530 }
1531
1532 snd_array_free(&codec->init_pins);
1533 err = read_pin_defaults(codec);
1534
1535 return err;
1536}
1537EXPORT_SYMBOL_HDA(snd_hda_codec_update_widgets);
1538
1539
d5191e50
TI		 1540/**
1541 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1542 * @codec: the HDA codec
1543 *
1544 * Start parsing of the given codec tree and (re-)initialize the whole
1545 * patch instance.
1546 *
1547 * Returns 0 if successful or a negative error code.
1548 */
6c1f45ea
TI		 1549int snd_hda_codec_configure(struct hda_codec *codec)
1550{
1551 int err;
1552
d5ad630b 1553 codec->preset = find_codec_preset(codec);
812a2cca 1554 if (!codec->vendor_name || !codec->chip_name) {
f44ac837
TI		 1555 err = get_codec_name(codec);
1556 if (err < 0)
1557 return err;
1558 }
1da177e4 1559
82467611 1560 if (is_generic_config(codec)) {
1da177e4 1561 err = snd_hda_parse_generic_codec(codec);
82467611
TI		 1562 goto patched;
1563 }
82467611
TI		 1564 if (codec->preset && codec->preset->patch) {
1565 err = codec->preset->patch(codec);
1566 goto patched;
1567 }
1568
1569 /* call the default parser */
82467611 1570 err = snd_hda_parse_generic_codec(codec);
35a1e0cc
TI		 1571 if (err < 0)
1572 printk(KERN_ERR "hda-codec: No codec parser is available\n");
82467611
TI		 1573
1574 patched:
6c1f45ea
TI		 1575 if (!err && codec->patch_ops.unsol_event)
1576 err = init_unsol_queue(codec->bus);
f62faedb
TI		 1577 /* audio codec should override the mixer name */
1578 if (!err && (codec->afg || !*codec->bus->card->mixername))
1579 snprintf(codec->bus->card->mixername,
1580 sizeof(codec->bus->card->mixername),
1581 "%s %s", codec->vendor_name, codec->chip_name);
6c1f45ea 1582 return err;
1da177e4 1583}
a1e21c90 1584EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1da177e4 1585
ed360813
TI		 1586/* update the stream-id if changed */
1587static void update_pcm_stream_id(struct hda_codec *codec,
1588 struct hda_cvt_setup *p, hda_nid_t nid,
1589 u32 stream_tag, int channel_id)
1590{
1591 unsigned int oldval, newval;
1592
1593 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1594 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1595 newval = (stream_tag << 4) | channel_id;
1596 if (oldval != newval)
1597 snd_hda_codec_write(codec, nid, 0,
1598 AC_VERB_SET_CHANNEL_STREAMID,
1599 newval);
1600 p->stream_tag = stream_tag;
1601 p->channel_id = channel_id;
1602 }
1603}
1604
1605/* update the format-id if changed */
1606static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1607 hda_nid_t nid, int format)
1608{
1609 unsigned int oldval;
1610
1611 if (p->format_id != format) {
1612 oldval = snd_hda_codec_read(codec, nid, 0,
1613 AC_VERB_GET_STREAM_FORMAT, 0);
1614 if (oldval != format) {
1615 msleep(1);
1616 snd_hda_codec_write(codec, nid, 0,
1617 AC_VERB_SET_STREAM_FORMAT,
1618 format);
1619 }
1620 p->format_id = format;
1621 }
1622}
1623
1da177e4
LT		 1624/**
1625 * snd_hda_codec_setup_stream - set up the codec for streaming
1626 * @codec: the CODEC to set up
1627 * @nid: the NID to set up
1628 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1629 * @channel_id: channel id to pass, zero based.
1630 * @format: stream format.
1631 */
0ba21762
TI		 1632void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1633 u32 stream_tag,
1da177e4
LT		 1634 int channel_id, int format)
1635{
3f50ac6a 1636 struct hda_codec *c;
eb541337 1637 struct hda_cvt_setup *p;
62b7e5e0 1638 int type;
eb541337
TI		 1639 int i;
1640
0ba21762 1641 if (!nid)
d21b37ea
TI		 1642 return;
1643
0ba21762
TI		 1644 snd_printdd("hda_codec_setup_stream: "
1645 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1da177e4 1646 nid, stream_tag, channel_id, format);
eb541337 1647 p = get_hda_cvt_setup(codec, nid);
6c35ae3c 1648 if (!p)
eb541337 1649 return;
ed360813
TI		 1650
1651 if (codec->pcm_format_first)
1652 update_pcm_format(codec, p, nid, format);
1653 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1654 if (!codec->pcm_format_first)
1655 update_pcm_format(codec, p, nid, format);
1656
eb541337
TI		 1657 p->active = 1;
1658 p->dirty = 0;
1659
1660 /* make other inactive cvts with the same stream-tag dirty */
62b7e5e0 1661 type = get_wcaps_type(get_wcaps(codec, nid));
3f50ac6a
TI		 1662 list_for_each_entry(c, &codec->bus->codec_list, list) {
1663 for (i = 0; i < c->cvt_setups.used; i++) {
1664 p = snd_array_elem(&c->cvt_setups, i);
62b7e5e0 1665 if (!p->active && p->stream_tag == stream_tag &&
54c2a89f 1666 get_wcaps_type(get_wcaps(c, p->nid)) == type)
3f50ac6a
TI		 1667 p->dirty = 1;
1668 }
eb541337 1669 }
1da177e4 1670}
ff7a3267 1671EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1da177e4 1672
f0cea797
TI		 1673static void really_cleanup_stream(struct hda_codec *codec,
1674 struct hda_cvt_setup *q);
1675
d5191e50 1676/**
f0cea797 1677 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
d5191e50
TI		 1678 * @codec: the CODEC to clean up
1679 * @nid: the NID to clean up
f0cea797 1680 * @do_now: really clean up the stream instead of clearing the active flag
d5191e50 1681 */
f0cea797
TI		 1682void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1683 int do_now)
888afa15 1684{
eb541337
TI		 1685 struct hda_cvt_setup *p;
1686
888afa15
TI		 1687 if (!nid)
1688 return;
1689
0e7adbe2
TI		 1690 if (codec->no_sticky_stream)
1691 do_now = 1;
1692
888afa15 1693 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
eb541337 1694 p = get_hda_cvt_setup(codec, nid);
6c35ae3c 1695 if (p) {
f0cea797
TI		 1696 /* here we just clear the active flag when do_now isn't set;
1697 * actual clean-ups will be done later in
1698 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1699 */
1700 if (do_now)
1701 really_cleanup_stream(codec, p);
1702 else
1703 p->active = 0;
1704 }
eb541337 1705}
f0cea797 1706EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
eb541337
TI		 1707
1708static void really_cleanup_stream(struct hda_codec *codec,
1709 struct hda_cvt_setup *q)
1710{
1711 hda_nid_t nid = q->nid;
218264ae
TI		 1712 if (q->stream_tag || q->channel_id)
1713 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1714 if (q->format_id)
1715 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1716);
eb541337
TI		 1717 memset(q, 0, sizeof(*q));
1718 q->nid = nid;
1719}
1720
1721/* clean up the all conflicting obsolete streams */
1722static void purify_inactive_streams(struct hda_codec *codec)
1723{
3f50ac6a 1724 struct hda_codec *c;
eb541337
TI		 1725 int i;
1726
3f50ac6a
TI		 1727 list_for_each_entry(c, &codec->bus->codec_list, list) {
1728 for (i = 0; i < c->cvt_setups.used; i++) {
1729 struct hda_cvt_setup *p;
1730 p = snd_array_elem(&c->cvt_setups, i);
1731 if (p->dirty)
1732 really_cleanup_stream(c, p);
1733 }
eb541337
TI		 1734 }
1735}
1736
2a43952a 1737#ifdef CONFIG_PM
eb541337
TI		 1738/* clean up all streams; called from suspend */
1739static void hda_cleanup_all_streams(struct hda_codec *codec)
1740{
1741 int i;
1742
1743 for (i = 0; i < codec->cvt_setups.used; i++) {
1744 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1745 if (p->stream_tag)
1746 really_cleanup_stream(codec, p);
1747 }
888afa15 1748}
1c7276cf 1749#endif
888afa15 1750
1da177e4
LT		 1751/*
1752 * amp access functions
1753 */
1754
4a19faee 1755/* FIXME: more better hash key? */
28aedaf7 1756#define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1327a32b 1757#define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
92c7c8a7
TI		 1758#define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1759#define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1da177e4 1760#define INFO_AMP_CAPS (1<<0)
4a19faee 1761#define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1da177e4
LT		 1762
1763/* initialize the hash table */
6a0f56a7 1764static void init_hda_cache(struct hda_cache_rec *cache,
01751f54
TI		 1765 unsigned int record_size)
1766{
1767 memset(cache, 0, sizeof(*cache));
1768 memset(cache->hash, 0xff, sizeof(cache->hash));
603c4019 1769 snd_array_init(&cache->buf, record_size, 64);
01751f54
TI		 1770}
1771
1fcaee6e 1772static void free_hda_cache(struct hda_cache_rec *cache)
1da177e4 1773{
603c4019 1774 snd_array_free(&cache->buf);
1da177e4
LT		 1775}
1776
1777/* query the hash. allocate an entry if not found. */
a68d5a54 1778static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1da177e4 1779{
01751f54
TI		 1780 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1781 u16 cur = cache->hash[idx];
1782 struct hda_cache_head *info;
1da177e4
LT		 1783
1784 while (cur != 0xffff) {
f43aa025 1785 info = snd_array_elem(&cache->buf, cur);
1da177e4
LT		 1786 if (info->key == key)
1787 return info;
1788 cur = info->next;
1789 }
a68d5a54
TI		 1790 return NULL;
1791}
1da177e4 1792
a68d5a54
TI		 1793/* query the hash. allocate an entry if not found. */
1794static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1795 u32 key)
1796{
1797 struct hda_cache_head *info = get_hash(cache, key);
1798 if (!info) {
1799 u16 idx, cur;
1800 /* add a new hash entry */
1801 info = snd_array_new(&cache->buf);
1802 if (!info)
1803 return NULL;
1804 cur = snd_array_index(&cache->buf, info);
1805 info->key = key;
1806 info->val = 0;
c370dd6e 1807 info->dirty = 0;
a68d5a54
TI		 1808 idx = key % (u16)ARRAY_SIZE(cache->hash);
1809 info->next = cache->hash[idx];
1810 cache->hash[idx] = cur;
1811 }
1da177e4
LT		 1812 return info;
1813}
1814
01751f54
TI		 1815/* query and allocate an amp hash entry */
1816static inline struct hda_amp_info *
1817get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1818{
1819 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1820}
1821
c3b6bcc2
TI		 1822/* overwrite the value with the key in the caps hash */
1823static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1824{
1825 struct hda_amp_info *info;
1826
1827 mutex_lock(&codec->hash_mutex);
1828 info = get_alloc_amp_hash(codec, key);
1829 if (!info) {
1830 mutex_unlock(&codec->hash_mutex);
1831 return -EINVAL;
1832 }
1833 info->amp_caps = val;
1834 info->head.val |= INFO_AMP_CAPS;
1835 mutex_unlock(&codec->hash_mutex);
1836 return 0;
1837}
1838
1839/* query the value from the caps hash; if not found, fetch the current
1840 * value from the given function and store in the hash
1841 */
1842static unsigned int
1843query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1844 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1845{
1846 struct hda_amp_info *info;
1847 unsigned int val;
1848
1849 mutex_lock(&codec->hash_mutex);
1850 info = get_alloc_amp_hash(codec, key);
1851 if (!info) {
1852 mutex_unlock(&codec->hash_mutex);
1853 return 0;
1854 }
1855 if (!(info->head.val & INFO_AMP_CAPS)) {
1856 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1857 val = func(codec, nid, dir);
1858 write_caps_hash(codec, key, val);
1859 } else {
1860 val = info->amp_caps;
1861 mutex_unlock(&codec->hash_mutex);
1862 }
1863 return val;
1864}
1865
1866static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1867 int direction)
1868{
1869 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1870 nid = codec->afg;
1871 return snd_hda_param_read(codec, nid,
1872 direction == HDA_OUTPUT ?
1873 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1874}
1875
d5191e50
TI		 1876/**
1877 * query_amp_caps - query AMP capabilities
1878 * @codec: the HD-auio codec
1879 * @nid: the NID to query
1880 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1881 *
1882 * Query AMP capabilities for the given widget and direction.
1883 * Returns the obtained capability bits.
1884 *
1885 * When cap bits have been already read, this doesn't read again but
1886 * returns the cached value.
1da177e4 1887 */
09a99959 1888u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1da177e4 1889{
c3b6bcc2
TI		 1890 return query_caps_hash(codec, nid, direction,
1891 HDA_HASH_KEY(nid, direction, 0),
1892 read_amp_cap);
1da177e4 1893}
ff7a3267 1894EXPORT_SYMBOL_HDA(query_amp_caps);
1da177e4 1895
d5191e50
TI		 1896/**
1897 * snd_hda_override_amp_caps - Override the AMP capabilities
1898 * @codec: the CODEC to clean up
1899 * @nid: the NID to clean up
1900 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1901 * @caps: the capability bits to set
1902 *
1903 * Override the cached AMP caps bits value by the given one.
1904 * This function is useful if the driver needs to adjust the AMP ranges,
1905 * e.g. limit to 0dB, etc.
1906 *
1907 * Returns zero if successful or a negative error code.
1908 */
897cc188
TI		 1909int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1910 unsigned int caps)
1911{
c3b6bcc2 1912 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
897cc188 1913}
ff7a3267 1914EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1327a32b 1915
c3b6bcc2
TI		 1916static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1917 int dir)
92c7c8a7
TI		 1918{
1919 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1920}
1921
d5191e50
TI		 1922/**
1923 * snd_hda_query_pin_caps - Query PIN capabilities
1924 * @codec: the HD-auio codec
1925 * @nid: the NID to query
1926 *
1927 * Query PIN capabilities for the given widget.
1928 * Returns the obtained capability bits.
1929 *
1930 * When cap bits have been already read, this doesn't read again but
1931 * returns the cached value.
1932 */
92c7c8a7
TI		 1933u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1934{
c3b6bcc2 1935 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
92c7c8a7
TI		 1936 read_pin_cap);
1937}
1327a32b 1938EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
897cc188 1939
f57c2565
TI		 1940/**
1941 * snd_hda_override_pin_caps - Override the pin capabilities
1942 * @codec: the CODEC
1943 * @nid: the NID to override
1944 * @caps: the capability bits to set
1945 *
1946 * Override the cached PIN capabilitiy bits value by the given one.
1947 *
1948 * Returns zero if successful or a negative error code.
1949 */
1950int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1951 unsigned int caps)
1952{
c3b6bcc2 1953 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
f57c2565
TI		 1954}
1955EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1956
c3b6bcc2
TI		 1957/* read or sync the hash value with the current value;
1958 * call within hash_mutex
1da177e4 1959 */
c3b6bcc2
TI		 1960static struct hda_amp_info *
1961update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
280e57d5 1962 int direction, int index, bool init_only)
1da177e4 1963{
c3b6bcc2
TI		 1964 struct hda_amp_info *info;
1965 unsigned int parm, val = 0;
1966 bool val_read = false;
1da177e4 1967
c3b6bcc2
TI		 1968 retry:
1969 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1970 if (!info)
1971 return NULL;
1972 if (!(info->head.val & INFO_AMP_VOL(ch))) {
1973 if (!val_read) {
1974 mutex_unlock(&codec->hash_mutex);
1975 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1976 parm |= direction == HDA_OUTPUT ?
1977 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1978 parm |= index;
1979 val = snd_hda_codec_read(codec, nid, 0,
0ba21762 1980 AC_VERB_GET_AMP_GAIN_MUTE, parm);
c3b6bcc2
TI		 1981 val &= 0xff;
1982 val_read = true;
1983 mutex_lock(&codec->hash_mutex);
1984 goto retry;
1985 }
1986 info->vol[ch] = val;
1987 info->head.val |= INFO_AMP_VOL(ch);
280e57d5
TI		 1988 } else if (init_only)
1989 return NULL;
c3b6bcc2 1990 return info;
1da177e4
LT		 1991}
1992
1993/*
c3b6bcc2 1994 * write the current volume in info to the h/w
1da177e4 1995 */
2ce4886a 1996static void put_vol_mute(struct hda_codec *codec, unsigned int amp_caps,
0ba21762
TI		 1997 hda_nid_t nid, int ch, int direction, int index,
1998 int val)
1da177e4
LT		 1999{
2000 u32 parm;
2001
2002 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
2003 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
2004 parm |= index << AC_AMP_SET_INDEX_SHIFT;
2ce4886a
TI		 2005 if ((val & HDA_AMP_MUTE) && !(amp_caps & AC_AMPCAP_MUTE) &&
2006 (amp_caps & AC_AMPCAP_MIN_MUTE))
3868137e
TI		 2007 ; /* set the zero value as a fake mute */
2008 else
2009 parm |= val;
1da177e4
LT		 2010 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
2011}
2012
d5191e50
TI		 2013/**
2014 * snd_hda_codec_amp_read - Read AMP value
2015 * @codec: HD-audio codec
2016 * @nid: NID to read the AMP value
2017 * @ch: channel (left=0 or right=1)
2018 * @direction: #HDA_INPUT or #HDA_OUTPUT
2019 * @index: the index value (only for input direction)
2020 *
2021 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1da177e4 2022 */
834be88d
TI		 2023int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
2024 int direction, int index)
1da177e4 2025{
0ba21762 2026 struct hda_amp_info *info;
c3b6bcc2
TI		 2027 unsigned int val = 0;
2028
2029 mutex_lock(&codec->hash_mutex);
280e57d5 2030 info = update_amp_hash(codec, nid, ch, direction, index, false);
c3b6bcc2
TI		 2031 if (info)
2032 val = info->vol[ch];
2033 mutex_unlock(&codec->hash_mutex);
2034 return val;
1da177e4 2035}
ff7a3267 2036EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1da177e4 2037
280e57d5
TI		 2038static int codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
2039 int direction, int idx, int mask, int val,
2040 bool init_only)
1da177e4 2041{
0ba21762 2042 struct hda_amp_info *info;
2ce4886a 2043 unsigned int caps;
de1e37b7 2044 unsigned int cache_only;
4a19faee 2045
46712646
TI		 2046 if (snd_BUG_ON(mask & ~0xff))
2047 mask &= 0xff;
4a19faee 2048 val &= mask;
c3b6bcc2
TI		 2049
2050 mutex_lock(&codec->hash_mutex);
280e57d5 2051 info = update_amp_hash(codec, nid, ch, direction, idx, init_only);
c3b6bcc2
TI		 2052 if (!info) {
2053 mutex_unlock(&codec->hash_mutex);
2054 return 0;
2055 }
2056 val |= info->vol[ch] & ~mask;
2057 if (info->vol[ch] == val) {
2058 mutex_unlock(&codec->hash_mutex);
1da177e4 2059 return 0;
c3b6bcc2
TI		 2060 }
2061 info->vol[ch] = val;
de1e37b7 2062 cache_only = info->head.dirty = codec->cached_write;
2ce4886a 2063 caps = info->amp_caps;
c3b6bcc2 2064 mutex_unlock(&codec->hash_mutex);
de1e37b7 2065 if (!cache_only)
2ce4886a 2066 put_vol_mute(codec, caps, nid, ch, direction, idx, val);
1da177e4
LT		 2067 return 1;
2068}
280e57d5
TI		 2069
2070/**
2071 * snd_hda_codec_amp_update - update the AMP value
2072 * @codec: HD-audio codec
2073 * @nid: NID to read the AMP value
2074 * @ch: channel (left=0 or right=1)
2075 * @direction: #HDA_INPUT or #HDA_OUTPUT
2076 * @idx: the index value (only for input direction)
2077 * @mask: bit mask to set
2078 * @val: the bits value to set
2079 *
2080 * Update the AMP value with a bit mask.
2081 * Returns 0 if the value is unchanged, 1 if changed.
2082 */
2083int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
2084 int direction, int idx, int mask, int val)
2085{
2086 return codec_amp_update(codec, nid, ch, direction, idx, mask, val, false);
2087}
ff7a3267 2088EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1da177e4 2089
d5191e50
TI		 2090/**
2091 * snd_hda_codec_amp_stereo - update the AMP stereo values
2092 * @codec: HD-audio codec
2093 * @nid: NID to read the AMP value
2094 * @direction: #HDA_INPUT or #HDA_OUTPUT
2095 * @idx: the index value (only for input direction)
2096 * @mask: bit mask to set
2097 * @val: the bits value to set
2098 *
2099 * Update the AMP values like snd_hda_codec_amp_update(), but for a
2100 * stereo widget with the same mask and value.
47fd830a
TI		 2101 */
2102int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
2103 int direction, int idx, int mask, int val)
2104{
2105 int ch, ret = 0;
46712646
TI		 2106
2107 if (snd_BUG_ON(mask & ~0xff))
2108 mask &= 0xff;
47fd830a
TI		 2109 for (ch = 0; ch < 2; ch++)
2110 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
2111 idx, mask, val);
2112 return ret;
2113}
ff7a3267 2114EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
47fd830a 2115
280e57d5
TI		 2116/* Works like snd_hda_codec_amp_update() but it writes the value only at
2117 * the first access. If the amp was already initialized / updated beforehand,
2118 * this does nothing.
2119 */
2120int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
2121 int dir, int idx, int mask, int val)
2122{
2123 return codec_amp_update(codec, nid, ch, dir, idx, mask, val, true);
2124}
2125EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init);
2126
2127int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
2128 int dir, int idx, int mask, int val)
2129{
2130 int ch, ret = 0;
2131
2132 if (snd_BUG_ON(mask & ~0xff))
2133 mask &= 0xff;
2134 for (ch = 0; ch < 2; ch++)
2135 ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
2136 idx, mask, val);
2137 return ret;
2138}
2139EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init_stereo);
2140
d5191e50
TI		 2141/**
2142 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
2143 * @codec: HD-audio codec
2144 *
2145 * Resume the all amp commands from the cache.
2146 */
b3ac5636
TI		 2147void snd_hda_codec_resume_amp(struct hda_codec *codec)
2148{
b3ac5636
TI		 2149 int i;
2150
c370dd6e 2151 mutex_lock(&codec->hash_mutex);
aa88a355 2152 codec->cached_write = 0;
c370dd6e
TI		 2153 for (i = 0; i < codec->amp_cache.buf.used; i++) {
2154 struct hda_amp_info *buffer;
2155 u32 key;
b3ac5636
TI		 2156 hda_nid_t nid;
2157 unsigned int idx, dir, ch;
2ce4886a 2158 struct hda_amp_info info;
c370dd6e
TI		 2159
2160 buffer = snd_array_elem(&codec->amp_cache.buf, i);
8565f052
TI		 2161 if (!buffer->head.dirty)
2162 continue;
2163 buffer->head.dirty = 0;
2ce4886a
TI		 2164 info = *buffer;
2165 key = info.head.key;
b3ac5636
TI		 2166 if (!key)
2167 continue;
2168 nid = key & 0xff;
2169 idx = (key >> 16) & 0xff;
2170 dir = (key >> 24) & 0xff;
2171 for (ch = 0; ch < 2; ch++) {
2ce4886a 2172 if (!(info.head.val & INFO_AMP_VOL(ch)))
b3ac5636 2173 continue;
c370dd6e 2174 mutex_unlock(&codec->hash_mutex);
2ce4886a
TI		 2175 put_vol_mute(codec, info.amp_caps, nid, ch, dir, idx,
2176 info.vol[ch]);
c370dd6e 2177 mutex_lock(&codec->hash_mutex);
b3ac5636
TI		 2178 }
2179 }
c370dd6e 2180 mutex_unlock(&codec->hash_mutex);
b3ac5636 2181}
ff7a3267 2182EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1da177e4 2183
afbd9b84
TI		 2184static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
2185 unsigned int ofs)
2186{
2187 u32 caps = query_amp_caps(codec, nid, dir);
2188 /* get num steps */
2189 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2190 if (ofs < caps)
2191 caps -= ofs;
2192 return caps;
2193}
2194
d5191e50
TI		 2195/**
2196 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
2197 *
2198 * The control element is supposed to have the private_value field
2199 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2200 */
0ba21762
TI		 2201int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
2202 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 2203{
2204 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2205 u16 nid = get_amp_nid(kcontrol);
2206 u8 chs = get_amp_channels(kcontrol);
2207 int dir = get_amp_direction(kcontrol);
29fdbec2 2208 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4 2209
afbd9b84
TI		 2210 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2211 uinfo->count = chs == 3 ? 2 : 1;
2212 uinfo->value.integer.min = 0;
2213 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
2214 if (!uinfo->value.integer.max) {
0ba21762 2215 printk(KERN_WARNING "hda_codec: "
9c8f2abd
TI		 2216 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
2217 kcontrol->id.name);
1da177e4
LT		 2218 return -EINVAL;
2219 }
1da177e4
LT		 2220 return 0;
2221}
ff7a3267 2222EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1da177e4 2223
29fdbec2
TI		 2224
2225static inline unsigned int
2226read_amp_value(struct hda_codec *codec, hda_nid_t nid,
2227 int ch, int dir, int idx, unsigned int ofs)
2228{
2229 unsigned int val;
2230 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
2231 val &= HDA_AMP_VOLMASK;
2232 if (val >= ofs)
2233 val -= ofs;
2234 else
2235 val = 0;
2236 return val;
2237}
2238
2239static inline int
2240update_amp_value(struct hda_codec *codec, hda_nid_t nid,
2241 int ch, int dir, int idx, unsigned int ofs,
2242 unsigned int val)
2243{
afbd9b84
TI		 2244 unsigned int maxval;
2245
29fdbec2
TI		 2246 if (val > 0)
2247 val += ofs;
7ccc3efa
TI		 2248 /* ofs = 0: raw max value */
2249 maxval = get_amp_max_value(codec, nid, dir, 0);
afbd9b84
TI		 2250 if (val > maxval)
2251 val = maxval;
29fdbec2
TI		 2252 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
2253 HDA_AMP_VOLMASK, val);
2254}
2255
d5191e50
TI		 2256/**
2257 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
2258 *
2259 * The control element is supposed to have the private_value field
2260 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2261 */
0ba21762
TI		 2262int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
2263 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2264{
2265 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2266 hda_nid_t nid = get_amp_nid(kcontrol);
2267 int chs = get_amp_channels(kcontrol);
2268 int dir = get_amp_direction(kcontrol);
2269 int idx = get_amp_index(kcontrol);
29fdbec2 2270 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 2271 long *valp = ucontrol->value.integer.value;
2272
2273 if (chs & 1)
29fdbec2 2274 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1da177e4 2275 if (chs & 2)
29fdbec2 2276 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1da177e4
LT		 2277 return 0;
2278}
ff7a3267 2279EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1da177e4 2280
d5191e50
TI		 2281/**
2282 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2283 *
2284 * The control element is supposed to have the private_value field
2285 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2286 */
0ba21762
TI		 2287int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2288 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2289{
2290 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2291 hda_nid_t nid = get_amp_nid(kcontrol);
2292 int chs = get_amp_channels(kcontrol);
2293 int dir = get_amp_direction(kcontrol);
2294 int idx = get_amp_index(kcontrol);
29fdbec2 2295 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 2296 long *valp = ucontrol->value.integer.value;
2297 int change = 0;
2298
cb53c626 2299 snd_hda_power_up(codec);
b9f5a89c 2300 if (chs & 1) {
29fdbec2 2301 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
b9f5a89c
NG		 2302 valp++;
2303 }
4a19faee 2304 if (chs & 2)
29fdbec2 2305 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
cb53c626 2306 snd_hda_power_down(codec);
1da177e4
LT		 2307 return change;
2308}
ff7a3267 2309EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1da177e4 2310
d5191e50
TI		 2311/**
2312 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2313 *
2314 * The control element is supposed to have the private_value field
2315 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2316 */
302e9c5a
JK		 2317int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2318 unsigned int size, unsigned int __user *_tlv)
2319{
2320 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2321 hda_nid_t nid = get_amp_nid(kcontrol);
2322 int dir = get_amp_direction(kcontrol);
29fdbec2 2323 unsigned int ofs = get_amp_offset(kcontrol);
de8c85f7 2324 bool min_mute = get_amp_min_mute(kcontrol);
302e9c5a
JK		 2325 u32 caps, val1, val2;
2326
2327 if (size < 4 * sizeof(unsigned int))
2328 return -ENOMEM;
2329 caps = query_amp_caps(codec, nid, dir);
0ba21762
TI		 2330 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2331 val2 = (val2 + 1) * 25;
302e9c5a 2332 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
29fdbec2 2333 val1 += ofs;
302e9c5a 2334 val1 = ((int)val1) * ((int)val2);
3868137e 2335 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
c08d9169 2336 val2 |= TLV_DB_SCALE_MUTE;
302e9c5a
JK		 2337 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2338 return -EFAULT;
2339 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2340 return -EFAULT;
2341 if (put_user(val1, _tlv + 2))
2342 return -EFAULT;
2343 if (put_user(val2, _tlv + 3))
2344 return -EFAULT;
2345 return 0;
2346}
ff7a3267 2347EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
302e9c5a 2348
d5191e50
TI		 2349/**
2350 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2351 * @codec: HD-audio codec
2352 * @nid: NID of a reference widget
2353 * @dir: #HDA_INPUT or #HDA_OUTPUT
2354 * @tlv: TLV data to be stored, at least 4 elements
2355 *
2356 * Set (static) TLV data for a virtual master volume using the AMP caps
2357 * obtained from the reference NID.
2358 * The volume range is recalculated as if the max volume is 0dB.
2134ea4f
TI		 2359 */
2360void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2361 unsigned int *tlv)
2362{
2363 u32 caps;
2364 int nums, step;
2365
2366 caps = query_amp_caps(codec, nid, dir);
2367 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2368 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2369 step = (step + 1) * 25;
2370 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2371 tlv[1] = 2 * sizeof(unsigned int);
2372 tlv[2] = -nums * step;
2373 tlv[3] = step;
2374}
ff7a3267 2375EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2134ea4f
TI		 2376
2377/* find a mixer control element with the given name */
09f99701 2378static struct snd_kcontrol *
dcda5806 2379find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
2134ea4f
TI		 2380{
2381 struct snd_ctl_elem_id id;
2382 memset(&id, 0, sizeof(id));
2383 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
dcda5806 2384 id.device = dev;
09f99701 2385 id.index = idx;
18cb7109
TI		 2386 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2387 return NULL;
2134ea4f
TI		 2388 strcpy(id.name, name);
2389 return snd_ctl_find_id(codec->bus->card, &id);
2390}
2391
d5191e50
TI		 2392/**
2393 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2394 * @codec: HD-audio codec
2395 * @name: ctl id name string
2396 *
2397 * Get the control element with the given id string and IFACE_MIXER.
2398 */
09f99701
TI		 2399struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2400 const char *name)
2401{
dcda5806 2402 return find_mixer_ctl(codec, name, 0, 0);
09f99701 2403}
ff7a3267 2404EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
09f99701 2405
dcda5806 2406static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
ea9b43ad 2407 int start_idx)
1afe206a 2408{
ea9b43ad
TI		 2409 int i, idx;
2410 /* 16 ctlrs should be large enough */
2411 for (i = 0, idx = start_idx; i < 16; i++, idx++) {
2412 if (!find_mixer_ctl(codec, name, 0, idx))
1afe206a
TI		 2413 return idx;
2414 }
2415 return -EBUSY;
2416}
2417
d5191e50 2418/**
5b0cb1d8 2419 * snd_hda_ctl_add - Add a control element and assign to the codec
d5191e50
TI		 2420 * @codec: HD-audio codec
2421 * @nid: corresponding NID (optional)
2422 * @kctl: the control element to assign
2423 *
2424 * Add the given control element to an array inside the codec instance.
2425 * All control elements belonging to a codec are supposed to be added
2426 * by this function so that a proper clean-up works at the free or
2427 * reconfiguration time.
2428 *
2429 * If non-zero @nid is passed, the NID is assigned to the control element.
2430 * The assignment is shown in the codec proc file.
2431 *
2432 * snd_hda_ctl_add() checks the control subdev id field whether
2433 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
9e3fd871
JK		 2434 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2435 * specifies if kctl->private_value is a HDA amplifier value.
d5191e50 2436 */
3911a4c1
JK		 2437int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2438 struct snd_kcontrol *kctl)
d13bd412
TI		 2439{
2440 int err;
9e3fd871 2441 unsigned short flags = 0;
3911a4c1 2442 struct hda_nid_item *item;
d13bd412 2443
5e26dfd0 2444 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
9e3fd871 2445 flags |= HDA_NID_ITEM_AMP;
5e26dfd0
JK		 2446 if (nid == 0)
2447 nid = get_amp_nid_(kctl->private_value);
2448 }
9e3fd871
JK		 2449 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2450 nid = kctl->id.subdevice & 0xffff;
5e26dfd0 2451 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
4d02d1b6 2452 kctl->id.subdevice = 0;
d13bd412
TI		 2453 err = snd_ctl_add(codec->bus->card, kctl);
2454 if (err < 0)
2455 return err;
3911a4c1
JK		 2456 item = snd_array_new(&codec->mixers);
2457 if (!item)
d13bd412 2458 return -ENOMEM;
3911a4c1
JK		 2459 item->kctl = kctl;
2460 item->nid = nid;
9e3fd871 2461 item->flags = flags;
d13bd412
TI		 2462 return 0;
2463}
ff7a3267 2464EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
d13bd412 2465
5b0cb1d8
JK		 2466/**
2467 * snd_hda_add_nid - Assign a NID to a control element
2468 * @codec: HD-audio codec
2469 * @nid: corresponding NID (optional)
2470 * @kctl: the control element to assign
2471 * @index: index to kctl
2472 *
2473 * Add the given control element to an array inside the codec instance.
2474 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2475 * NID:KCTL mapping - for example "Capture Source" selector.
2476 */
2477int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2478 unsigned int index, hda_nid_t nid)
2479{
2480 struct hda_nid_item *item;
2481
2482 if (nid > 0) {
2483 item = snd_array_new(&codec->nids);
2484 if (!item)
2485 return -ENOMEM;
2486 item->kctl = kctl;
2487 item->index = index;
2488 item->nid = nid;
2489 return 0;
2490 }
28d1a85e
TI		 2491 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2492 kctl->id.name, kctl->id.index, index);
5b0cb1d8
JK		 2493 return -EINVAL;
2494}
2495EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2496
d5191e50
TI		 2497/**
2498 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2499 * @codec: HD-audio codec
2500 */
d13bd412
TI		 2501void snd_hda_ctls_clear(struct hda_codec *codec)
2502{
2503 int i;
3911a4c1 2504 struct hda_nid_item *items = codec->mixers.list;
d13bd412 2505 for (i = 0; i < codec->mixers.used; i++)
3911a4c1 2506 snd_ctl_remove(codec->bus->card, items[i].kctl);
d13bd412 2507 snd_array_free(&codec->mixers);
5b0cb1d8 2508 snd_array_free(&codec->nids);
d13bd412
TI		 2509}
2510
a65d629c
TI		 2511/* pseudo device locking
2512 * toggle card->shutdown to allow/disallow the device access (as a hack)
2513 */
d3d020bd 2514int snd_hda_lock_devices(struct hda_bus *bus)
6c1f45ea 2515{
d3d020bd
TI		 2516 struct snd_card *card = bus->card;
2517 struct hda_codec *codec;
2518
a65d629c 2519 spin_lock(&card->files_lock);
d3d020bd
TI		 2520 if (card->shutdown)
2521 goto err_unlock;
a65d629c 2522 card->shutdown = 1;
d3d020bd
TI		 2523 if (!list_empty(&card->ctl_files))
2524 goto err_clear;
2525
2526 list_for_each_entry(codec, &bus->codec_list, list) {
2527 int pcm;
2528 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2529 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2530 if (!cpcm->pcm)
2531 continue;
2532 if (cpcm->pcm->streams[0].substream_opened ||
2533 cpcm->pcm->streams[1].substream_opened)
2534 goto err_clear;
2535 }
2536 }
a65d629c
TI		 2537 spin_unlock(&card->files_lock);
2538 return 0;
d3d020bd
TI		 2539
2540 err_clear:
2541 card->shutdown = 0;
2542 err_unlock:
2543 spin_unlock(&card->files_lock);
2544 return -EINVAL;
a65d629c 2545}
d3d020bd 2546EXPORT_SYMBOL_HDA(snd_hda_lock_devices);
a65d629c 2547
d3d020bd 2548void snd_hda_unlock_devices(struct hda_bus *bus)
a65d629c 2549{
d3d020bd
TI		 2550 struct snd_card *card = bus->card;
2551
2552 card = bus->card;
a65d629c
TI		 2553 spin_lock(&card->files_lock);
2554 card->shutdown = 0;
2555 spin_unlock(&card->files_lock);
2556}
d3d020bd 2557EXPORT_SYMBOL_HDA(snd_hda_unlock_devices);
a65d629c 2558
d5191e50
TI		 2559/**
2560 * snd_hda_codec_reset - Clear all objects assigned to the codec
2561 * @codec: HD-audio codec
2562 *
2563 * This frees the all PCM and control elements assigned to the codec, and
2564 * clears the caches and restores the pin default configurations.
2565 *
2566 * When a device is being used, it returns -EBSY. If successfully freed,
2567 * returns zero.
2568 */
a65d629c
TI		 2569int snd_hda_codec_reset(struct hda_codec *codec)
2570{
d3d020bd
TI		 2571 struct hda_bus *bus = codec->bus;
2572 struct snd_card *card = bus->card;
2573 int i;
a65d629c 2574
d3d020bd 2575 if (snd_hda_lock_devices(bus) < 0)
a65d629c 2576 return -EBUSY;
a65d629c
TI		 2577
2578 /* OK, let it free */
26a6cb6c 2579 cancel_delayed_work_sync(&codec->jackpoll_work);
83012a7c 2580#ifdef CONFIG_PM
a2d96e77 2581 cancel_delayed_work_sync(&codec->power_work);
339876d7
TI		 2582 codec->power_on = 0;
2583 codec->power_transition = 0;
2584 codec->power_jiffies = jiffies;
d3d020bd 2585 flush_workqueue(bus->workq);
6c1f45ea
TI		 2586#endif
2587 snd_hda_ctls_clear(codec);
83a35e36 2588 /* release PCMs */
6c1f45ea 2589 for (i = 0; i < codec->num_pcms; i++) {
529bd6c4 2590 if (codec->pcm_info[i].pcm) {
a65d629c 2591 snd_device_free(card, codec->pcm_info[i].pcm);
529bd6c4 2592 clear_bit(codec->pcm_info[i].device,
d3d020bd 2593 bus->pcm_dev_bits);
529bd6c4 2594 }
6c1f45ea
TI		 2595 }
2596 if (codec->patch_ops.free)
2597 codec->patch_ops.free(codec);
07dc59f0 2598 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1835a0f9 2599 snd_hda_jack_tbl_clear(codec);
56d17712 2600 codec->proc_widget_hook = NULL;
6c1f45ea
TI		 2601 codec->spec = NULL;
2602 free_hda_cache(&codec->amp_cache);
2603 free_hda_cache(&codec->cmd_cache);
827057f5
TI		 2604 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2605 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
346ff70f
TI		 2606 /* free only driver_pins so that init_pins + user_pins are restored */
2607 snd_array_free(&codec->driver_pins);
09a6071b
TI		 2608 snd_array_free(&codec->cvt_setups);
2609 snd_array_free(&codec->spdif_out);
c9ce6b26 2610 snd_array_free(&codec->verbs);
6c1f45ea
TI		 2611 codec->num_pcms = 0;
2612 codec->pcm_info = NULL;
2613 codec->preset = NULL;
d1f1af2d
TI		 2614 codec->slave_dig_outs = NULL;
2615 codec->spdif_status_reset = 0;
1289e9e8
TI		 2616 module_put(codec->owner);
2617 codec->owner = NULL;
a65d629c
TI		 2618
2619 /* allow device access again */
d3d020bd 2620 snd_hda_unlock_devices(bus);
a65d629c 2621 return 0;
6c1f45ea
TI		 2622}
2623
aeb4b88e
TI		 2624typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2625
2626/* apply the function to all matching slave ctls in the mixer list */
2627static int map_slaves(struct hda_codec *codec, const char * const *slaves,
9322ca54 2628 const char *suffix, map_slave_func_t func, void *data)
aeb4b88e
TI		 2629{
2630 struct hda_nid_item *items;
2631 const char * const *s;
2632 int i, err;
2633
2634 items = codec->mixers.list;
2635 for (i = 0; i < codec->mixers.used; i++) {
2636 struct snd_kcontrol *sctl = items[i].kctl;
ca16ec02 2637 if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
aeb4b88e
TI		 2638 continue;
2639 for (s = slaves; *s; s++) {
9322ca54
TI		 2640 char tmpname[sizeof(sctl->id.name)];
2641 const char *name = *s;
2642 if (suffix) {
2643 snprintf(tmpname, sizeof(tmpname), "%s %s",
2644 name, suffix);
2645 name = tmpname;
2646 }
9322ca54 2647 if (!strcmp(sctl->id.name, name)) {
aeb4b88e
TI		 2648 err = func(data, sctl);
2649 if (err)
2650 return err;
2651 break;
2652 }
2653 }
2654 }
2655 return 0;
2656}
2657
2658static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2659{
2660 return 1;
2661}
2662
18478e8b
TI		 2663/* guess the value corresponding to 0dB */
2664static int get_kctl_0dB_offset(struct snd_kcontrol *kctl)
2665{
2666 int _tlv[4];
2667 const int *tlv = NULL;
2668 int val = -1;
2669
2670 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2671 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2672 mm_segment_t fs = get_fs();
2673 set_fs(get_ds());
2674 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2675 tlv = _tlv;
2676 set_fs(fs);
2677 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2678 tlv = kctl->tlv.p;
2679 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE)
2680 val = -tlv[2] / tlv[3];
2681 return val;
2682}
2683
2684/* call kctl->put with the given value(s) */
2685static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2686{
2687 struct snd_ctl_elem_value *ucontrol;
2688 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2689 if (!ucontrol)
2690 return -ENOMEM;
2691 ucontrol->value.integer.value[0] = val;
2692 ucontrol->value.integer.value[1] = val;
2693 kctl->put(kctl, ucontrol);
2694 kfree(ucontrol);
2695 return 0;
2696}
2697
2698/* initialize the slave volume with 0dB */
2699static int init_slave_0dB(void *data, struct snd_kcontrol *slave)
2700{
2701 int offset = get_kctl_0dB_offset(slave);
2702 if (offset > 0)
2703 put_kctl_with_value(slave, offset);
2704 return 0;
2705}
2706
2707/* unmute the slave */
2708static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2709{
2710 return put_kctl_with_value(slave, 1);
2711}
2712
d5191e50
TI		 2713/**
2714 * snd_hda_add_vmaster - create a virtual master control and add slaves
2715 * @codec: HD-audio codec
2716 * @name: vmaster control name
2717 * @tlv: TLV data (optional)
2718 * @slaves: slave control names (optional)
9322ca54 2719 * @suffix: suffix string to each slave name (optional)
18478e8b 2720 * @init_slave_vol: initialize slaves to unmute/0dB
29e5853d 2721 * @ctl_ret: store the vmaster kcontrol in return
d5191e50
TI		 2722 *
2723 * Create a virtual master control with the given name. The TLV data
2724 * must be either NULL or a valid data.
2725 *
2726 * @slaves is a NULL-terminated array of strings, each of which is a
2727 * slave control name. All controls with these names are assigned to
2728 * the new virtual master control.
2729 *
2730 * This function returns zero if successful or a negative error code.
2731 */
18478e8b 2732int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
9322ca54 2733 unsigned int *tlv, const char * const *slaves,
29e5853d
TI		 2734 const char *suffix, bool init_slave_vol,
2735 struct snd_kcontrol **ctl_ret)
2134ea4f
TI		 2736{
2737 struct snd_kcontrol *kctl;
2134ea4f
TI		 2738 int err;
2739
29e5853d
TI		 2740 if (ctl_ret)
2741 *ctl_ret = NULL;
2742
9322ca54 2743 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
aeb4b88e 2744 if (err != 1) {
2f085549
TI		 2745 snd_printdd("No slave found for %s\n", name);
2746 return 0;
2747 }
2134ea4f
TI		 2748 kctl = snd_ctl_make_virtual_master(name, tlv);
2749 if (!kctl)
2750 return -ENOMEM;
3911a4c1 2751 err = snd_hda_ctl_add(codec, 0, kctl);
2134ea4f
TI		 2752 if (err < 0)
2753 return err;
28aedaf7 2754
9322ca54
TI		 2755 err = map_slaves(codec, slaves, suffix,
2756 (map_slave_func_t)snd_ctl_add_slave, kctl);
aeb4b88e
TI		 2757 if (err < 0)
2758 return err;
18478e8b
TI		 2759
2760 /* init with master mute & zero volume */
2761 put_kctl_with_value(kctl, 0);
2762 if (init_slave_vol)
2763 map_slaves(codec, slaves, suffix,
2764 tlv ? init_slave_0dB : init_slave_unmute, kctl);
2765
29e5853d
TI		 2766 if (ctl_ret)
2767 *ctl_ret = kctl;
2134ea4f
TI		 2768 return 0;
2769}
18478e8b 2770EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
2134ea4f 2771
d2f344b5
TI		 2772/*
2773 * mute-LED control using vmaster
2774 */
2775static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2776 struct snd_ctl_elem_info *uinfo)
2777{
2778 static const char * const texts[] = {
c86c2d44 2779 "On", "Off", "Follow Master"
d2f344b5
TI		 2780 };
2781 unsigned int index;
2782
2783 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2784 uinfo->count = 1;
2785 uinfo->value.enumerated.items = 3;
2786 index = uinfo->value.enumerated.item;
2787 if (index >= 3)
2788 index = 2;
2789 strcpy(uinfo->value.enumerated.name, texts[index]);
2790 return 0;
2791}
2792
2793static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2794 struct snd_ctl_elem_value *ucontrol)
2795{
2796 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2797 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2798 return 0;
2799}
2800
2801static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2802 struct snd_ctl_elem_value *ucontrol)
2803{
2804 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2805 unsigned int old_mode = hook->mute_mode;
2806
2807 hook->mute_mode = ucontrol->value.enumerated.item[0];
2808 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2809 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2810 if (old_mode == hook->mute_mode)
2811 return 0;
2812 snd_hda_sync_vmaster_hook(hook);
2813 return 1;
2814}
2815
2816static struct snd_kcontrol_new vmaster_mute_mode = {
2817 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2818 .name = "Mute-LED Mode",
2819 .info = vmaster_mute_mode_info,
2820 .get = vmaster_mute_mode_get,
2821 .put = vmaster_mute_mode_put,
2822};
2823
2824/*
2825 * Add a mute-LED hook with the given vmaster switch kctl
2826 * "Mute-LED Mode" control is automatically created and associated with
2827 * the given hook.
2828 */
2829int snd_hda_add_vmaster_hook(struct hda_codec *codec,
f29735cb
TI		 2830 struct hda_vmaster_mute_hook *hook,
2831 bool expose_enum_ctl)
d2f344b5
TI		 2832{
2833 struct snd_kcontrol *kctl;
2834
2835 if (!hook->hook || !hook->sw_kctl)
2836 return 0;
2837 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2838 hook->codec = codec;
2839 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
f29735cb
TI		 2840 if (!expose_enum_ctl)
2841 return 0;
d2f344b5
TI		 2842 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2843 if (!kctl)
2844 return -ENOMEM;
2845 return snd_hda_ctl_add(codec, 0, kctl);
2846}
2847EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
2848
2849/*
2850 * Call the hook with the current value for synchronization
2851 * Should be called in init callback
2852 */
2853void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2854{
2855 if (!hook->hook || !hook->codec)
2856 return;
594813ff
TI		 2857 /* don't call vmaster hook in the destructor since it might have
2858 * been already destroyed
2859 */
2860 if (hook->codec->bus->shutdown)
2861 return;
d2f344b5
TI		 2862 switch (hook->mute_mode) {
2863 case HDA_VMUTE_FOLLOW_MASTER:
2864 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2865 break;
2866 default:
2867 hook->hook(hook->codec, hook->mute_mode);
2868 break;
2869 }
2870}
2871EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
2872
2873
d5191e50
TI		 2874/**
2875 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2876 *
2877 * The control element is supposed to have the private_value field
2878 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2879 */
0ba21762
TI		 2880int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2881 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 2882{
2883 int chs = get_amp_channels(kcontrol);
2884
2885 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2886 uinfo->count = chs == 3 ? 2 : 1;
2887 uinfo->value.integer.min = 0;
2888 uinfo->value.integer.max = 1;
2889 return 0;
2890}
ff7a3267 2891EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1da177e4 2892
d5191e50
TI		 2893/**
2894 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2895 *
2896 * The control element is supposed to have the private_value field
2897 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2898 */
0ba21762
TI		 2899int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2900 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2901{
2902 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2903 hda_nid_t nid = get_amp_nid(kcontrol);
2904 int chs = get_amp_channels(kcontrol);
2905 int dir = get_amp_direction(kcontrol);
2906 int idx = get_amp_index(kcontrol);
2907 long *valp = ucontrol->value.integer.value;
2908
2909 if (chs & 1)
0ba21762 2910 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
47fd830a 2911 HDA_AMP_MUTE) ? 0 : 1;
1da177e4 2912 if (chs & 2)
0ba21762 2913 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
47fd830a 2914 HDA_AMP_MUTE) ? 0 : 1;
1da177e4
LT		 2915 return 0;
2916}
ff7a3267 2917EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1da177e4 2918
d5191e50
TI		 2919/**
2920 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2921 *
2922 * The control element is supposed to have the private_value field
2923 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2924 */
0ba21762
TI		 2925int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2926 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2927{
2928 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2929 hda_nid_t nid = get_amp_nid(kcontrol);
2930 int chs = get_amp_channels(kcontrol);
2931 int dir = get_amp_direction(kcontrol);
2932 int idx = get_amp_index(kcontrol);
1da177e4
LT		 2933 long *valp = ucontrol->value.integer.value;
2934 int change = 0;
2935
cb53c626 2936 snd_hda_power_up(codec);
b9f5a89c 2937 if (chs & 1) {
4a19faee 2938 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
47fd830a
TI		 2939 HDA_AMP_MUTE,
2940 *valp ? 0 : HDA_AMP_MUTE);
b9f5a89c
NG		 2941 valp++;
2942 }
4a19faee
TI		 2943 if (chs & 2)
2944 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
47fd830a
TI		 2945 HDA_AMP_MUTE,
2946 *valp ? 0 : HDA_AMP_MUTE);
9e5341b9 2947 hda_call_check_power_status(codec, nid);
cb53c626 2948 snd_hda_power_down(codec);
1da177e4
LT		 2949 return change;
2950}
ff7a3267 2951EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1da177e4 2952
985be54b
TI		 2953/*
2954 * bound volume controls
2955 *
2956 * bind multiple volumes (# indices, from 0)
2957 */
2958
2959#define AMP_VAL_IDX_SHIFT 19
2960#define AMP_VAL_IDX_MASK (0x0f<<19)
2961
d5191e50
TI		 2962/**
2963 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2964 *
2965 * The control element is supposed to have the private_value field
2966 * set up via HDA_BIND_MUTE*() macros.
2967 */
0ba21762
TI		 2968int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2969 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 2970{
2971 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2972 unsigned long pval;
2973 int err;
2974
5a9e02e9 2975 mutex_lock(&codec->control_mutex);
985be54b
TI		 2976 pval = kcontrol->private_value;
2977 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2978 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2979 kcontrol->private_value = pval;
5a9e02e9 2980 mutex_unlock(&codec->control_mutex);
985be54b
TI		 2981 return err;
2982}
ff7a3267 2983EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
985be54b 2984
d5191e50
TI		 2985/**
2986 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2987 *
2988 * The control element is supposed to have the private_value field
2989 * set up via HDA_BIND_MUTE*() macros.
2990 */
0ba21762
TI		 2991int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2992 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 2993{
2994 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2995 unsigned long pval;
2996 int i, indices, err = 0, change = 0;
2997
5a9e02e9 2998 mutex_lock(&codec->control_mutex);
985be54b
TI		 2999 pval = kcontrol->private_value;
3000 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
3001 for (i = 0; i < indices; i++) {
0ba21762
TI		 3002 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
3003 (i << AMP_VAL_IDX_SHIFT);
985be54b
TI		 3004 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3005 if (err < 0)
3006 break;
3007 change |= err;
3008 }
3009 kcontrol->private_value = pval;
5a9e02e9 3010 mutex_unlock(&codec->control_mutex);
985be54b
TI		 3011 return err < 0 ? err : change;
3012}
ff7a3267 3013EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
985be54b 3014
d5191e50
TI		 3015/**
3016 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
3017 *
3018 * The control element is supposed to have the private_value field
3019 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
532d5381
TI		 3020 */
3021int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
3022 struct snd_ctl_elem_info *uinfo)
3023{
3024 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3025 struct hda_bind_ctls *c;
3026 int err;
3027
5a9e02e9 3028 mutex_lock(&codec->control_mutex);
14c65f98 3029 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 3030 kcontrol->private_value = *c->values;
3031 err = c->ops->info(kcontrol, uinfo);
3032 kcontrol->private_value = (long)c;
5a9e02e9 3033 mutex_unlock(&codec->control_mutex);
532d5381
TI		 3034 return err;
3035}
ff7a3267 3036EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
532d5381 3037
d5191e50
TI		 3038/**
3039 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
3040 *
3041 * The control element is supposed to have the private_value field
3042 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
3043 */
532d5381
TI		 3044int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
3045 struct snd_ctl_elem_value *ucontrol)
3046{
3047 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3048 struct hda_bind_ctls *c;
3049 int err;
3050
5a9e02e9 3051 mutex_lock(&codec->control_mutex);
14c65f98 3052 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 3053 kcontrol->private_value = *c->values;
3054 err = c->ops->get(kcontrol, ucontrol);
3055 kcontrol->private_value = (long)c;
5a9e02e9 3056 mutex_unlock(&codec->control_mutex);
532d5381
TI		 3057 return err;
3058}
ff7a3267 3059EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
532d5381 3060
d5191e50
TI		 3061/**
3062 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
3063 *
3064 * The control element is supposed to have the private_value field
3065 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
3066 */
532d5381
TI		 3067int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
3068 struct snd_ctl_elem_value *ucontrol)
3069{
3070 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3071 struct hda_bind_ctls *c;
3072 unsigned long *vals;
3073 int err = 0, change = 0;
3074
5a9e02e9 3075 mutex_lock(&codec->control_mutex);
14c65f98 3076 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 3077 for (vals = c->values; *vals; vals++) {
3078 kcontrol->private_value = *vals;
3079 err = c->ops->put(kcontrol, ucontrol);
3080 if (err < 0)
3081 break;
3082 change |= err;
3083 }
3084 kcontrol->private_value = (long)c;
5a9e02e9 3085 mutex_unlock(&codec->control_mutex);
532d5381
TI		 3086 return err < 0 ? err : change;
3087}
ff7a3267 3088EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
532d5381 3089
d5191e50
TI		 3090/**
3091 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
3092 *
3093 * The control element is supposed to have the private_value field
3094 * set up via HDA_BIND_VOL() macro.
3095 */
532d5381
TI		 3096int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
3097 unsigned int size, unsigned int __user *tlv)
3098{
3099 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3100 struct hda_bind_ctls *c;
3101 int err;
3102
5a9e02e9 3103 mutex_lock(&codec->control_mutex);
14c65f98 3104 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 3105 kcontrol->private_value = *c->values;
3106 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
3107 kcontrol->private_value = (long)c;
5a9e02e9 3108 mutex_unlock(&codec->control_mutex);
532d5381
TI		 3109 return err;
3110}
ff7a3267 3111EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
532d5381
TI		 3112
3113struct hda_ctl_ops snd_hda_bind_vol = {
3114 .info = snd_hda_mixer_amp_volume_info,
3115 .get = snd_hda_mixer_amp_volume_get,
3116 .put = snd_hda_mixer_amp_volume_put,
3117 .tlv = snd_hda_mixer_amp_tlv
3118};
ff7a3267 3119EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
532d5381
TI		 3120
3121struct hda_ctl_ops snd_hda_bind_sw = {
3122 .info = snd_hda_mixer_amp_switch_info,
3123 .get = snd_hda_mixer_amp_switch_get,
3124 .put = snd_hda_mixer_amp_switch_put,
3125 .tlv = snd_hda_mixer_amp_tlv
3126};
ff7a3267 3127EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
532d5381 3128
1da177e4
LT		 3129/*
3130 * SPDIF out controls
3131 */
3132
0ba21762
TI		 3133static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
3134 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 3135{
3136 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
3137 uinfo->count = 1;
3138 return 0;
3139}
3140
0ba21762
TI		 3141static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
3142 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3143{
3144 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3145 IEC958_AES0_NONAUDIO |
3146 IEC958_AES0_CON_EMPHASIS_5015 |
3147 IEC958_AES0_CON_NOT_COPYRIGHT;
3148 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
3149 IEC958_AES1_CON_ORIGINAL;
3150 return 0;
3151}
3152
0ba21762
TI		 3153static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
3154 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3155{
3156 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3157 IEC958_AES0_NONAUDIO |
3158 IEC958_AES0_PRO_EMPHASIS_5015;
3159 return 0;
3160}
3161
0ba21762
TI		 3162static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
3163 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3164{
3165 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 3166 int idx = kcontrol->private_value;
e3245cdd 3167 struct hda_spdif_out *spdif;
1da177e4 3168
e3245cdd
TI		 3169 mutex_lock(&codec->spdif_mutex);
3170 spdif = snd_array_elem(&codec->spdif_out, idx);
7c935976
SW		 3171 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
3172 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
3173 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
3174 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
e3245cdd 3175 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3176
3177 return 0;
3178}
3179
3180/* convert from SPDIF status bits to HDA SPDIF bits
3181 * bit 0 (DigEn) is always set zero (to be filled later)
3182 */
3183static unsigned short convert_from_spdif_status(unsigned int sbits)
3184{
3185 unsigned short val = 0;
3186
3187 if (sbits & IEC958_AES0_PROFESSIONAL)
0ba21762 3188 val |= AC_DIG1_PROFESSIONAL;
1da177e4 3189 if (sbits & IEC958_AES0_NONAUDIO)
0ba21762 3190 val |= AC_DIG1_NONAUDIO;
1da177e4 3191 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762
TI		 3192 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
3193 IEC958_AES0_PRO_EMPHASIS_5015)
3194 val |= AC_DIG1_EMPHASIS;
1da177e4 3195 } else {
0ba21762
TI		 3196 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
3197 IEC958_AES0_CON_EMPHASIS_5015)
3198 val |= AC_DIG1_EMPHASIS;
3199 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
3200 val |= AC_DIG1_COPYRIGHT;
1da177e4 3201 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
0ba21762 3202 val |= AC_DIG1_LEVEL;
1da177e4
LT		 3203 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
3204 }
3205 return val;
3206}
3207
3208/* convert to SPDIF status bits from HDA SPDIF bits
3209 */
3210static unsigned int convert_to_spdif_status(unsigned short val)
3211{
3212 unsigned int sbits = 0;
3213
0ba21762 3214 if (val & AC_DIG1_NONAUDIO)
1da177e4 3215 sbits |= IEC958_AES0_NONAUDIO;
0ba21762 3216 if (val & AC_DIG1_PROFESSIONAL)
1da177e4
LT		 3217 sbits |= IEC958_AES0_PROFESSIONAL;
3218 if (sbits & IEC958_AES0_PROFESSIONAL) {
a686fd14 3219 if (val & AC_DIG1_EMPHASIS)
1da177e4
LT		 3220 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
3221 } else {
0ba21762 3222 if (val & AC_DIG1_EMPHASIS)
1da177e4 3223 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
0ba21762 3224 if (!(val & AC_DIG1_COPYRIGHT))
1da177e4 3225 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
0ba21762 3226 if (val & AC_DIG1_LEVEL)
1da177e4
LT		 3227 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
3228 sbits |= val & (0x7f << 8);
3229 }
3230 return sbits;
3231}
3232
2f72853c
TI		 3233/* set digital convert verbs both for the given NID and its slaves */
3234static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
3235 int verb, int val)
3236{
dda14410 3237 const hda_nid_t *d;
2f72853c 3238
9e976976 3239 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2f72853c
TI		 3240 d = codec->slave_dig_outs;
3241 if (!d)
3242 return;
3243 for (; *d; d++)
9e976976 3244 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2f72853c
TI		 3245}
3246
3247static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
3248 int dig1, int dig2)
3249{
3250 if (dig1 != -1)
3251 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
3252 if (dig2 != -1)
3253 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
3254}
3255
0ba21762
TI		 3256static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
3257 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3258{
3259 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 3260 int idx = kcontrol->private_value;
e3245cdd
TI		 3261 struct hda_spdif_out *spdif;
3262 hda_nid_t nid;
1da177e4
LT		 3263 unsigned short val;
3264 int change;
3265
62932df8 3266 mutex_lock(&codec->spdif_mutex);
e3245cdd
TI		 3267 spdif = snd_array_elem(&codec->spdif_out, idx);
3268 nid = spdif->nid;
7c935976 3269 spdif->status = ucontrol->value.iec958.status[0] |
1da177e4
LT		 3270 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
3271 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
3272 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
7c935976
SW		 3273 val = convert_from_spdif_status(spdif->status);
3274 val |= spdif->ctls & 1;
3275 change = spdif->ctls != val;
3276 spdif->ctls = val;
74b654c9 3277 if (change && nid != (u16)-1)
2f72853c 3278 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
62932df8 3279 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3280 return change;
3281}
3282
a5ce8890 3283#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1da177e4 3284
0ba21762
TI		 3285static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3286 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3287{
3288 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 3289 int idx = kcontrol->private_value;
e3245cdd 3290 struct hda_spdif_out *spdif;
1da177e4 3291
e3245cdd
TI		 3292 mutex_lock(&codec->spdif_mutex);
3293 spdif = snd_array_elem(&codec->spdif_out, idx);
7c935976 3294 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
e3245cdd 3295 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3296 return 0;
3297}
3298
74b654c9
SW		 3299static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3300 int dig1, int dig2)
3301{
3302 set_dig_out_convert(codec, nid, dig1, dig2);
3303 /* unmute amp switch (if any) */
3304 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3305 (dig1 & AC_DIG1_ENABLE))
3306 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3307 HDA_AMP_MUTE, 0);
3308}
3309
0ba21762
TI		 3310static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3311 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3312{
3313 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 3314 int idx = kcontrol->private_value;
e3245cdd
TI		 3315 struct hda_spdif_out *spdif;
3316 hda_nid_t nid;
1da177e4
LT		 3317 unsigned short val;
3318 int change;
3319
62932df8 3320 mutex_lock(&codec->spdif_mutex);
e3245cdd
TI		 3321 spdif = snd_array_elem(&codec->spdif_out, idx);
3322 nid = spdif->nid;
7c935976 3323 val = spdif->ctls & ~AC_DIG1_ENABLE;
1da177e4 3324 if (ucontrol->value.integer.value[0])
0ba21762 3325 val |= AC_DIG1_ENABLE;
7c935976 3326 change = spdif->ctls != val;
74b654c9
SW		 3327 spdif->ctls = val;
3328 if (change && nid != (u16)-1)
3329 set_spdif_ctls(codec, nid, val & 0xff, -1);
62932df8 3330 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3331 return change;
3332}
3333
c8b6bf9b 3334static struct snd_kcontrol_new dig_mixes[] = {
1da177e4
LT		 3335 {
3336 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3337 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3338 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
1da177e4
LT		 3339 .info = snd_hda_spdif_mask_info,
3340 .get = snd_hda_spdif_cmask_get,
3341 },
3342 {
3343 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3344 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3345 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
1da177e4
LT		 3346 .info = snd_hda_spdif_mask_info,
3347 .get = snd_hda_spdif_pmask_get,
3348 },
3349 {
3350 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3351 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1da177e4
LT		 3352 .info = snd_hda_spdif_mask_info,
3353 .get = snd_hda_spdif_default_get,
3354 .put = snd_hda_spdif_default_put,
3355 },
3356 {
3357 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3358 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1da177e4
LT		 3359 .info = snd_hda_spdif_out_switch_info,
3360 .get = snd_hda_spdif_out_switch_get,
3361 .put = snd_hda_spdif_out_switch_put,
3362 },
3363 { } /* end */
3364};
3365
3366/**
dcda5806 3367 * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
1da177e4 3368 * @codec: the HDA codec
dcda5806
TI		 3369 * @associated_nid: NID that new ctls associated with
3370 * @cvt_nid: converter NID
3371 * @type: HDA_PCM_TYPE_*
3372 * Creates controls related with the digital output.
3373 * Called from each patch supporting the digital out.
1da177e4
LT		 3374 *
3375 * Returns 0 if successful, or a negative error code.
3376 */
dcda5806
TI		 3377int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
3378 hda_nid_t associated_nid,
3379 hda_nid_t cvt_nid,
3380 int type)
1da177e4
LT		 3381{
3382 int err;
c8b6bf9b
TI		 3383 struct snd_kcontrol *kctl;
3384 struct snd_kcontrol_new *dig_mix;
ea9b43ad
TI		 3385 int idx = 0;
3386 const int spdif_index = 16;
7c935976 3387 struct hda_spdif_out *spdif;
ea9b43ad 3388 struct hda_bus *bus = codec->bus;
1da177e4 3389
ea9b43ad 3390 if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
dcda5806 3391 type == HDA_PCM_TYPE_SPDIF) {
ea9b43ad
TI		 3392 idx = spdif_index;
3393 } else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
dcda5806 3394 type == HDA_PCM_TYPE_HDMI) {
ea9b43ad
TI		 3395 /* suppose a single SPDIF device */
3396 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3397 kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
3398 if (!kctl)
3399 break;
3400 kctl->id.index = spdif_index;
dcda5806 3401 }
ea9b43ad 3402 bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
dcda5806 3403 }
ea9b43ad
TI		 3404 if (!bus->primary_dig_out_type)
3405 bus->primary_dig_out_type = type;
dcda5806 3406
ea9b43ad 3407 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
1afe206a 3408 if (idx < 0) {
09f99701
TI		 3409 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3410 return -EBUSY;
3411 }
7c935976 3412 spdif = snd_array_new(&codec->spdif_out);
25336e8a
ML		 3413 if (!spdif)
3414 return -ENOMEM;
1da177e4
LT		 3415 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3416 kctl = snd_ctl_new1(dig_mix, codec);
b91f080f
TI		 3417 if (!kctl)
3418 return -ENOMEM;
09f99701 3419 kctl->id.index = idx;
7c935976 3420 kctl->private_value = codec->spdif_out.used - 1;
74b654c9 3421 err = snd_hda_ctl_add(codec, associated_nid, kctl);
0ba21762 3422 if (err < 0)
1da177e4
LT		 3423 return err;
3424 }
74b654c9
SW		 3425 spdif->nid = cvt_nid;
3426 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
7c935976
SW		 3427 AC_VERB_GET_DIGI_CONVERT_1, 0);
3428 spdif->status = convert_to_spdif_status(spdif->ctls);
1da177e4
LT		 3429 return 0;
3430}
dcda5806 3431EXPORT_SYMBOL_HDA(snd_hda_create_dig_out_ctls);
1da177e4 3432
e3245cdd
TI		 3433/* get the hda_spdif_out entry from the given NID
3434 * call within spdif_mutex lock
3435 */
7c935976
SW		 3436struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3437 hda_nid_t nid)
3438{
3439 int i;
3440 for (i = 0; i < codec->spdif_out.used; i++) {
3441 struct hda_spdif_out *spdif =
3442 snd_array_elem(&codec->spdif_out, i);
3443 if (spdif->nid == nid)
3444 return spdif;
3445 }
3446 return NULL;
3447}
3448EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3449
74b654c9
SW		 3450void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3451{
e3245cdd 3452 struct hda_spdif_out *spdif;
74b654c9
SW		 3453
3454 mutex_lock(&codec->spdif_mutex);
e3245cdd 3455 spdif = snd_array_elem(&codec->spdif_out, idx);
74b654c9
SW		 3456 spdif->nid = (u16)-1;
3457 mutex_unlock(&codec->spdif_mutex);
3458}
3459EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3460
3461void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3462{
e3245cdd 3463 struct hda_spdif_out *spdif;
74b654c9
SW		 3464 unsigned short val;
3465
3466 mutex_lock(&codec->spdif_mutex);
e3245cdd 3467 spdif = snd_array_elem(&codec->spdif_out, idx);
74b654c9
SW		 3468 if (spdif->nid != nid) {
3469 spdif->nid = nid;
3470 val = spdif->ctls;
3471 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3472 }
3473 mutex_unlock(&codec->spdif_mutex);
3474}
3475EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3476
9a08160b
TI		 3477/*
3478 * SPDIF sharing with analog output
3479 */
3480static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3481 struct snd_ctl_elem_value *ucontrol)
3482{
3483 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3484 ucontrol->value.integer.value[0] = mout->share_spdif;
3485 return 0;
3486}
3487
3488static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3489 struct snd_ctl_elem_value *ucontrol)
3490{
3491 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3492 mout->share_spdif = !!ucontrol->value.integer.value[0];
3493 return 0;
3494}
3495
3496static struct snd_kcontrol_new spdif_share_sw = {
3497 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3498 .name = "IEC958 Default PCM Playback Switch",
3499 .info = snd_ctl_boolean_mono_info,
3500 .get = spdif_share_sw_get,
3501 .put = spdif_share_sw_put,
3502};
3503
d5191e50
TI		 3504/**
3505 * snd_hda_create_spdif_share_sw - create Default PCM switch
3506 * @codec: the HDA codec
3507 * @mout: multi-out instance
3508 */
9a08160b
TI		 3509int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3510 struct hda_multi_out *mout)
3511{
4c7a548a
ML		 3512 struct snd_kcontrol *kctl;
3513
9a08160b
TI		 3514 if (!mout->dig_out_nid)
3515 return 0;
4c7a548a
ML		 3516
3517 kctl = snd_ctl_new1(&spdif_share_sw, mout);
3518 if (!kctl)
3519 return -ENOMEM;
9a08160b 3520 /* ATTENTION: here mout is passed as private_data, instead of codec */
4c7a548a 3521 return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
9a08160b 3522}
ff7a3267 3523EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
9a08160b 3524
1da177e4
LT		 3525/*
3526 * SPDIF input
3527 */
3528
3529#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3530
0ba21762
TI		 3531static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3532 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3533{
3534 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3535
3536 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3537 return 0;
3538}
3539
0ba21762
TI		 3540static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3541 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3542{
3543 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3544 hda_nid_t nid = kcontrol->private_value;
3545 unsigned int val = !!ucontrol->value.integer.value[0];
3546 int change;
3547
62932df8 3548 mutex_lock(&codec->spdif_mutex);
1da177e4 3549 change = codec->spdif_in_enable != val;
82beb8fd 3550 if (change) {
1da177e4 3551 codec->spdif_in_enable = val;
82beb8fd
TI		 3552 snd_hda_codec_write_cache(codec, nid, 0,
3553 AC_VERB_SET_DIGI_CONVERT_1, val);
1da177e4 3554 }
62932df8 3555 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3556 return change;
3557}
3558
0ba21762
TI		 3559static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3560 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3561{
3562 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3563 hda_nid_t nid = kcontrol->private_value;
3564 unsigned short val;
3565 unsigned int sbits;
3566
3982d17e 3567 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1da177e4
LT		 3568 sbits = convert_to_spdif_status(val);
3569 ucontrol->value.iec958.status[0] = sbits;
3570 ucontrol->value.iec958.status[1] = sbits >> 8;
3571 ucontrol->value.iec958.status[2] = sbits >> 16;
3572 ucontrol->value.iec958.status[3] = sbits >> 24;
3573 return 0;
3574}
3575
c8b6bf9b 3576static struct snd_kcontrol_new dig_in_ctls[] = {
1da177e4
LT		 3577 {
3578 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3579 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
1da177e4
LT		 3580 .info = snd_hda_spdif_in_switch_info,
3581 .get = snd_hda_spdif_in_switch_get,
3582 .put = snd_hda_spdif_in_switch_put,
3583 },
3584 {
3585 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3586 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3587 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
1da177e4
LT		 3588 .info = snd_hda_spdif_mask_info,
3589 .get = snd_hda_spdif_in_status_get,
3590 },
3591 { } /* end */
3592};
3593
3594/**
3595 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3596 * @codec: the HDA codec
3597 * @nid: audio in widget NID
3598 *
3599 * Creates controls related with the SPDIF input.
3600 * Called from each patch supporting the SPDIF in.
3601 *
3602 * Returns 0 if successful, or a negative error code.
3603 */
12f288bf 3604int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1da177e4
LT		 3605{
3606 int err;
c8b6bf9b
TI		 3607 struct snd_kcontrol *kctl;
3608 struct snd_kcontrol_new *dig_mix;
09f99701 3609 int idx;
1da177e4 3610
dcda5806 3611 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
1afe206a 3612 if (idx < 0) {
09f99701
TI		 3613 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3614 return -EBUSY;
3615 }
1da177e4
LT		 3616 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3617 kctl = snd_ctl_new1(dig_mix, codec);
c8dcdf82
TI		 3618 if (!kctl)
3619 return -ENOMEM;
1da177e4 3620 kctl->private_value = nid;
3911a4c1 3621 err = snd_hda_ctl_add(codec, nid, kctl);
0ba21762 3622 if (err < 0)
1da177e4
LT		 3623 return err;
3624 }
0ba21762 3625 codec->spdif_in_enable =
3982d17e
AP		 3626 snd_hda_codec_read(codec, nid, 0,
3627 AC_VERB_GET_DIGI_CONVERT_1, 0) &
0ba21762 3628 AC_DIG1_ENABLE;
1da177e4
LT		 3629 return 0;
3630}
ff7a3267 3631EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
1da177e4 3632
82beb8fd
TI		 3633/*
3634 * command cache
3635 */
1da177e4 3636
c370dd6e 3637/* build a 31bit cache key with the widget id and the command parameter */
b3ac5636
TI		 3638#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3639#define get_cmd_cache_nid(key) ((key) & 0xff)
3640#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3641
3642/**
3643 * snd_hda_codec_write_cache - send a single command with caching
3644 * @codec: the HDA codec
3645 * @nid: NID to send the command
e7ecc27e 3646 * @flags: optional bit flags
b3ac5636
TI		 3647 * @verb: the verb to send
3648 * @parm: the parameter for the verb
3649 *
3650 * Send a single command without waiting for response.
3651 *
3652 * Returns 0 if successful, or a negative error code.
3653 */
3654int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
e7ecc27e 3655 int flags, unsigned int verb, unsigned int parm)
b3ac5636 3656{
c370dd6e 3657 int err;
aa2936f5
TI		 3658 struct hda_cache_head *c;
3659 u32 key;
de1e37b7 3660 unsigned int cache_only;
33fa35ed 3661
de1e37b7
TI		 3662 cache_only = codec->cached_write;
3663 if (!cache_only) {
e7ecc27e 3664 err = snd_hda_codec_write(codec, nid, flags, verb, parm);
c370dd6e
TI		 3665 if (err < 0)
3666 return err;
3667 }
3668
aa2936f5
TI		 3669 /* parm may contain the verb stuff for get/set amp */
3670 verb = verb | (parm >> 8);
3671 parm &= 0xff;
3672 key = build_cmd_cache_key(nid, verb);
3673 mutex_lock(&codec->bus->cmd_mutex);
3674 c = get_alloc_hash(&codec->cmd_cache, key);
c370dd6e 3675 if (c) {
aa2936f5 3676 c->val = parm;
de1e37b7 3677 c->dirty = cache_only;
c370dd6e 3678 }
aa2936f5
TI		 3679 mutex_unlock(&codec->bus->cmd_mutex);
3680 return 0;
b3ac5636 3681}
ff7a3267 3682EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
b3ac5636 3683
a68d5a54
TI		 3684/**
3685 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3686 * @codec: the HDA codec
3687 * @nid: NID to send the command
e7ecc27e 3688 * @flags: optional bit flags
a68d5a54
TI		 3689 * @verb: the verb to send
3690 * @parm: the parameter for the verb
3691 *
3692 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3693 * command if the parameter is already identical with the cached value.
3694 * If not, it sends the command and refreshes the cache.
3695 *
3696 * Returns 0 if successful, or a negative error code.
3697 */
3698int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
e7ecc27e 3699 int flags, unsigned int verb, unsigned int parm)
a68d5a54
TI		 3700{
3701 struct hda_cache_head *c;
3702 u32 key;
3703
3704 /* parm may contain the verb stuff for get/set amp */
3705 verb = verb | (parm >> 8);
3706 parm &= 0xff;
3707 key = build_cmd_cache_key(nid, verb);
3708 mutex_lock(&codec->bus->cmd_mutex);
3709 c = get_hash(&codec->cmd_cache, key);
3710 if (c && c->val == parm) {
3711 mutex_unlock(&codec->bus->cmd_mutex);
3712 return 0;
3713 }
3714 mutex_unlock(&codec->bus->cmd_mutex);
e7ecc27e 3715 return snd_hda_codec_write_cache(codec, nid, flags, verb, parm);
a68d5a54
TI		 3716}
3717EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3718
d5191e50
TI		 3719/**
3720 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3721 * @codec: HD-audio codec
3722 *
3723 * Execute all verbs recorded in the command caches to resume.
3724 */
b3ac5636
TI		 3725void snd_hda_codec_resume_cache(struct hda_codec *codec)
3726{
b3ac5636
TI		 3727 int i;
3728
c370dd6e 3729 mutex_lock(&codec->hash_mutex);
aa88a355 3730 codec->cached_write = 0;
c370dd6e
TI		 3731 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3732 struct hda_cache_head *buffer;
3733 u32 key;
3734
3735 buffer = snd_array_elem(&codec->cmd_cache.buf, i);
3736 key = buffer->key;
b3ac5636
TI		 3737 if (!key)
3738 continue;
c370dd6e
TI		 3739 if (!buffer->dirty)
3740 continue;
3741 buffer->dirty = 0;
3742 mutex_unlock(&codec->hash_mutex);
b3ac5636
TI		 3743 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3744 get_cmd_cache_cmd(key), buffer->val);
c370dd6e 3745 mutex_lock(&codec->hash_mutex);
b3ac5636 3746 }
c370dd6e 3747 mutex_unlock(&codec->hash_mutex);
b3ac5636 3748}
ff7a3267 3749EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
b3ac5636
TI		 3750
3751/**
3752 * snd_hda_sequence_write_cache - sequence writes with caching
3753 * @codec: the HDA codec
3754 * @seq: VERB array to send
3755 *
3756 * Send the commands sequentially from the given array.
3757 * Thte commands are recorded on cache for power-save and resume.
3758 * The array must be terminated with NID=0.
3759 */
3760void snd_hda_sequence_write_cache(struct hda_codec *codec,
3761 const struct hda_verb *seq)
3762{
3763 for (; seq->nid; seq++)
3764 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3765 seq->param);
3766}
ff7a3267 3767EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
b3ac5636 3768
dc870f38
TI		 3769/**
3770 * snd_hda_codec_flush_cache - Execute all pending (cached) amps / verbs
3771 * @codec: HD-audio codec
3772 */
3773void snd_hda_codec_flush_cache(struct hda_codec *codec)
3774{
3775 snd_hda_codec_resume_amp(codec);
3776 snd_hda_codec_resume_cache(codec);
3777}
3778EXPORT_SYMBOL_HDA(snd_hda_codec_flush_cache);
3779
4d7fbdbc 3780void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
9419ab6b 3781 unsigned int power_state)
54d17403 3782{
4d7fbdbc 3783 hda_nid_t nid = codec->start_nid;
cb53c626 3784 int i;
54d17403 3785
cb53c626 3786 for (i = 0; i < codec->num_nodes; i++, nid++) {
7eba5c9d 3787 unsigned int wcaps = get_wcaps(codec, nid);
9419ab6b 3788 unsigned int state = power_state;
4d7fbdbc
TI		 3789 if (!(wcaps & AC_WCAP_POWER))
3790 continue;
9419ab6b
TI		 3791 if (codec->power_filter) {
3792 state = codec->power_filter(codec, nid, power_state);
3793 if (state != power_state && power_state == AC_PWRST_D3)
4d7fbdbc 3794 continue;
1194b5b7 3795 }
4d7fbdbc 3796 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
9419ab6b 3797 state);
54d17403 3798 }
cb53c626 3799}
4d7fbdbc
TI		 3800EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3801
0c7f46ad
WX		 3802/*
3803 * supported power states check
3804 */
3805static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
3806 unsigned int power_state)
3807{
3808 int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
3809
e037cb4a 3810 if (sup == -1)
0c7f46ad
WX		 3811 return false;
3812 if (sup & power_state)
3813 return true;
3814 else
3815 return false;
3816}
3817
432c641e
TI		 3818/*
3819 * wait until the state is reached, returns the current state
3820 */
3821static unsigned int hda_sync_power_state(struct hda_codec *codec,
3822 hda_nid_t fg,
3823 unsigned int power_state)
3824{
3825 unsigned long end_time = jiffies + msecs_to_jiffies(500);
3826 unsigned int state, actual_state;
3827
3828 for (;;) {
3829 state = snd_hda_codec_read(codec, fg, 0,
3830 AC_VERB_GET_POWER_STATE, 0);
3831 if (state & AC_PWRST_ERROR)
3832 break;
3833 actual_state = (state >> 4) & 0x0f;
3834 if (actual_state == power_state)
3835 break;
3836 if (time_after_eq(jiffies, end_time))
3837 break;
3838 /* wait until the codec reachs to the target state */
3839 msleep(1);
3840 }
3841 return state;
3842}
3843
9419ab6b 3844/* don't power down the widget if it controls eapd and EAPD_BTLENABLE is set */
ba615b86
TI		 3845unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
3846 hda_nid_t nid,
3847 unsigned int power_state)
9419ab6b
TI		 3848{
3849 if (power_state == AC_PWRST_D3 &&
3850 get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
3851 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3852 int eapd = snd_hda_codec_read(codec, nid, 0,
3853 AC_VERB_GET_EAPD_BTLENABLE, 0);
3854 if (eapd & 0x02)
3855 return AC_PWRST_D0;
3856 }
3857 return power_state;
3858}
ba615b86 3859EXPORT_SYMBOL_HDA(snd_hda_codec_eapd_power_filter);
9419ab6b 3860
4d7fbdbc 3861/*
08fa20ae 3862 * set power state of the codec, and return the power state
4d7fbdbc 3863 */
d819387e 3864static unsigned int hda_set_power_state(struct hda_codec *codec,
08fa20ae 3865 unsigned int power_state)
4d7fbdbc 3866{
d819387e 3867 hda_nid_t fg = codec->afg ? codec->afg : codec->mfg;
09617ce4
WX		 3868 int count;
3869 unsigned int state;
63e51fd7 3870 int flags = 0;
09617ce4 3871
4d7fbdbc 3872 /* this delay seems necessary to avoid click noise at power-down */
0f4ccbb0
WX		 3873 if (power_state == AC_PWRST_D3) {
3874 /* transition time less than 10ms for power down */
983f6b93 3875 msleep(codec->epss ? 10 : 100);
63e51fd7 3876 flags = HDA_RW_NO_RESPONSE_FALLBACK;
0f4ccbb0 3877 }
09617ce4
WX		 3878
3879 /* repeat power states setting at most 10 times*/
3880 for (count = 0; count < 10; count++) {
432c641e
TI		 3881 if (codec->patch_ops.set_power_state)
3882 codec->patch_ops.set_power_state(codec, fg,
3883 power_state);
3884 else {
63e51fd7 3885 snd_hda_codec_read(codec, fg, flags,
432c641e
TI		 3886 AC_VERB_SET_POWER_STATE,
3887 power_state);
9419ab6b 3888 snd_hda_codec_set_power_to_all(codec, fg, power_state);
432c641e
TI		 3889 }
3890 state = hda_sync_power_state(codec, fg, power_state);
09617ce4
WX		 3891 if (!(state & AC_PWRST_ERROR))
3892 break;
3893 }
b8dfc462 3894
08fa20ae 3895 return state;
4d7fbdbc 3896}
cb53c626 3897
b9c590bb
TI		 3898/* sync power states of all widgets;
3899 * this is called at the end of codec parsing
3900 */
3901static void sync_power_up_states(struct hda_codec *codec)
3902{
3903 hda_nid_t nid = codec->start_nid;
3904 int i;
3905
ba615b86
TI		 3906 /* don't care if no filter is used */
3907 if (!codec->power_filter)
b9c590bb
TI		 3908 return;
3909
3910 for (i = 0; i < codec->num_nodes; i++, nid++) {
3911 unsigned int wcaps = get_wcaps(codec, nid);
9040d102 3912 unsigned int target;
b9c590bb
TI		 3913 if (!(wcaps & AC_WCAP_POWER))
3914 continue;
3915 target = codec->power_filter(codec, nid, AC_PWRST_D0);
3916 if (target == AC_PWRST_D0)
3917 continue;
9040d102 3918 if (!snd_hda_check_power_state(codec, nid, target))
b9c590bb
TI		 3919 snd_hda_codec_write(codec, nid, 0,
3920 AC_VERB_SET_POWER_STATE, target);
3921 }
3922}
3923
11aeff08
TI		 3924#ifdef CONFIG_SND_HDA_HWDEP
3925/* execute additional init verbs */
3926static void hda_exec_init_verbs(struct hda_codec *codec)
3927{
3928 if (codec->init_verbs.list)
3929 snd_hda_sequence_write(codec, codec->init_verbs.list);
3930}
3931#else
3932static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3933#endif
3934
2a43952a 3935#ifdef CONFIG_PM
cb53c626
TI		 3936/*
3937 * call suspend and power-down; used both from PM and power-save
08fa20ae 3938 * this function returns the power state in the end
cb53c626 3939 */
d17344b3 3940static unsigned int hda_call_codec_suspend(struct hda_codec *codec, bool in_wq)
cb53c626 3941{
08fa20ae
TI		 3942 unsigned int state;
3943
989c3187
TI		 3944 codec->in_pm = 1;
3945
cb53c626 3946 if (codec->patch_ops.suspend)
68cb2b55 3947 codec->patch_ops.suspend(codec);
eb541337 3948 hda_cleanup_all_streams(codec);
d819387e 3949 state = hda_set_power_state(codec, AC_PWRST_D3);
d17344b3
DR		 3950 /* Cancel delayed work if we aren't currently running from it. */
3951 if (!in_wq)
3952 cancel_delayed_work_sync(&codec->power_work);
a2d96e77
TI		 3953 spin_lock(&codec->power_lock);
3954 snd_hda_update_power_acct(codec);
3955 trace_hda_power_down(codec);
95e99fda 3956 codec->power_on = 0;
a221e287 3957 codec->power_transition = 0;
a2f6309e 3958 codec->power_jiffies = jiffies;
a2d96e77 3959 spin_unlock(&codec->power_lock);
989c3187 3960 codec->in_pm = 0;
08fa20ae 3961 return state;
54d17403
TI		 3962}
3963
c370dd6e
TI		 3964/* mark all entries of cmd and amp caches dirty */
3965static void hda_mark_cmd_cache_dirty(struct hda_codec *codec)
3966{
3967 int i;
3968 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3969 struct hda_cache_head *cmd;
3970 cmd = snd_array_elem(&codec->cmd_cache.buf, i);
3971 cmd->dirty = 1;
3972 }
3973 for (i = 0; i < codec->amp_cache.buf.used; i++) {
3974 struct hda_amp_info *amp;
f038fcac 3975 amp = snd_array_elem(&codec->amp_cache.buf, i);
c370dd6e
TI		 3976 amp->head.dirty = 1;
3977 }
3978}
3979
cb53c626
TI		 3980/*
3981 * kick up codec; used both from PM and power-save
3982 */
3983static void hda_call_codec_resume(struct hda_codec *codec)
3984{
989c3187
TI		 3985 codec->in_pm = 1;
3986
c370dd6e
TI		 3987 hda_mark_cmd_cache_dirty(codec);
3988
7f30830b
TI		 3989 /* set as if powered on for avoiding re-entering the resume
3990 * in the resume / power-save sequence
3991 */
3992 hda_keep_power_on(codec);
d819387e 3993 hda_set_power_state(codec, AC_PWRST_D0);
ac0547dc 3994 restore_shutup_pins(codec);
11aeff08 3995 hda_exec_init_verbs(codec);
31614bb8 3996 snd_hda_jack_set_dirty_all(codec);
cb53c626
TI		 3997 if (codec->patch_ops.resume)
3998 codec->patch_ops.resume(codec);
3999 else {
9d99f312
TI		 4000 if (codec->patch_ops.init)
4001 codec->patch_ops.init(codec);
cb53c626
TI		 4002 snd_hda_codec_resume_amp(codec);
4003 snd_hda_codec_resume_cache(codec);
4004 }
26a6cb6c
DH		 4005
4006 if (codec->jackpoll_interval)
4007 hda_jackpoll_work(&codec->jackpoll_work.work);
31614bb8 4008 else
26a6cb6c 4009 snd_hda_jack_report_sync(codec);
989c3187
TI		 4010
4011 codec->in_pm = 0;
7f30830b 4012 snd_hda_power_down(codec); /* flag down before returning */
cb53c626 4013}
2a43952a 4014#endif /* CONFIG_PM */
cb53c626 4015
54d17403 4016
1da177e4
LT		 4017/**
4018 * snd_hda_build_controls - build mixer controls
4019 * @bus: the BUS
4020 *
4021 * Creates mixer controls for each codec included in the bus.
4022 *
4023 * Returns 0 if successful, otherwise a negative error code.
4024 */
6a0f56a7 4025int snd_hda_build_controls(struct hda_bus *bus)
1da177e4 4026{
0ba21762 4027 struct hda_codec *codec;
1da177e4 4028
0ba21762 4029 list_for_each_entry(codec, &bus->codec_list, list) {
6c1f45ea 4030 int err = snd_hda_codec_build_controls(codec);
f93d461b 4031 if (err < 0) {
28d1a85e 4032 printk(KERN_ERR "hda_codec: cannot build controls "
28aedaf7 4033 "for #%d (error %d)\n", codec->addr, err);
f93d461b
TI		 4034 err = snd_hda_codec_reset(codec);
4035 if (err < 0) {
4036 printk(KERN_ERR
4037 "hda_codec: cannot revert codec\n");
4038 return err;
4039 }
4040 }
1da177e4 4041 }
6c1f45ea
TI		 4042 return 0;
4043}
ff7a3267 4044EXPORT_SYMBOL_HDA(snd_hda_build_controls);
cb53c626 4045
9c9a5175
TI		 4046/*
4047 * add standard channel maps if not specified
4048 */
4049static int add_std_chmaps(struct hda_codec *codec)
4050{
4051 int i, str, err;
4052
4053 for (i = 0; i < codec->num_pcms; i++) {
4054 for (str = 0; str < 2; str++) {
4055 struct snd_pcm *pcm = codec->pcm_info[i].pcm;
4056 struct hda_pcm_stream *hinfo =
4057 &codec->pcm_info[i].stream[str];
4058 struct snd_pcm_chmap *chmap;
ee81abb6 4059 const struct snd_pcm_chmap_elem *elem;
9c9a5175
TI		 4060
4061 if (codec->pcm_info[i].own_chmap)
4062 continue;
4063 if (!pcm || !hinfo->substreams)
4064 continue;
ee81abb6
TI		 4065 elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
4066 err = snd_pcm_add_chmap_ctls(pcm, str, elem,
9c9a5175
TI		 4067 hinfo->channels_max,
4068 0, &chmap);
4069 if (err < 0)
4070 return err;
4071 chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
4072 }
4073 }
4074 return 0;
4075}
4076
ee81abb6
TI		 4077/* default channel maps for 2.1 speakers;
4078 * since HD-audio supports only stereo, odd number channels are omitted
4079 */
4080const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
4081 { .channels = 2,
4082 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
4083 { .channels = 4,
4084 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
4085 SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
4086 { }
4087};
4088EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
4089
6c1f45ea
TI		 4090int snd_hda_codec_build_controls(struct hda_codec *codec)
4091{
4092 int err = 0;
11aeff08 4093 hda_exec_init_verbs(codec);
6c1f45ea
TI		 4094 /* continue to initialize... */
4095 if (codec->patch_ops.init)
4096 err = codec->patch_ops.init(codec);
4097 if (!err && codec->patch_ops.build_controls)
4098 err = codec->patch_ops.build_controls(codec);
6c1f45ea
TI		 4099 if (err < 0)
4100 return err;
9c9a5175
TI		 4101
4102 /* we create chmaps here instead of build_pcms */
4103 err = add_std_chmaps(codec);
4104 if (err < 0)
4105 return err;
4106
26a6cb6c
DH		 4107 if (codec->jackpoll_interval)
4108 hda_jackpoll_work(&codec->jackpoll_work.work);
4109 else
4110 snd_hda_jack_report_sync(codec); /* call at the last init point */
b9c590bb 4111 sync_power_up_states(codec);
1da177e4
LT		 4112 return 0;
4113}
4114
1da177e4
LT		 4115/*
4116 * stream formats
4117 */
befdf316
TI		 4118struct hda_rate_tbl {
4119 unsigned int hz;
4120 unsigned int alsa_bits;
4121 unsigned int hda_fmt;
4122};
4123
92f10b3f
TI		 4124/* rate = base * mult / div */
4125#define HDA_RATE(base, mult, div) \
4126 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
4127 (((div) - 1) << AC_FMT_DIV_SHIFT))
4128
befdf316 4129static struct hda_rate_tbl rate_bits[] = {
1da177e4 4130 /* rate in Hz, ALSA rate bitmask, HDA format value */
9d8f53f2
NG		 4131
4132 /* autodetected value used in snd_hda_query_supported_pcm */
92f10b3f
TI		 4133 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
4134 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
4135 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
4136 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
4137 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
4138 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
4139 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
4140 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
4141 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
4142 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
4143 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
a961f9fe
TI		 4144#define AC_PAR_PCM_RATE_BITS 11
4145 /* up to bits 10, 384kHZ isn't supported properly */
4146
4147 /* not autodetected value */
92f10b3f 4148 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
9d8f53f2 4149
befdf316 4150 { 0 } /* terminator */
1da177e4
LT		 4151};
4152
4153/**
4154 * snd_hda_calc_stream_format - calculate format bitset
4155 * @rate: the sample rate
4156 * @channels: the number of channels
4157 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
4158 * @maxbps: the max. bps
4159 *
4160 * Calculate the format bitset from the given rate, channels and th PCM format.
4161 *
4162 * Return zero if invalid.
4163 */
4164unsigned int snd_hda_calc_stream_format(unsigned int rate,
4165 unsigned int channels,
4166 unsigned int format,
32c168c8
AH		 4167 unsigned int maxbps,
4168 unsigned short spdif_ctls)
1da177e4
LT		 4169{
4170 int i;
4171 unsigned int val = 0;
4172
befdf316
TI		 4173 for (i = 0; rate_bits[i].hz; i++)
4174 if (rate_bits[i].hz == rate) {
4175 val = rate_bits[i].hda_fmt;
1da177e4
LT		 4176 break;
4177 }
0ba21762 4178 if (!rate_bits[i].hz) {
1da177e4
LT		 4179 snd_printdd("invalid rate %d\n", rate);
4180 return 0;
4181 }
4182
4183 if (channels == 0 || channels > 8) {
4184 snd_printdd("invalid channels %d\n", channels);
4185 return 0;
4186 }
4187 val |= channels - 1;
4188
4189 switch (snd_pcm_format_width(format)) {
28aedaf7 4190 case 8:
92f10b3f 4191 val |= AC_FMT_BITS_8;
28aedaf7
NL		 4192 break;
4193 case 16:
92f10b3f 4194 val |= AC_FMT_BITS_16;
28aedaf7 4195 break;
1da177e4
LT		 4196 case 20:
4197 case 24:
4198 case 32:
b0bb3aa6 4199 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
92f10b3f 4200 val |= AC_FMT_BITS_32;
1da177e4 4201 else if (maxbps >= 24)
92f10b3f 4202 val |= AC_FMT_BITS_24;
1da177e4 4203 else
92f10b3f 4204 val |= AC_FMT_BITS_20;
1da177e4
LT		 4205 break;
4206 default:
0ba21762
TI		 4207 snd_printdd("invalid format width %d\n",
4208 snd_pcm_format_width(format));
1da177e4
LT		 4209 return 0;
4210 }
4211
32c168c8 4212 if (spdif_ctls & AC_DIG1_NONAUDIO)
92f10b3f 4213 val |= AC_FMT_TYPE_NON_PCM;
32c168c8 4214
1da177e4
LT		 4215 return val;
4216}
ff7a3267 4217EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
1da177e4 4218
c3b6bcc2
TI		 4219static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
4220 int dir)
92c7c8a7
TI		 4221{
4222 unsigned int val = 0;
4223 if (nid != codec->afg &&
4224 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
4225 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
4226 if (!val || val == -1)
4227 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
4228 if (!val || val == -1)
4229 return 0;
4230 return val;
4231}
4232
4233static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
4234{
c3b6bcc2 4235 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
92c7c8a7
TI		 4236 get_pcm_param);
4237}
4238
c3b6bcc2
TI		 4239static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
4240 int dir)
92c7c8a7
TI		 4241{
4242 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
4243 if (!streams || streams == -1)
4244 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
4245 if (!streams || streams == -1)
4246 return 0;
4247 return streams;
4248}
4249
4250static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
4251{
c3b6bcc2 4252 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
92c7c8a7
TI		 4253 get_stream_param);
4254}
4255
1da177e4
LT		 4256/**
4257 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
4258 * @codec: the HDA codec
4259 * @nid: NID to query
4260 * @ratesp: the pointer to store the detected rate bitflags
4261 * @formatsp: the pointer to store the detected formats
4262 * @bpsp: the pointer to store the detected format widths
4263 *
4264 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
4265 * or @bsps argument is ignored.
4266 *
4267 * Returns 0 if successful, otherwise a negative error code.
4268 */
384a48d7 4269int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
1da177e4
LT		 4270 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
4271{
ee504710 4272 unsigned int i, val, wcaps;
1da177e4 4273
ee504710 4274 wcaps = get_wcaps(codec, nid);
92c7c8a7 4275 val = query_pcm_param(codec, nid);
1da177e4
LT		 4276
4277 if (ratesp) {
4278 u32 rates = 0;
a961f9fe 4279 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
1da177e4 4280 if (val & (1 << i))
befdf316 4281 rates |= rate_bits[i].alsa_bits;
1da177e4 4282 }
ee504710
JK		 4283 if (rates == 0) {
4284 snd_printk(KERN_ERR "hda_codec: rates == 0 "
4285 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
4286 nid, val,
4287 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
4288 return -EIO;
4289 }
1da177e4
LT		 4290 *ratesp = rates;
4291 }
4292
4293 if (formatsp || bpsp) {
4294 u64 formats = 0;
ee504710 4295 unsigned int streams, bps;
1da177e4 4296
92c7c8a7
TI		 4297 streams = query_stream_param(codec, nid);
4298 if (!streams)
1da177e4 4299 return -EIO;
1da177e4
LT		 4300
4301 bps = 0;
4302 if (streams & AC_SUPFMT_PCM) {
4303 if (val & AC_SUPPCM_BITS_8) {
4304 formats |= SNDRV_PCM_FMTBIT_U8;
4305 bps = 8;
4306 }
4307 if (val & AC_SUPPCM_BITS_16) {
4308 formats |= SNDRV_PCM_FMTBIT_S16_LE;
4309 bps = 16;
4310 }
4311 if (wcaps & AC_WCAP_DIGITAL) {
4312 if (val & AC_SUPPCM_BITS_32)
4313 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
4314 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
4315 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4316 if (val & AC_SUPPCM_BITS_24)
4317 bps = 24;
4318 else if (val & AC_SUPPCM_BITS_20)
4319 bps = 20;
0ba21762
TI		 4320 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
4321 AC_SUPPCM_BITS_32)) {
1da177e4
LT		 4322 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4323 if (val & AC_SUPPCM_BITS_32)
4324 bps = 32;
1da177e4
LT		 4325 else if (val & AC_SUPPCM_BITS_24)
4326 bps = 24;
33ef7651
NG		 4327 else if (val & AC_SUPPCM_BITS_20)
4328 bps = 20;
1da177e4
LT		 4329 }
4330 }
8c7dd890 4331#if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
b5025c50 4332 if (streams & AC_SUPFMT_FLOAT32) {
1da177e4 4333 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
b0bb3aa6
TI		 4334 if (!bps)
4335 bps = 32;
b5025c50 4336 }
8c7dd890 4337#endif
b5025c50 4338 if (streams == AC_SUPFMT_AC3) {
0ba21762 4339 /* should be exclusive */
1da177e4
LT		 4340 /* temporary hack: we have still no proper support
4341 * for the direct AC3 stream...
4342 */
4343 formats |= SNDRV_PCM_FMTBIT_U8;
4344 bps = 8;
4345 }
ee504710
JK		 4346 if (formats == 0) {
4347 snd_printk(KERN_ERR "hda_codec: formats == 0 "
4348 "(nid=0x%x, val=0x%x, ovrd=%i, "
4349 "streams=0x%x)\n",
4350 nid, val,
4351 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
4352 streams);
4353 return -EIO;
4354 }
1da177e4
LT		 4355 if (formatsp)
4356 *formatsp = formats;
4357 if (bpsp)
4358 *bpsp = bps;
4359 }
4360
4361 return 0;
4362}
384a48d7 4363EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
1da177e4
LT		 4364
4365/**
d5191e50
TI		 4366 * snd_hda_is_supported_format - Check the validity of the format
4367 * @codec: HD-audio codec
4368 * @nid: NID to check
4369 * @format: the HD-audio format value to check
4370 *
4371 * Check whether the given node supports the format value.
1da177e4
LT		 4372 *
4373 * Returns 1 if supported, 0 if not.
4374 */
4375int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
4376 unsigned int format)
4377{
4378 int i;
4379 unsigned int val = 0, rate, stream;
4380
92c7c8a7
TI		 4381 val = query_pcm_param(codec, nid);
4382 if (!val)
4383 return 0;
1da177e4
LT		 4384
4385 rate = format & 0xff00;
a961f9fe 4386 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
befdf316 4387 if (rate_bits[i].hda_fmt == rate) {
1da177e4
LT		 4388 if (val & (1 << i))
4389 break;
4390 return 0;
4391 }
a961f9fe 4392 if (i >= AC_PAR_PCM_RATE_BITS)
1da177e4
LT		 4393 return 0;
4394
92c7c8a7
TI		 4395 stream = query_stream_param(codec, nid);
4396 if (!stream)
1da177e4
LT		 4397 return 0;
4398
4399 if (stream & AC_SUPFMT_PCM) {
4400 switch (format & 0xf0) {
4401 case 0x00:
0ba21762 4402 if (!(val & AC_SUPPCM_BITS_8))
1da177e4
LT		 4403 return 0;
4404 break;
4405 case 0x10:
0ba21762 4406 if (!(val & AC_SUPPCM_BITS_16))
1da177e4
LT		 4407 return 0;
4408 break;
4409 case 0x20:
0ba21762 4410 if (!(val & AC_SUPPCM_BITS_20))
1da177e4
LT		 4411 return 0;
4412 break;
4413 case 0x30:
0ba21762 4414 if (!(val & AC_SUPPCM_BITS_24))
1da177e4
LT		 4415 return 0;
4416 break;
4417 case 0x40:
0ba21762 4418 if (!(val & AC_SUPPCM_BITS_32))
1da177e4
LT		 4419 return 0;
4420 break;
4421 default:
4422 return 0;
4423 }
4424 } else {
4425 /* FIXME: check for float32 and AC3? */
4426 }
4427
4428 return 1;
4429}
ff7a3267 4430EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
1da177e4
LT		 4431
4432/*
4433 * PCM stuff
4434 */
4435static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
4436 struct hda_codec *codec,
c8b6bf9b 4437 struct snd_pcm_substream *substream)
1da177e4
LT		 4438{
4439 return 0;
4440}
4441
4442static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
4443 struct hda_codec *codec,
4444 unsigned int stream_tag,
4445 unsigned int format,
c8b6bf9b 4446 struct snd_pcm_substream *substream)
1da177e4
LT		 4447{
4448 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4449 return 0;
4450}
4451
4452static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
4453 struct hda_codec *codec,
c8b6bf9b 4454 struct snd_pcm_substream *substream)
1da177e4 4455{
888afa15 4456 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
1da177e4
LT		 4457 return 0;
4458}
4459
6c1f45ea
TI		 4460static int set_pcm_default_values(struct hda_codec *codec,
4461 struct hda_pcm_stream *info)
1da177e4 4462{
ee504710
JK		 4463 int err;
4464
0ba21762
TI		 4465 /* query support PCM information from the given NID */
4466 if (info->nid && (!info->rates || !info->formats)) {
ee504710 4467 err = snd_hda_query_supported_pcm(codec, info->nid,
0ba21762
TI		 4468 info->rates ? NULL : &info->rates,
4469 info->formats ? NULL : &info->formats,
4470 info->maxbps ? NULL : &info->maxbps);
ee504710
JK		 4471 if (err < 0)
4472 return err;
1da177e4
LT		 4473 }
4474 if (info->ops.open == NULL)
4475 info->ops.open = hda_pcm_default_open_close;
4476 if (info->ops.close == NULL)
4477 info->ops.close = hda_pcm_default_open_close;
4478 if (info->ops.prepare == NULL) {
da3cec35
TI		 4479 if (snd_BUG_ON(!info->nid))
4480 return -EINVAL;
1da177e4
LT		 4481 info->ops.prepare = hda_pcm_default_prepare;
4482 }
1da177e4 4483 if (info->ops.cleanup == NULL) {
da3cec35
TI		 4484 if (snd_BUG_ON(!info->nid))
4485 return -EINVAL;
1da177e4
LT		 4486 info->ops.cleanup = hda_pcm_default_cleanup;
4487 }
4488 return 0;
4489}
4490
eb541337
TI		 4491/*
4492 * codec prepare/cleanup entries
4493 */
4494int snd_hda_codec_prepare(struct hda_codec *codec,
4495 struct hda_pcm_stream *hinfo,
4496 unsigned int stream,
4497 unsigned int format,
4498 struct snd_pcm_substream *substream)
4499{
4500 int ret;
3f50ac6a 4501 mutex_lock(&codec->bus->prepare_mutex);
eb541337
TI		 4502 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4503 if (ret >= 0)
4504 purify_inactive_streams(codec);
3f50ac6a 4505 mutex_unlock(&codec->bus->prepare_mutex);
eb541337
TI		 4506 return ret;
4507}
4508EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
4509
4510void snd_hda_codec_cleanup(struct hda_codec *codec,
4511 struct hda_pcm_stream *hinfo,
4512 struct snd_pcm_substream *substream)
4513{
3f50ac6a 4514 mutex_lock(&codec->bus->prepare_mutex);
eb541337 4515 hinfo->ops.cleanup(hinfo, codec, substream);
3f50ac6a 4516 mutex_unlock(&codec->bus->prepare_mutex);
eb541337
TI		 4517}
4518EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
4519
d5191e50 4520/* global */
e3303235
JK		 4521const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4522 "Audio", "SPDIF", "HDMI", "Modem"
4523};
4524
529bd6c4
TI		 4525/*
4526 * get the empty PCM device number to assign
4527 */
36bb00d4 4528static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type)
529bd6c4 4529{
f5d6def5 4530 /* audio device indices; not linear to keep compatibility */
36bb00d4
TI		 4531 /* assigned to static slots up to dev#10; if more needed, assign
4532 * the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y)
4533 */
f5d6def5
WF		 4534 static int audio_idx[HDA_PCM_NTYPES][5] = {
4535 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4536 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
92608bad 4537 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
f5d6def5 4538 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
529bd6c4 4539 };
f5d6def5
WF		 4540 int i;
4541
4542 if (type >= HDA_PCM_NTYPES) {
529bd6c4
TI		 4543 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4544 return -EINVAL;
4545 }
f5d6def5 4546
36bb00d4
TI		 4547 for (i = 0; audio_idx[type][i] >= 0; i++) {
4548#ifndef CONFIG_SND_DYNAMIC_MINORS
4549 if (audio_idx[type][i] >= 8)
4550 break;
4551#endif
f5d6def5
WF		 4552 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4553 return audio_idx[type][i];
36bb00d4 4554 }
f5d6def5 4555
36bb00d4 4556#ifdef CONFIG_SND_DYNAMIC_MINORS
01b65bfb
TI		 4557 /* non-fixed slots starting from 10 */
4558 for (i = 10; i < 32; i++) {
4559 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4560 return i;
4561 }
36bb00d4 4562#endif
01b65bfb 4563
28aedaf7
NL		 4564 snd_printk(KERN_WARNING "Too many %s devices\n",
4565 snd_hda_pcm_type_name[type]);
36bb00d4
TI		 4566#ifndef CONFIG_SND_DYNAMIC_MINORS
4567 snd_printk(KERN_WARNING "Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n");
4568#endif
f5d6def5 4569 return -EAGAIN;
529bd6c4
TI		 4570}
4571
176d5335
TI		 4572/*
4573 * attach a new PCM stream
4574 */
529bd6c4 4575static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
176d5335 4576{
33fa35ed 4577 struct hda_bus *bus = codec->bus;
176d5335
TI		 4578 struct hda_pcm_stream *info;
4579 int stream, err;
4580
b91f080f 4581 if (snd_BUG_ON(!pcm->name))
176d5335
TI		 4582 return -EINVAL;
4583 for (stream = 0; stream < 2; stream++) {
4584 info = &pcm->stream[stream];
4585 if (info->substreams) {
4586 err = set_pcm_default_values(codec, info);
4587 if (err < 0)
4588 return err;
4589 }
4590 }
33fa35ed 4591 return bus->ops.attach_pcm(bus, codec, pcm);
176d5335
TI		 4592}
4593
529bd6c4
TI		 4594/* assign all PCMs of the given codec */
4595int snd_hda_codec_build_pcms(struct hda_codec *codec)
4596{
4597 unsigned int pcm;
4598 int err;
4599
4600 if (!codec->num_pcms) {
4601 if (!codec->patch_ops.build_pcms)
4602 return 0;
4603 err = codec->patch_ops.build_pcms(codec);
6e655bf2
TI		 4604 if (err < 0) {
4605 printk(KERN_ERR "hda_codec: cannot build PCMs"
28aedaf7 4606 "for #%d (error %d)\n", codec->addr, err);
6e655bf2
TI		 4607 err = snd_hda_codec_reset(codec);
4608 if (err < 0) {
4609 printk(KERN_ERR
4610 "hda_codec: cannot revert codec\n");
4611 return err;
4612 }
4613 }
529bd6c4
TI		 4614 }
4615 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4616 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4617 int dev;
4618
4619 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
41b5b01a 4620 continue; /* no substreams assigned */
529bd6c4
TI		 4621
4622 if (!cpcm->pcm) {
4623 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4624 if (dev < 0)
6e655bf2 4625 continue; /* no fatal error */
529bd6c4
TI		 4626 cpcm->device = dev;
4627 err = snd_hda_attach_pcm(codec, cpcm);
6e655bf2
TI		 4628 if (err < 0) {
4629 printk(KERN_ERR "hda_codec: cannot attach "
4630 "PCM stream %d for codec #%d\n",
4631 dev, codec->addr);
4632 continue; /* no fatal error */
4633 }
529bd6c4
TI		 4634 }
4635 }
4636 return 0;
4637}
4638
1da177e4
LT		 4639/**
4640 * snd_hda_build_pcms - build PCM information
4641 * @bus: the BUS
4642 *
4643 * Create PCM information for each codec included in the bus.
4644 *
4645 * The build_pcms codec patch is requested to set up codec->num_pcms and
4646 * codec->pcm_info properly. The array is referred by the top-level driver
4647 * to create its PCM instances.
4648 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4649 * callback.
4650 *
4651 * At least, substreams, channels_min and channels_max must be filled for
4652 * each stream. substreams = 0 indicates that the stream doesn't exist.
4653 * When rates and/or formats are zero, the supported values are queried
4654 * from the given nid. The nid is used also by the default ops.prepare
4655 * and ops.cleanup callbacks.
4656 *
4657 * The driver needs to call ops.open in its open callback. Similarly,
4658 * ops.close is supposed to be called in the close callback.
4659 * ops.prepare should be called in the prepare or hw_params callback
4660 * with the proper parameters for set up.
4661 * ops.cleanup should be called in hw_free for clean up of streams.
4662 *
25985edc 4663 * This function returns 0 if successful, or a negative error code.
1da177e4 4664 */
5cb543db 4665int snd_hda_build_pcms(struct hda_bus *bus)
1da177e4 4666{
0ba21762 4667 struct hda_codec *codec;
1da177e4 4668
0ba21762 4669 list_for_each_entry(codec, &bus->codec_list, list) {
529bd6c4
TI		 4670 int err = snd_hda_codec_build_pcms(codec);
4671 if (err < 0)
4672 return err;
1da177e4
LT		 4673 }
4674 return 0;
4675}
ff7a3267 4676EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
1da177e4 4677
1da177e4
LT		 4678/**
4679 * snd_hda_check_board_config - compare the current codec with the config table
4680 * @codec: the HDA codec
f5fcc13c
TI		 4681 * @num_configs: number of config enums
4682 * @models: array of model name strings
1da177e4
LT		 4683 * @tbl: configuration table, terminated by null entries
4684 *
4685 * Compares the modelname or PCI subsystem id of the current codec with the
4686 * given configuration table. If a matching entry is found, returns its
4687 * config value (supposed to be 0 or positive).
4688 *
4689 * If no entries are matching, the function returns a negative value.
4690 */
12f288bf 4691int snd_hda_check_board_config(struct hda_codec *codec,
ea734963 4692 int num_configs, const char * const *models,
12f288bf 4693 const struct snd_pci_quirk *tbl)
1da177e4 4694{
f44ac837 4695 if (codec->modelname && models) {
f5fcc13c
TI		 4696 int i;
4697 for (i = 0; i < num_configs; i++) {
4698 if (models[i] &&
f44ac837 4699 !strcmp(codec->modelname, models[i])) {
f5fcc13c
TI		 4700 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4701 "selected\n", models[i]);
4702 return i;
1da177e4
LT		 4703 }
4704 }
4705 }
4706
f5fcc13c
TI		 4707 if (!codec->bus->pci || !tbl)
4708 return -1;
4709
4710 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4711 if (!tbl)
4712 return -1;
4713 if (tbl->value >= 0 && tbl->value < num_configs) {
62cf872a 4714#ifdef CONFIG_SND_DEBUG_VERBOSE
f5fcc13c
TI		 4715 char tmp[10];
4716 const char *model = NULL;
4717 if (models)
4718 model = models[tbl->value];
4719 if (!model) {
4720 sprintf(tmp, "#%d", tbl->value);
4721 model = tmp;
1da177e4 4722 }
f5fcc13c
TI		 4723 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4724 "for config %x:%x (%s)\n",
4725 model, tbl->subvendor, tbl->subdevice,
4726 (tbl->name ? tbl->name : "Unknown device"));
4727#endif
4728 return tbl->value;
1da177e4
LT		 4729 }
4730 return -1;
4731}
ff7a3267 4732EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
1da177e4 4733
2eda3445
MCC		 4734/**
4735 * snd_hda_check_board_codec_sid_config - compare the current codec
28aedaf7
NL		 4736 subsystem ID with the
4737 config table
2eda3445
MCC		 4738
4739 This is important for Gateway notebooks with SB450 HDA Audio
4740 where the vendor ID of the PCI device is:
4741 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4742 and the vendor/subvendor are found only at the codec.
4743
4744 * @codec: the HDA codec
4745 * @num_configs: number of config enums
4746 * @models: array of model name strings
4747 * @tbl: configuration table, terminated by null entries
4748 *
4749 * Compares the modelname or PCI subsystem id of the current codec with the
4750 * given configuration table. If a matching entry is found, returns its
4751 * config value (supposed to be 0 or positive).
4752 *
4753 * If no entries are matching, the function returns a negative value.
4754 */
4755int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
ea734963 4756 int num_configs, const char * const *models,
2eda3445
MCC		 4757 const struct snd_pci_quirk *tbl)
4758{
4759 const struct snd_pci_quirk *q;
4760
4761 /* Search for codec ID */
4762 for (q = tbl; q->subvendor; q++) {
e2301a4d
TI		 4763 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4764 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4765 if ((codec->subsystem_id & mask) == id)
2eda3445
MCC		 4766 break;
4767 }
4768
4769 if (!q->subvendor)
4770 return -1;
4771
4772 tbl = q;
4773
4774 if (tbl->value >= 0 && tbl->value < num_configs) {
d94ff6b7 4775#ifdef CONFIG_SND_DEBUG_VERBOSE
2eda3445
MCC		 4776 char tmp[10];
4777 const char *model = NULL;
4778 if (models)
4779 model = models[tbl->value];
4780 if (!model) {
4781 sprintf(tmp, "#%d", tbl->value);
4782 model = tmp;
4783 }
4784 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4785 "for config %x:%x (%s)\n",
4786 model, tbl->subvendor, tbl->subdevice,
4787 (tbl->name ? tbl->name : "Unknown device"));
4788#endif
4789 return tbl->value;
4790 }
4791 return -1;
4792}
4793EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4794
1da177e4
LT		 4795/**
4796 * snd_hda_add_new_ctls - create controls from the array
4797 * @codec: the HDA codec
c8b6bf9b 4798 * @knew: the array of struct snd_kcontrol_new
1da177e4
LT		 4799 *
4800 * This helper function creates and add new controls in the given array.
4801 * The array must be terminated with an empty entry as terminator.
4802 *
4803 * Returns 0 if successful, or a negative error code.
4804 */
031024ee
TI		 4805int snd_hda_add_new_ctls(struct hda_codec *codec,
4806 const struct snd_kcontrol_new *knew)
1da177e4 4807{
4d02d1b6 4808 int err;
1da177e4
LT		 4809
4810 for (; knew->name; knew++) {
54d17403 4811 struct snd_kcontrol *kctl;
1afe206a 4812 int addr = 0, idx = 0;
5b0cb1d8
JK		 4813 if (knew->iface == -1) /* skip this codec private value */
4814 continue;
1afe206a 4815 for (;;) {
54d17403 4816 kctl = snd_ctl_new1(knew, codec);
0ba21762 4817 if (!kctl)
54d17403 4818 return -ENOMEM;
1afe206a
TI		 4819 if (addr > 0)
4820 kctl->id.device = addr;
4821 if (idx > 0)
4822 kctl->id.index = idx;
3911a4c1 4823 err = snd_hda_ctl_add(codec, 0, kctl);
1afe206a
TI		 4824 if (!err)
4825 break;
4826 /* try first with another device index corresponding to
4827 * the codec addr; if it still fails (or it's the
4828 * primary codec), then try another control index
4829 */
4830 if (!addr && codec->addr)
4831 addr = codec->addr;
4832 else if (!idx && !knew->index) {
4833 idx = find_empty_mixer_ctl_idx(codec,
dcda5806 4834 knew->name, 0);
1afe206a
TI		 4835 if (idx <= 0)
4836 return err;
4837 } else
54d17403
TI		 4838 return err;
4839 }
1da177e4
LT		 4840 }
4841 return 0;
4842}
ff7a3267 4843EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
1da177e4 4844
83012a7c 4845#ifdef CONFIG_PM
cb53c626
TI		 4846static void hda_power_work(struct work_struct *work)
4847{
4848 struct hda_codec *codec =
4849 container_of(work, struct hda_codec, power_work.work);
33fa35ed 4850 struct hda_bus *bus = codec->bus;
08fa20ae 4851 unsigned int state;
cb53c626 4852
5536c6d6 4853 spin_lock(&codec->power_lock);
a2d96e77
TI		 4854 if (codec->power_transition > 0) { /* during power-up sequence? */
4855 spin_unlock(&codec->power_lock);
4856 return;
4857 }
2e492462
ML		 4858 if (!codec->power_on || codec->power_count) {
4859 codec->power_transition = 0;
5536c6d6 4860 spin_unlock(&codec->power_lock);
cb53c626 4861 return;
2e492462 4862 }
5536c6d6
TI		 4863 spin_unlock(&codec->power_lock);
4864
d17344b3 4865 state = hda_call_codec_suspend(codec, true);
e6bbe666
TI		 4866 if (!codec->pm_down_notified &&
4867 !bus->power_keep_link_on && (state & AC_PWRST_CLK_STOP_OK)) {
08fa20ae 4868 codec->pm_down_notified = 1;
68467f51 4869 hda_call_pm_notify(bus, false);
08fa20ae 4870 }
cb53c626
TI		 4871}
4872
4873static void hda_keep_power_on(struct hda_codec *codec)
4874{
5536c6d6 4875 spin_lock(&codec->power_lock);
cb53c626
TI		 4876 codec->power_count++;
4877 codec->power_on = 1;
a2f6309e 4878 codec->power_jiffies = jiffies;
5536c6d6 4879 spin_unlock(&codec->power_lock);
a2f6309e
TI		 4880}
4881
d5191e50 4882/* update the power on/off account with the current jiffies */
a2f6309e
TI		 4883void snd_hda_update_power_acct(struct hda_codec *codec)
4884{
4885 unsigned long delta = jiffies - codec->power_jiffies;
4886 if (codec->power_on)
4887 codec->power_on_acct += delta;
4888 else
4889 codec->power_off_acct += delta;
4890 codec->power_jiffies += delta;
cb53c626
TI		 4891}
4892
b4a91cf0
DR		 4893/* Transition to powered up, if wait_power_down then wait for a pending
4894 * transition to D3 to complete. A pending D3 transition is indicated
4895 * with power_transition == -1. */
c376e2c7 4896/* call this with codec->power_lock held! */
b4a91cf0 4897static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
cb53c626 4898{
33fa35ed
TI		 4899 struct hda_bus *bus = codec->bus;
4900
b4a91cf0
DR		 4901 /* Return if power_on or transitioning to power_on, unless currently
4902 * powering down. */
4903 if ((codec->power_on || codec->power_transition > 0) &&
c376e2c7 4904 !(wait_power_down && codec->power_transition < 0))
cb53c626 4905 return;
a2d96e77 4906 spin_unlock(&codec->power_lock);
cb53c626 4907
a2d96e77
TI		 4908 cancel_delayed_work_sync(&codec->power_work);
4909
4910 spin_lock(&codec->power_lock);
b43d2247
DR		 4911 /* If the power down delayed work was cancelled above before starting,
4912 * then there is no need to go through power up here.
4913 */
4914 if (codec->power_on) {
535b6c51
TI		 4915 if (codec->power_transition < 0)
4916 codec->power_transition = 0;
b43d2247
DR		 4917 return;
4918 }
c376e2c7 4919
d66fee5d 4920 trace_hda_power_up(codec);
a2f6309e 4921 snd_hda_update_power_acct(codec);
cb53c626 4922 codec->power_on = 1;
a2f6309e 4923 codec->power_jiffies = jiffies;
7f30830b 4924 codec->power_transition = 1; /* avoid reentrance */
5536c6d6
TI		 4925 spin_unlock(&codec->power_lock);
4926
08fa20ae
TI		 4927 if (codec->pm_down_notified) {
4928 codec->pm_down_notified = 0;
68467f51 4929 hda_call_pm_notify(bus, true);
08fa20ae
TI		 4930 }
4931
cb53c626 4932 hda_call_codec_resume(codec);
5536c6d6
TI		 4933
4934 spin_lock(&codec->power_lock);
a221e287 4935 codec->power_transition = 0;
cb53c626 4936}
b4a91cf0 4937
c376e2c7
TI		 4938#define power_save(codec) \
4939 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
1289e9e8 4940
c376e2c7
TI		 4941/* Transition to powered down */
4942static void __snd_hda_power_down(struct hda_codec *codec)
b4a91cf0 4943{
c376e2c7
TI		 4944 if (!codec->power_on || codec->power_count || codec->power_transition)
4945 return;
b4a91cf0 4946
c376e2c7
TI		 4947 if (power_save(codec)) {
4948 codec->power_transition = -1; /* avoid reentrance */
4949 queue_delayed_work(codec->bus->workq, &codec->power_work,
4950 msecs_to_jiffies(power_save(codec) * 1000));
4951 }
4952}
cb53c626 4953
d5191e50 4954/**
c376e2c7 4955 * snd_hda_power_save - Power-up/down/sync the codec
d5191e50 4956 * @codec: HD-audio codec
c376e2c7 4957 * @delta: the counter delta to change
d5191e50 4958 *
c376e2c7
TI		 4959 * Change the power-up counter via @delta, and power up or down the hardware
4960 * appropriately. For the power-down, queue to the delayed action.
4961 * Passing zero to @delta means to synchronize the power state.
28aedaf7 4962 */
c376e2c7 4963void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait)
cb53c626 4964{
5536c6d6 4965 spin_lock(&codec->power_lock);
c376e2c7 4966 codec->power_count += delta;
b244d335 4967 trace_hda_power_count(codec);
c376e2c7
TI		 4968 if (delta > 0)
4969 __snd_hda_power_up(codec, d3wait);
4970 else
4971 __snd_hda_power_down(codec);
5536c6d6 4972 spin_unlock(&codec->power_lock);
cb53c626 4973}
c376e2c7 4974EXPORT_SYMBOL_HDA(snd_hda_power_save);
cb53c626 4975
d5191e50
TI		 4976/**
4977 * snd_hda_check_amp_list_power - Check the amp list and update the power
4978 * @codec: HD-audio codec
4979 * @check: the object containing an AMP list and the status
4980 * @nid: NID to check / update
4981 *
4982 * Check whether the given NID is in the amp list. If it's in the list,
4983 * check the current AMP status, and update the the power-status according
4984 * to the mute status.
4985 *
4986 * This function is supposed to be set or called from the check_power_status
4987 * patch ops.
28aedaf7 4988 */
cb53c626
TI		 4989int snd_hda_check_amp_list_power(struct hda_codec *codec,
4990 struct hda_loopback_check *check,
4991 hda_nid_t nid)
4992{
031024ee 4993 const struct hda_amp_list *p;
cb53c626
TI		 4994 int ch, v;
4995
4996 if (!check->amplist)
4997 return 0;
4998 for (p = check->amplist; p->nid; p++) {
4999 if (p->nid == nid)
5000 break;
5001 }
5002 if (!p->nid)
5003 return 0; /* nothing changed */
5004
5005 for (p = check->amplist; p->nid; p++) {
5006 for (ch = 0; ch < 2; ch++) {
5007 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
5008 p->idx);
5009 if (!(v & HDA_AMP_MUTE) && v > 0) {
5010 if (!check->power_on) {
5011 check->power_on = 1;
5012 snd_hda_power_up(codec);
5013 }
5014 return 1;
5015 }
5016 }
5017 }
5018 if (check->power_on) {
5019 check->power_on = 0;
5020 snd_hda_power_down(codec);
5021 }
5022 return 0;
5023}
ff7a3267 5024EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
cb53c626 5025#endif
1da177e4 5026
c8b6bf9b 5027/*
d2a6d7dc
TI		 5028 * Channel mode helper
5029 */
d5191e50
TI		 5030
5031/**
5032 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
5033 */
0ba21762
TI		 5034int snd_hda_ch_mode_info(struct hda_codec *codec,
5035 struct snd_ctl_elem_info *uinfo,
5036 const struct hda_channel_mode *chmode,
5037 int num_chmodes)
d2a6d7dc
TI		 5038{
5039 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5040 uinfo->count = 1;
5041 uinfo->value.enumerated.items = num_chmodes;
5042 if (uinfo->value.enumerated.item >= num_chmodes)
5043 uinfo->value.enumerated.item = num_chmodes - 1;
5044 sprintf(uinfo->value.enumerated.name, "%dch",
5045 chmode[uinfo->value.enumerated.item].channels);
5046 return 0;
5047}
ff7a3267 5048EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
d2a6d7dc 5049
d5191e50
TI		 5050/**
5051 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
5052 */
0ba21762
TI		 5053int snd_hda_ch_mode_get(struct hda_codec *codec,
5054 struct snd_ctl_elem_value *ucontrol,
5055 const struct hda_channel_mode *chmode,
5056 int num_chmodes,
d2a6d7dc
TI		 5057 int max_channels)
5058{
5059 int i;
5060
5061 for (i = 0; i < num_chmodes; i++) {
5062 if (max_channels == chmode[i].channels) {
5063 ucontrol->value.enumerated.item[0] = i;
5064 break;
5065 }
5066 }
5067 return 0;
5068}
ff7a3267 5069EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
d2a6d7dc 5070
d5191e50
TI		 5071/**
5072 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
5073 */
0ba21762
TI		 5074int snd_hda_ch_mode_put(struct hda_codec *codec,
5075 struct snd_ctl_elem_value *ucontrol,
5076 const struct hda_channel_mode *chmode,
5077 int num_chmodes,
d2a6d7dc
TI		 5078 int *max_channelsp)
5079{
5080 unsigned int mode;
5081
5082 mode = ucontrol->value.enumerated.item[0];
68ea7b2f
TI		 5083 if (mode >= num_chmodes)
5084 return -EINVAL;
82beb8fd 5085 if (*max_channelsp == chmode[mode].channels)
d2a6d7dc
TI		 5086 return 0;
5087 /* change the current channel setting */
5088 *max_channelsp = chmode[mode].channels;
5089 if (chmode[mode].sequence)
82beb8fd 5090 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
d2a6d7dc
TI		 5091 return 1;
5092}
ff7a3267 5093EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
d2a6d7dc 5094
1da177e4
LT		 5095/*
5096 * input MUX helper
5097 */
d5191e50
TI		 5098
5099/**
5100 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
5101 */
0ba21762
TI		 5102int snd_hda_input_mux_info(const struct hda_input_mux *imux,
5103 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 5104{
5105 unsigned int index;
5106
5107 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5108 uinfo->count = 1;
5109 uinfo->value.enumerated.items = imux->num_items;
5513b0c5
TI		 5110 if (!imux->num_items)
5111 return 0;
1da177e4
LT		 5112 index = uinfo->value.enumerated.item;
5113 if (index >= imux->num_items)
5114 index = imux->num_items - 1;
5115 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
5116 return 0;
5117}
ff7a3267 5118EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
1da177e4 5119
d5191e50
TI		 5120/**
5121 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
5122 */
0ba21762
TI		 5123int snd_hda_input_mux_put(struct hda_codec *codec,
5124 const struct hda_input_mux *imux,
5125 struct snd_ctl_elem_value *ucontrol,
5126 hda_nid_t nid,
1da177e4
LT		 5127 unsigned int *cur_val)
5128{
5129 unsigned int idx;
5130
5513b0c5
TI		 5131 if (!imux->num_items)
5132 return 0;
1da177e4
LT		 5133 idx = ucontrol->value.enumerated.item[0];
5134 if (idx >= imux->num_items)
5135 idx = imux->num_items - 1;
82beb8fd 5136 if (*cur_val == idx)
1da177e4 5137 return 0;
82beb8fd
TI		 5138 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
5139 imux->items[idx].index);
1da177e4
LT		 5140 *cur_val = idx;
5141 return 1;
5142}
ff7a3267 5143EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
1da177e4
LT		 5144
5145
dda415d4
TI		 5146/*
5147 * process kcontrol info callback of a simple string enum array
5148 * when @num_items is 0 or @texts is NULL, assume a boolean enum array
5149 */
5150int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
5151 struct snd_ctl_elem_info *uinfo,
5152 int num_items, const char * const *texts)
5153{
5154 static const char * const texts_default[] = {
5155 "Disabled", "Enabled"
5156 };
5157
5158 if (!texts || !num_items) {
5159 num_items = 2;
5160 texts = texts_default;
5161 }
5162
5163 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5164 uinfo->count = 1;
5165 uinfo->value.enumerated.items = num_items;
5166 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
5167 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
5168 strcpy(uinfo->value.enumerated.name,
5169 texts[uinfo->value.enumerated.item]);
5170 return 0;
5171}
5172EXPORT_SYMBOL_HDA(snd_hda_enum_helper_info);
5173
1da177e4
LT		 5174/*
5175 * Multi-channel / digital-out PCM helper functions
5176 */
5177
6b97eb45
TI		 5178/* setup SPDIF output stream */
5179static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
5180 unsigned int stream_tag, unsigned int format)
5181{
3bef1c37
LD		 5182 struct hda_spdif_out *spdif;
5183 unsigned int curr_fmt;
5184 bool reset;
5185
5186 spdif = snd_hda_spdif_out_of_nid(codec, nid);
5187 curr_fmt = snd_hda_codec_read(codec, nid, 0,
5188 AC_VERB_GET_STREAM_FORMAT, 0);
5189 reset = codec->spdif_status_reset &&
5190 (spdif->ctls & AC_DIG1_ENABLE) &&
5191 curr_fmt != format;
5192
5193 /* turn off SPDIF if needed; otherwise the IEC958 bits won't be
5194 updated */
5195 if (reset)
28aedaf7 5196 set_dig_out_convert(codec, nid,
7c935976 5197 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
2f72853c 5198 -1);
6b97eb45 5199 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2f72853c 5200 if (codec->slave_dig_outs) {
dda14410 5201 const hda_nid_t *d;
2f72853c
TI		 5202 for (d = codec->slave_dig_outs; *d; d++)
5203 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
5204 format);
5205 }
6b97eb45 5206 /* turn on again (if needed) */
3bef1c37 5207 if (reset)
2f72853c 5208 set_dig_out_convert(codec, nid,
7c935976 5209 spdif->ctls & 0xff, -1);
2f72853c 5210}
de51ca12 5211
2f72853c
TI		 5212static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
5213{
5214 snd_hda_codec_cleanup_stream(codec, nid);
5215 if (codec->slave_dig_outs) {
dda14410 5216 const hda_nid_t *d;
2f72853c
TI		 5217 for (d = codec->slave_dig_outs; *d; d++)
5218 snd_hda_codec_cleanup_stream(codec, *d);
de51ca12 5219 }
6b97eb45
TI		 5220}
5221
d5191e50
TI		 5222/**
5223 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
5224 * @bus: HD-audio bus
5225 */
fb8d1a34
TI		 5226void snd_hda_bus_reboot_notify(struct hda_bus *bus)
5227{
5228 struct hda_codec *codec;
5229
5230 if (!bus)
5231 return;
5232 list_for_each_entry(codec, &bus->codec_list, list) {
e581f3db
TI		 5233 if (hda_codec_is_power_on(codec) &&
5234 codec->patch_ops.reboot_notify)
fb8d1a34
TI		 5235 codec->patch_ops.reboot_notify(codec);
5236 }
5237}
8f217a22 5238EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
fb8d1a34 5239
d5191e50
TI		 5240/**
5241 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
1da177e4 5242 */
0ba21762
TI		 5243int snd_hda_multi_out_dig_open(struct hda_codec *codec,
5244 struct hda_multi_out *mout)
1da177e4 5245{
62932df8 5246 mutex_lock(&codec->spdif_mutex);
5930ca41
TI		 5247 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
5248 /* already opened as analog dup; reset it once */
2f72853c 5249 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4 5250 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
62932df8 5251 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 5252 return 0;
5253}
ff7a3267 5254EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
1da177e4 5255
d5191e50
TI		 5256/**
5257 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
5258 */
6b97eb45
TI		 5259int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
5260 struct hda_multi_out *mout,
5261 unsigned int stream_tag,
5262 unsigned int format,
5263 struct snd_pcm_substream *substream)
5264{
5265 mutex_lock(&codec->spdif_mutex);
5266 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
5267 mutex_unlock(&codec->spdif_mutex);
5268 return 0;
5269}
ff7a3267 5270EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
6b97eb45 5271
d5191e50
TI		 5272/**
5273 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
5274 */
9411e21c
TI		 5275int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
5276 struct hda_multi_out *mout)
5277{
5278 mutex_lock(&codec->spdif_mutex);
5279 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5280 mutex_unlock(&codec->spdif_mutex);
5281 return 0;
5282}
5283EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
5284
d5191e50
TI		 5285/**
5286 * snd_hda_multi_out_dig_close - release the digital out stream
1da177e4 5287 */
0ba21762
TI		 5288int snd_hda_multi_out_dig_close(struct hda_codec *codec,
5289 struct hda_multi_out *mout)
1da177e4 5290{
62932df8 5291 mutex_lock(&codec->spdif_mutex);
1da177e4 5292 mout->dig_out_used = 0;
62932df8 5293 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 5294 return 0;
5295}
ff7a3267 5296EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
1da177e4 5297
d5191e50
TI		 5298/**
5299 * snd_hda_multi_out_analog_open - open analog outputs
5300 *
5301 * Open analog outputs and set up the hw-constraints.
5302 * If the digital outputs can be opened as slave, open the digital
5303 * outputs, too.
1da177e4 5304 */
0ba21762
TI		 5305int snd_hda_multi_out_analog_open(struct hda_codec *codec,
5306 struct hda_multi_out *mout,
9a08160b
TI		 5307 struct snd_pcm_substream *substream,
5308 struct hda_pcm_stream *hinfo)
5309{
5310 struct snd_pcm_runtime *runtime = substream->runtime;
5311 runtime->hw.channels_max = mout->max_channels;
5312 if (mout->dig_out_nid) {
5313 if (!mout->analog_rates) {
5314 mout->analog_rates = hinfo->rates;
5315 mout->analog_formats = hinfo->formats;
5316 mout->analog_maxbps = hinfo->maxbps;
5317 } else {
5318 runtime->hw.rates = mout->analog_rates;
5319 runtime->hw.formats = mout->analog_formats;
5320 hinfo->maxbps = mout->analog_maxbps;
5321 }
5322 if (!mout->spdif_rates) {
5323 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
5324 &mout->spdif_rates,
5325 &mout->spdif_formats,
5326 &mout->spdif_maxbps);
5327 }
5328 mutex_lock(&codec->spdif_mutex);
5329 if (mout->share_spdif) {
022b466f
TI		 5330 if ((runtime->hw.rates & mout->spdif_rates) &&
5331 (runtime->hw.formats & mout->spdif_formats)) {
5332 runtime->hw.rates &= mout->spdif_rates;
5333 runtime->hw.formats &= mout->spdif_formats;
5334 if (mout->spdif_maxbps < hinfo->maxbps)
5335 hinfo->maxbps = mout->spdif_maxbps;
5336 } else {
5337 mout->share_spdif = 0;
5338 /* FIXME: need notify? */
5339 }
9a08160b 5340 }
eaa9985b 5341 mutex_unlock(&codec->spdif_mutex);
9a08160b 5342 }
1da177e4
LT		 5343 return snd_pcm_hw_constraint_step(substream->runtime, 0,
5344 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
5345}
ff7a3267 5346EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
1da177e4 5347
d5191e50
TI		 5348/**
5349 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
5350 *
5351 * Set up the i/o for analog out.
5352 * When the digital out is available, copy the front out to digital out, too.
1da177e4 5353 */
0ba21762
TI		 5354int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
5355 struct hda_multi_out *mout,
1da177e4
LT		 5356 unsigned int stream_tag,
5357 unsigned int format,
c8b6bf9b 5358 struct snd_pcm_substream *substream)
1da177e4 5359{
dda14410 5360 const hda_nid_t *nids = mout->dac_nids;
1da177e4 5361 int chs = substream->runtime->channels;
e3245cdd 5362 struct hda_spdif_out *spdif;
1da177e4
LT		 5363 int i;
5364
62932df8 5365 mutex_lock(&codec->spdif_mutex);
e3245cdd 5366 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
9a08160b
TI		 5367 if (mout->dig_out_nid && mout->share_spdif &&
5368 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
1da177e4 5369 if (chs == 2 &&
0ba21762
TI		 5370 snd_hda_is_supported_format(codec, mout->dig_out_nid,
5371 format) &&
7c935976 5372 !(spdif->status & IEC958_AES0_NONAUDIO)) {
1da177e4 5373 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
6b97eb45
TI		 5374 setup_dig_out_stream(codec, mout->dig_out_nid,
5375 stream_tag, format);
1da177e4
LT		 5376 } else {
5377 mout->dig_out_used = 0;
2f72853c 5378 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 5379 }
5380 }
62932df8 5381 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 5382
5383 /* front */
0ba21762
TI		 5384 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
5385 0, format);
d29240ce
TI		 5386 if (!mout->no_share_stream &&
5387 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
1da177e4 5388 /* headphone out will just decode front left/right (stereo) */
0ba21762
TI		 5389 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
5390 0, format);
82bc955f 5391 /* extra outputs copied from front */
a06dbfc2
TI		 5392 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5393 if (!mout->no_share_stream && mout->hp_out_nid[i])
5394 snd_hda_codec_setup_stream(codec,
5395 mout->hp_out_nid[i],
5396 stream_tag, 0, format);
82bc955f 5397
1da177e4
LT		 5398 /* surrounds */
5399 for (i = 1; i < mout->num_dacs; i++) {
4b3acaf5 5400 if (chs >= (i + 1) * 2) /* independent out */
0ba21762
TI		 5401 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5402 i * 2, format);
d29240ce 5403 else if (!mout->no_share_stream) /* copy front */
0ba21762
TI		 5404 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5405 0, format);
1da177e4 5406 }
cd4035e8
DH		 5407
5408 /* extra surrounds */
5409 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) {
5410 int ch = 0;
5411 if (!mout->extra_out_nid[i])
5412 break;
5413 if (chs >= (i + 1) * 2)
5414 ch = i * 2;
5415 else if (!mout->no_share_stream)
5416 break;
5417 snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i],
5418 stream_tag, ch, format);
5419 }
5420
1da177e4
LT		 5421 return 0;
5422}
ff7a3267 5423EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
1da177e4 5424
d5191e50
TI		 5425/**
5426 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
1da177e4 5427 */
0ba21762
TI		 5428int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
5429 struct hda_multi_out *mout)
1da177e4 5430{
dda14410 5431 const hda_nid_t *nids = mout->dac_nids;
1da177e4
LT		 5432 int i;
5433
5434 for (i = 0; i < mout->num_dacs; i++)
888afa15 5435 snd_hda_codec_cleanup_stream(codec, nids[i]);
1da177e4 5436 if (mout->hp_nid)
888afa15 5437 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
a06dbfc2
TI		 5438 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5439 if (mout->hp_out_nid[i])
5440 snd_hda_codec_cleanup_stream(codec,
5441 mout->hp_out_nid[i]);
82bc955f
TI		 5442 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
5443 if (mout->extra_out_nid[i])
888afa15
TI		 5444 snd_hda_codec_cleanup_stream(codec,
5445 mout->extra_out_nid[i]);
62932df8 5446 mutex_lock(&codec->spdif_mutex);
1da177e4 5447 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
2f72853c 5448 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 5449 mout->dig_out_used = 0;
5450 }
62932df8 5451 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 5452 return 0;
5453}
ff7a3267 5454EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
1da177e4 5455
4740860b
TI		 5456/**
5457 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
5458 *
5459 * Guess the suitable VREF pin bits to be set as the pin-control value.
5460 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
5461 */
5462unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
5463{
5464 unsigned int pincap;
5465 unsigned int oldval;
5466 oldval = snd_hda_codec_read(codec, pin, 0,
5467 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5468 pincap = snd_hda_query_pin_caps(codec, pin);
5469 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5470 /* Exception: if the default pin setup is vref50, we give it priority */
5471 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
5472 return AC_PINCTL_VREF_80;
5473 else if (pincap & AC_PINCAP_VREF_50)
5474 return AC_PINCTL_VREF_50;
5475 else if (pincap & AC_PINCAP_VREF_100)
5476 return AC_PINCTL_VREF_100;
5477 else if (pincap & AC_PINCAP_VREF_GRD)
5478 return AC_PINCTL_VREF_GRD;
5479 return AC_PINCTL_VREF_HIZ;
5480}
5481EXPORT_SYMBOL_HDA(snd_hda_get_default_vref);
5482
62f3a2f7
TI		 5483/* correct the pin ctl value for matching with the pin cap */
5484unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
5485 hda_nid_t pin, unsigned int val)
5486{
5487 static unsigned int cap_lists[][2] = {
5488 { AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
5489 { AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
5490 { AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
5491 { AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
5492 };
5493 unsigned int cap;
5494
5495 if (!val)
5496 return 0;
5497 cap = snd_hda_query_pin_caps(codec, pin);
5498 if (!cap)
5499 return val; /* don't know what to do... */
5500
5501 if (val & AC_PINCTL_OUT_EN) {
5502 if (!(cap & AC_PINCAP_OUT))
5503 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5504 else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
5505 val &= ~AC_PINCTL_HP_EN;
5506 }
5507
5508 if (val & AC_PINCTL_IN_EN) {
5509 if (!(cap & AC_PINCAP_IN))
5510 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
5511 else {
5512 unsigned int vcap, vref;
5513 int i;
5514 vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5515 vref = val & AC_PINCTL_VREFEN;
5516 for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
5517 if (vref == cap_lists[i][0] &&
5518 !(vcap & cap_lists[i][1])) {
5519 if (i == ARRAY_SIZE(cap_lists) - 1)
5520 vref = AC_PINCTL_VREF_HIZ;
5521 else
5522 vref = cap_lists[i + 1][0];
5523 }
5524 }
5525 val &= ~AC_PINCTL_VREFEN;
5526 val |= vref;
5527 }
5528 }
5529
5530 return val;
5531}
5532EXPORT_SYMBOL_HDA(snd_hda_correct_pin_ctl);
5533
cdd03ced
TI		 5534int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
5535 unsigned int val, bool cached)
5536{
62f3a2f7 5537 val = snd_hda_correct_pin_ctl(codec, pin, val);
d7fdc00a 5538 snd_hda_codec_set_pin_target(codec, pin, val);
cdd03ced
TI		 5539 if (cached)
5540 return snd_hda_codec_update_cache(codec, pin, 0,
5541 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5542 else
5543 return snd_hda_codec_write(codec, pin, 0,
5544 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5545}
5546EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl);
5547
990061c2
TI		 5548/**
5549 * snd_hda_add_imux_item - Add an item to input_mux
5550 *
5551 * When the same label is used already in the existing items, the number
5552 * suffix is appended to the label. This label index number is stored
5553 * to type_idx when non-NULL pointer is given.
5554 */
10a20af7
TI		 5555int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5556 int index, int *type_idx)
5557{
5558 int i, label_idx = 0;
5559 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5560 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5561 return -EINVAL;
5562 }
5563 for (i = 0; i < imux->num_items; i++) {
5564 if (!strncmp(label, imux->items[i].label, strlen(label)))
5565 label_idx++;
d7b1ae9d 5566 }
10a20af7
TI		 5567 if (type_idx)
5568 *type_idx = label_idx;
5569 if (label_idx > 0)
5570 snprintf(imux->items[imux->num_items].label,
5571 sizeof(imux->items[imux->num_items].label),
5572 "%s %d", label, label_idx);
b5786e85 5573 else
10a20af7
TI		 5574 strlcpy(imux->items[imux->num_items].label, label,
5575 sizeof(imux->items[imux->num_items].label));
5576 imux->items[imux->num_items].index = index;
5577 imux->num_items++;
5578 return 0;
d7b1ae9d 5579}
10a20af7 5580EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
d7b1ae9d 5581
4a471b7d 5582
1da177e4
LT		 5583#ifdef CONFIG_PM
5584/*
5585 * power management
5586 */
5587
5588/**
5589 * snd_hda_suspend - suspend the codecs
5590 * @bus: the HDA bus
1da177e4
LT		 5591 *
5592 * Returns 0 if successful.
5593 */
8dd78330 5594int snd_hda_suspend(struct hda_bus *bus)
1da177e4 5595{
0ba21762 5596 struct hda_codec *codec;
1da177e4 5597
0ba21762 5598 list_for_each_entry(codec, &bus->codec_list, list) {
26a6cb6c 5599 cancel_delayed_work_sync(&codec->jackpoll_work);
e581f3db 5600 if (hda_codec_is_power_on(codec))
d17344b3 5601 hda_call_codec_suspend(codec, false);
1da177e4
LT		 5602 }
5603 return 0;
5604}
ff7a3267 5605EXPORT_SYMBOL_HDA(snd_hda_suspend);
1da177e4
LT		 5606
5607/**
5608 * snd_hda_resume - resume the codecs
5609 * @bus: the HDA bus
1da177e4
LT		 5610 *
5611 * Returns 0 if successful.
5612 */
5613int snd_hda_resume(struct hda_bus *bus)
5614{
0ba21762 5615 struct hda_codec *codec;
1da177e4 5616
0ba21762 5617 list_for_each_entry(codec, &bus->codec_list, list) {
7f30830b 5618 hda_call_codec_resume(codec);
1da177e4 5619 }
1da177e4
LT		 5620 return 0;
5621}
ff7a3267 5622EXPORT_SYMBOL_HDA(snd_hda_resume);
1289e9e8 5623#endif /* CONFIG_PM */
b2e18597
TI		 5624
5625/*
5626 * generic arrays
5627 */
5628
d5191e50
TI		 5629/**
5630 * snd_array_new - get a new element from the given array
5631 * @array: the array object
28aedaf7 5632 *
d5191e50
TI		 5633 * Get a new element from the given array. If it exceeds the
5634 * pre-allocated array size, re-allocate the array.
5635 *
5636 * Returns NULL if allocation failed.
b2e18597
TI		 5637 */
5638void *snd_array_new(struct snd_array *array)
5639{
12f17717
TI		 5640 if (snd_BUG_ON(!array->elem_size))
5641 return NULL;
b2e18597
TI		 5642 if (array->used >= array->alloced) {
5643 int num = array->alloced + array->alloc_align;
3101ba03 5644 int size = (num + 1) * array->elem_size;
b910d9ae
TI		 5645 void *nlist;
5646 if (snd_BUG_ON(num >= 4096))
5647 return NULL;
5265fd9a 5648 nlist = krealloc(array->list, size, GFP_KERNEL | __GFP_ZERO);
b2e18597
TI		 5649 if (!nlist)
5650 return NULL;
b2e18597
TI		 5651 array->list = nlist;
5652 array->alloced = num;
5653 }
f43aa025 5654 return snd_array_elem(array, array->used++);
b2e18597 5655}
ff7a3267 5656EXPORT_SYMBOL_HDA(snd_array_new);
b2e18597 5657
d5191e50
TI		 5658/**
5659 * snd_array_free - free the given array elements
5660 * @array: the array object
5661 */
b2e18597
TI		 5662void snd_array_free(struct snd_array *array)
5663{
5664 kfree(array->list);
5665 array->used = 0;
5666 array->alloced = 0;
5667 array->list = NULL;
5668}
ff7a3267 5669EXPORT_SYMBOL_HDA(snd_array_free);
b2022266 5670
d5191e50
TI		 5671/**
5672 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5673 * @pcm: PCM caps bits
5674 * @buf: the string buffer to write
5675 * @buflen: the max buffer length
5676 *
5677 * used by hda_proc.c and hda_eld.c
5678 */
b2022266
TI		 5679void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5680{
5681 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5682 int i, j;
5683
5684 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5685 if (pcm & (AC_SUPPCM_BITS_8 << i))
5686 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5687
5688 buf[j] = '\0'; /* necessary when j == 0 */
5689}
ff7a3267 5690EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
1289e9e8
TI		 5691
5692MODULE_DESCRIPTION("HDA codec core");
5693MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 1.018896 seconds and 5 git commands to generate.