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