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