projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'fix/hda' into topic/hda
[deliverable/linux.git] / sound / pci / hda / hda_codec.c
CommitLineData
1da177e4
LT		 1/*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
5 *
6 *
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
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
aeb4b88e
TI		 2334typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2335
2336/* apply the function to all matching slave ctls in the mixer list */
2337static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2338 map_slave_func_t func, void *data)
2339{
2340 struct hda_nid_item *items;
2341 const char * const *s;
2342 int i, err;
2343
2344 items = codec->mixers.list;
2345 for (i = 0; i < codec->mixers.used; i++) {
2346 struct snd_kcontrol *sctl = items[i].kctl;
2347 if (!sctl || !sctl->id.name ||
2348 sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2349 continue;
2350 for (s = slaves; *s; s++) {
2351 if (!strcmp(sctl->id.name, *s)) {
2352 err = func(data, sctl);
2353 if (err)
2354 return err;
2355 break;
2356 }
2357 }
2358 }
2359 return 0;
2360}
2361
2362static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2363{
2364 return 1;
2365}
2366
d5191e50
TI		 2367/**
2368 * snd_hda_add_vmaster - create a virtual master control and add slaves
2369 * @codec: HD-audio codec
2370 * @name: vmaster control name
2371 * @tlv: TLV data (optional)
2372 * @slaves: slave control names (optional)
2373 *
2374 * Create a virtual master control with the given name. The TLV data
2375 * must be either NULL or a valid data.
2376 *
2377 * @slaves is a NULL-terminated array of strings, each of which is a
2378 * slave control name. All controls with these names are assigned to
2379 * the new virtual master control.
2380 *
2381 * This function returns zero if successful or a negative error code.
2382 */
2134ea4f 2383int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
ea734963 2384 unsigned int *tlv, const char * const *slaves)
2134ea4f
TI		 2385{
2386 struct snd_kcontrol *kctl;
2134ea4f
TI		 2387 int err;
2388
aeb4b88e
TI		 2389 err = map_slaves(codec, slaves, check_slave_present, NULL);
2390 if (err != 1) {
2f085549
TI		 2391 snd_printdd("No slave found for %s\n", name);
2392 return 0;
2393 }
2134ea4f
TI		 2394 kctl = snd_ctl_make_virtual_master(name, tlv);
2395 if (!kctl)
2396 return -ENOMEM;
3911a4c1 2397 err = snd_hda_ctl_add(codec, 0, kctl);
2134ea4f
TI		 2398 if (err < 0)
2399 return err;
28aedaf7 2400
aeb4b88e
TI		 2401 err = map_slaves(codec, slaves, (map_slave_func_t)snd_ctl_add_slave,
2402 kctl);
2403 if (err < 0)
2404 return err;
2134ea4f
TI		 2405 return 0;
2406}
ff7a3267 2407EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
2134ea4f 2408
d5191e50
TI		 2409/**
2410 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2411 *
2412 * The control element is supposed to have the private_value field
2413 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2414 */
0ba21762
TI		 2415int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2416 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 2417{
2418 int chs = get_amp_channels(kcontrol);
2419
2420 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2421 uinfo->count = chs == 3 ? 2 : 1;
2422 uinfo->value.integer.min = 0;
2423 uinfo->value.integer.max = 1;
2424 return 0;
2425}
ff7a3267 2426EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1da177e4 2427
d5191e50
TI		 2428/**
2429 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2430 *
2431 * The control element is supposed to have the private_value field
2432 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2433 */
0ba21762
TI		 2434int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2435 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2436{
2437 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2438 hda_nid_t nid = get_amp_nid(kcontrol);
2439 int chs = get_amp_channels(kcontrol);
2440 int dir = get_amp_direction(kcontrol);
2441 int idx = get_amp_index(kcontrol);
2442 long *valp = ucontrol->value.integer.value;
2443
2444 if (chs & 1)
0ba21762 2445 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
47fd830a 2446 HDA_AMP_MUTE) ? 0 : 1;
1da177e4 2447 if (chs & 2)
0ba21762 2448 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
47fd830a 2449 HDA_AMP_MUTE) ? 0 : 1;
1da177e4
LT		 2450 return 0;
2451}
ff7a3267 2452EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1da177e4 2453
d5191e50
TI		 2454/**
2455 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2456 *
2457 * The control element is supposed to have the private_value field
2458 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2459 */
0ba21762
TI		 2460int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2461 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2462{
2463 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2464 hda_nid_t nid = get_amp_nid(kcontrol);
2465 int chs = get_amp_channels(kcontrol);
2466 int dir = get_amp_direction(kcontrol);
2467 int idx = get_amp_index(kcontrol);
1da177e4
LT		 2468 long *valp = ucontrol->value.integer.value;
2469 int change = 0;
2470
cb53c626 2471 snd_hda_power_up(codec);
b9f5a89c 2472 if (chs & 1) {
4a19faee 2473 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
47fd830a
TI		 2474 HDA_AMP_MUTE,
2475 *valp ? 0 : HDA_AMP_MUTE);
b9f5a89c
NG		 2476 valp++;
2477 }
4a19faee
TI		 2478 if (chs & 2)
2479 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
47fd830a
TI		 2480 HDA_AMP_MUTE,
2481 *valp ? 0 : HDA_AMP_MUTE);
9e5341b9 2482 hda_call_check_power_status(codec, nid);
cb53c626 2483 snd_hda_power_down(codec);
1da177e4
LT		 2484 return change;
2485}
ff7a3267 2486EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1da177e4 2487
67d634c0 2488#ifdef CONFIG_SND_HDA_INPUT_BEEP
d5191e50
TI		 2489/**
2490 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2491 *
2492 * This function calls snd_hda_enable_beep_device(), which behaves differently
2493 * depending on beep_mode option.
2494 */
123c07ae
JK		 2495int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2496 struct snd_ctl_elem_value *ucontrol)
2497{
2498 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2499 long *valp = ucontrol->value.integer.value;
2500
2501 snd_hda_enable_beep_device(codec, *valp);
2502 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2503}
2504EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
67d634c0 2505#endif /* CONFIG_SND_HDA_INPUT_BEEP */
123c07ae 2506
985be54b
TI		 2507/*
2508 * bound volume controls
2509 *
2510 * bind multiple volumes (# indices, from 0)
2511 */
2512
2513#define AMP_VAL_IDX_SHIFT 19
2514#define AMP_VAL_IDX_MASK (0x0f<<19)
2515
d5191e50
TI		 2516/**
2517 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2518 *
2519 * The control element is supposed to have the private_value field
2520 * set up via HDA_BIND_MUTE*() macros.
2521 */
0ba21762
TI		 2522int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2523 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 2524{
2525 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2526 unsigned long pval;
2527 int err;
2528
5a9e02e9 2529 mutex_lock(&codec->control_mutex);
985be54b
TI		 2530 pval = kcontrol->private_value;
2531 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2532 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2533 kcontrol->private_value = pval;
5a9e02e9 2534 mutex_unlock(&codec->control_mutex);
985be54b
TI		 2535 return err;
2536}
ff7a3267 2537EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
985be54b 2538
d5191e50
TI		 2539/**
2540 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2541 *
2542 * The control element is supposed to have the private_value field
2543 * set up via HDA_BIND_MUTE*() macros.
2544 */
0ba21762
TI		 2545int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2546 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 2547{
2548 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2549 unsigned long pval;
2550 int i, indices, err = 0, change = 0;
2551
5a9e02e9 2552 mutex_lock(&codec->control_mutex);
985be54b
TI		 2553 pval = kcontrol->private_value;
2554 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2555 for (i = 0; i < indices; i++) {
0ba21762
TI		 2556 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2557 (i << AMP_VAL_IDX_SHIFT);
985be54b
TI		 2558 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2559 if (err < 0)
2560 break;
2561 change |= err;
2562 }
2563 kcontrol->private_value = pval;
5a9e02e9 2564 mutex_unlock(&codec->control_mutex);
985be54b
TI		 2565 return err < 0 ? err : change;
2566}
ff7a3267 2567EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
985be54b 2568
d5191e50
TI		 2569/**
2570 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2571 *
2572 * The control element is supposed to have the private_value field
2573 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
532d5381
TI		 2574 */
2575int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2576 struct snd_ctl_elem_info *uinfo)
2577{
2578 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2579 struct hda_bind_ctls *c;
2580 int err;
2581
5a9e02e9 2582 mutex_lock(&codec->control_mutex);
14c65f98 2583 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2584 kcontrol->private_value = *c->values;
2585 err = c->ops->info(kcontrol, uinfo);
2586 kcontrol->private_value = (long)c;
5a9e02e9 2587 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2588 return err;
2589}
ff7a3267 2590EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
532d5381 2591
d5191e50
TI		 2592/**
2593 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2594 *
2595 * The control element is supposed to have the private_value field
2596 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2597 */
532d5381
TI		 2598int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2599 struct snd_ctl_elem_value *ucontrol)
2600{
2601 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2602 struct hda_bind_ctls *c;
2603 int err;
2604
5a9e02e9 2605 mutex_lock(&codec->control_mutex);
14c65f98 2606 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2607 kcontrol->private_value = *c->values;
2608 err = c->ops->get(kcontrol, ucontrol);
2609 kcontrol->private_value = (long)c;
5a9e02e9 2610 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2611 return err;
2612}
ff7a3267 2613EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
532d5381 2614
d5191e50
TI		 2615/**
2616 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2617 *
2618 * The control element is supposed to have the private_value field
2619 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2620 */
532d5381
TI		 2621int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2622 struct snd_ctl_elem_value *ucontrol)
2623{
2624 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2625 struct hda_bind_ctls *c;
2626 unsigned long *vals;
2627 int err = 0, change = 0;
2628
5a9e02e9 2629 mutex_lock(&codec->control_mutex);
14c65f98 2630 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2631 for (vals = c->values; *vals; vals++) {
2632 kcontrol->private_value = *vals;
2633 err = c->ops->put(kcontrol, ucontrol);
2634 if (err < 0)
2635 break;
2636 change |= err;
2637 }
2638 kcontrol->private_value = (long)c;
5a9e02e9 2639 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2640 return err < 0 ? err : change;
2641}
ff7a3267 2642EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
532d5381 2643
d5191e50
TI		 2644/**
2645 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2646 *
2647 * The control element is supposed to have the private_value field
2648 * set up via HDA_BIND_VOL() macro.
2649 */
532d5381
TI		 2650int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2651 unsigned int size, unsigned int __user *tlv)
2652{
2653 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2654 struct hda_bind_ctls *c;
2655 int err;
2656
5a9e02e9 2657 mutex_lock(&codec->control_mutex);
14c65f98 2658 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2659 kcontrol->private_value = *c->values;
2660 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2661 kcontrol->private_value = (long)c;
5a9e02e9 2662 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2663 return err;
2664}
ff7a3267 2665EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
532d5381
TI		 2666
2667struct hda_ctl_ops snd_hda_bind_vol = {
2668 .info = snd_hda_mixer_amp_volume_info,
2669 .get = snd_hda_mixer_amp_volume_get,
2670 .put = snd_hda_mixer_amp_volume_put,
2671 .tlv = snd_hda_mixer_amp_tlv
2672};
ff7a3267 2673EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
532d5381
TI		 2674
2675struct hda_ctl_ops snd_hda_bind_sw = {
2676 .info = snd_hda_mixer_amp_switch_info,
2677 .get = snd_hda_mixer_amp_switch_get,
2678 .put = snd_hda_mixer_amp_switch_put,
2679 .tlv = snd_hda_mixer_amp_tlv
2680};
ff7a3267 2681EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
532d5381 2682
1da177e4
LT		 2683/*
2684 * SPDIF out controls
2685 */
2686
0ba21762
TI		 2687static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2688 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 2689{
2690 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2691 uinfo->count = 1;
2692 return 0;
2693}
2694
0ba21762
TI		 2695static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2696 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2697{
2698 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2699 IEC958_AES0_NONAUDIO |
2700 IEC958_AES0_CON_EMPHASIS_5015 |
2701 IEC958_AES0_CON_NOT_COPYRIGHT;
2702 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2703 IEC958_AES1_CON_ORIGINAL;
2704 return 0;
2705}
2706
0ba21762
TI		 2707static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2708 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2709{
2710 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2711 IEC958_AES0_NONAUDIO |
2712 IEC958_AES0_PRO_EMPHASIS_5015;
2713 return 0;
2714}
2715
0ba21762
TI		 2716static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2717 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2718{
2719 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976
SW		 2720 int idx = kcontrol->private_value;
2721 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
1da177e4 2722
7c935976
SW		 2723 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2724 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2725 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2726 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
1da177e4
LT		 2727
2728 return 0;
2729}
2730
2731/* convert from SPDIF status bits to HDA SPDIF bits
2732 * bit 0 (DigEn) is always set zero (to be filled later)
2733 */
2734static unsigned short convert_from_spdif_status(unsigned int sbits)
2735{
2736 unsigned short val = 0;
2737
2738 if (sbits & IEC958_AES0_PROFESSIONAL)
0ba21762 2739 val |= AC_DIG1_PROFESSIONAL;
1da177e4 2740 if (sbits & IEC958_AES0_NONAUDIO)
0ba21762 2741 val |= AC_DIG1_NONAUDIO;
1da177e4 2742 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762
TI		 2743 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2744 IEC958_AES0_PRO_EMPHASIS_5015)
2745 val |= AC_DIG1_EMPHASIS;
1da177e4 2746 } else {
0ba21762
TI		 2747 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2748 IEC958_AES0_CON_EMPHASIS_5015)
2749 val |= AC_DIG1_EMPHASIS;
2750 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2751 val |= AC_DIG1_COPYRIGHT;
1da177e4 2752 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
0ba21762 2753 val |= AC_DIG1_LEVEL;
1da177e4
LT		 2754 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2755 }
2756 return val;
2757}
2758
2759/* convert to SPDIF status bits from HDA SPDIF bits
2760 */
2761static unsigned int convert_to_spdif_status(unsigned short val)
2762{
2763 unsigned int sbits = 0;
2764
0ba21762 2765 if (val & AC_DIG1_NONAUDIO)
1da177e4 2766 sbits |= IEC958_AES0_NONAUDIO;
0ba21762 2767 if (val & AC_DIG1_PROFESSIONAL)
1da177e4
LT		 2768 sbits |= IEC958_AES0_PROFESSIONAL;
2769 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762 2770 if (sbits & AC_DIG1_EMPHASIS)
1da177e4
LT		 2771 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2772 } else {
0ba21762 2773 if (val & AC_DIG1_EMPHASIS)
1da177e4 2774 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
0ba21762 2775 if (!(val & AC_DIG1_COPYRIGHT))
1da177e4 2776 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
0ba21762 2777 if (val & AC_DIG1_LEVEL)
1da177e4
LT		 2778 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2779 sbits |= val & (0x7f << 8);
2780 }
2781 return sbits;
2782}
2783
2f72853c
TI		 2784/* set digital convert verbs both for the given NID and its slaves */
2785static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2786 int verb, int val)
2787{
dda14410 2788 const hda_nid_t *d;
2f72853c 2789
9e976976 2790 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2f72853c
TI		 2791 d = codec->slave_dig_outs;
2792 if (!d)
2793 return;
2794 for (; *d; d++)
9e976976 2795 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2f72853c
TI		 2796}
2797
2798static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2799 int dig1, int dig2)
2800{
2801 if (dig1 != -1)
2802 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2803 if (dig2 != -1)
2804 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2805}
2806
0ba21762
TI		 2807static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2808 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2809{
2810 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976
SW		 2811 int idx = kcontrol->private_value;
2812 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2813 hda_nid_t nid = spdif->nid;
1da177e4
LT		 2814 unsigned short val;
2815 int change;
2816
62932df8 2817 mutex_lock(&codec->spdif_mutex);
7c935976 2818 spdif->status = ucontrol->value.iec958.status[0] |
1da177e4
LT		 2819 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2820 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2821 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
7c935976
SW		 2822 val = convert_from_spdif_status(spdif->status);
2823 val |= spdif->ctls & 1;
2824 change = spdif->ctls != val;
2825 spdif->ctls = val;
74b654c9 2826 if (change && nid != (u16)-1)
2f72853c 2827 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
62932df8 2828 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2829 return change;
2830}
2831
a5ce8890 2832#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1da177e4 2833
0ba21762
TI		 2834static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2835 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2836{
2837 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976
SW		 2838 int idx = kcontrol->private_value;
2839 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
1da177e4 2840
7c935976 2841 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
1da177e4
LT		 2842 return 0;
2843}
2844
74b654c9
SW		 2845static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2846 int dig1, int dig2)
2847{
2848 set_dig_out_convert(codec, nid, dig1, dig2);
2849 /* unmute amp switch (if any) */
2850 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2851 (dig1 & AC_DIG1_ENABLE))
2852 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2853 HDA_AMP_MUTE, 0);
2854}
2855
0ba21762
TI		 2856static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2857 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2858{
2859 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976
SW		 2860 int idx = kcontrol->private_value;
2861 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2862 hda_nid_t nid = spdif->nid;
1da177e4
LT		 2863 unsigned short val;
2864 int change;
2865
62932df8 2866 mutex_lock(&codec->spdif_mutex);
7c935976 2867 val = spdif->ctls & ~AC_DIG1_ENABLE;
1da177e4 2868 if (ucontrol->value.integer.value[0])
0ba21762 2869 val |= AC_DIG1_ENABLE;
7c935976 2870 change = spdif->ctls != val;
74b654c9
SW		 2871 spdif->ctls = val;
2872 if (change && nid != (u16)-1)
2873 set_spdif_ctls(codec, nid, val & 0xff, -1);
62932df8 2874 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2875 return change;
2876}
2877
c8b6bf9b 2878static struct snd_kcontrol_new dig_mixes[] = {
1da177e4
LT		 2879 {
2880 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2881 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 2882 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
1da177e4
LT		 2883 .info = snd_hda_spdif_mask_info,
2884 .get = snd_hda_spdif_cmask_get,
2885 },
2886 {
2887 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2888 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 2889 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
1da177e4
LT		 2890 .info = snd_hda_spdif_mask_info,
2891 .get = snd_hda_spdif_pmask_get,
2892 },
2893 {
2894 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 2895 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1da177e4
LT		 2896 .info = snd_hda_spdif_mask_info,
2897 .get = snd_hda_spdif_default_get,
2898 .put = snd_hda_spdif_default_put,
2899 },
2900 {
2901 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 2902 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1da177e4
LT		 2903 .info = snd_hda_spdif_out_switch_info,
2904 .get = snd_hda_spdif_out_switch_get,
2905 .put = snd_hda_spdif_out_switch_put,
2906 },
2907 { } /* end */
2908};
2909
2910/**
2911 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2912 * @codec: the HDA codec
2913 * @nid: audio out widget NID
2914 *
2915 * Creates controls related with the SPDIF output.
2916 * Called from each patch supporting the SPDIF out.
2917 *
2918 * Returns 0 if successful, or a negative error code.
2919 */
74b654c9
SW		 2920int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
2921 hda_nid_t associated_nid,
2922 hda_nid_t cvt_nid)
1da177e4
LT		 2923{
2924 int err;
c8b6bf9b
TI		 2925 struct snd_kcontrol *kctl;
2926 struct snd_kcontrol_new *dig_mix;
09f99701 2927 int idx;
7c935976 2928 struct hda_spdif_out *spdif;
1da177e4 2929
1afe206a
TI		 2930 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
2931 if (idx < 0) {
09f99701
TI		 2932 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2933 return -EBUSY;
2934 }
7c935976 2935 spdif = snd_array_new(&codec->spdif_out);
1da177e4
LT		 2936 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2937 kctl = snd_ctl_new1(dig_mix, codec);
b91f080f
TI		 2938 if (!kctl)
2939 return -ENOMEM;
09f99701 2940 kctl->id.index = idx;
7c935976 2941 kctl->private_value = codec->spdif_out.used - 1;
74b654c9 2942 err = snd_hda_ctl_add(codec, associated_nid, kctl);
0ba21762 2943 if (err < 0)
1da177e4
LT		 2944 return err;
2945 }
74b654c9
SW		 2946 spdif->nid = cvt_nid;
2947 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
7c935976
SW		 2948 AC_VERB_GET_DIGI_CONVERT_1, 0);
2949 spdif->status = convert_to_spdif_status(spdif->ctls);
1da177e4
LT		 2950 return 0;
2951}
ff7a3267 2952EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1da177e4 2953
7c935976
SW		 2954struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
2955 hda_nid_t nid)
2956{
2957 int i;
2958 for (i = 0; i < codec->spdif_out.used; i++) {
2959 struct hda_spdif_out *spdif =
2960 snd_array_elem(&codec->spdif_out, i);
2961 if (spdif->nid == nid)
2962 return spdif;
2963 }
2964 return NULL;
2965}
2966EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
2967
74b654c9
SW		 2968void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
2969{
2970 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2971
2972 mutex_lock(&codec->spdif_mutex);
2973 spdif->nid = (u16)-1;
2974 mutex_unlock(&codec->spdif_mutex);
2975}
2976EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
2977
2978void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
2979{
2980 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2981 unsigned short val;
2982
2983 mutex_lock(&codec->spdif_mutex);
2984 if (spdif->nid != nid) {
2985 spdif->nid = nid;
2986 val = spdif->ctls;
2987 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
2988 }
2989 mutex_unlock(&codec->spdif_mutex);
2990}
2991EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
2992
9a08160b
TI		 2993/*
2994 * SPDIF sharing with analog output
2995 */
2996static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2997 struct snd_ctl_elem_value *ucontrol)
2998{
2999 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3000 ucontrol->value.integer.value[0] = mout->share_spdif;
3001 return 0;
3002}
3003
3004static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3005 struct snd_ctl_elem_value *ucontrol)
3006{
3007 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3008 mout->share_spdif = !!ucontrol->value.integer.value[0];
3009 return 0;
3010}
3011
3012static struct snd_kcontrol_new spdif_share_sw = {
3013 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3014 .name = "IEC958 Default PCM Playback Switch",
3015 .info = snd_ctl_boolean_mono_info,
3016 .get = spdif_share_sw_get,
3017 .put = spdif_share_sw_put,
3018};
3019
d5191e50
TI		 3020/**
3021 * snd_hda_create_spdif_share_sw - create Default PCM switch
3022 * @codec: the HDA codec
3023 * @mout: multi-out instance
3024 */
9a08160b
TI		 3025int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3026 struct hda_multi_out *mout)
3027{
3028 if (!mout->dig_out_nid)
3029 return 0;
3030 /* ATTENTION: here mout is passed as private_data, instead of codec */
3911a4c1
JK		 3031 return snd_hda_ctl_add(codec, mout->dig_out_nid,
3032 snd_ctl_new1(&spdif_share_sw, mout));
9a08160b 3033}
ff7a3267 3034EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
9a08160b 3035
1da177e4
LT		 3036/*
3037 * SPDIF input
3038 */
3039
3040#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3041
0ba21762
TI		 3042static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3043 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3044{
3045 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3046
3047 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3048 return 0;
3049}
3050
0ba21762
TI		 3051static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3052 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3053{
3054 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3055 hda_nid_t nid = kcontrol->private_value;
3056 unsigned int val = !!ucontrol->value.integer.value[0];
3057 int change;
3058
62932df8 3059 mutex_lock(&codec->spdif_mutex);
1da177e4 3060 change = codec->spdif_in_enable != val;
82beb8fd 3061 if (change) {
1da177e4 3062 codec->spdif_in_enable = val;
82beb8fd
TI		 3063 snd_hda_codec_write_cache(codec, nid, 0,
3064 AC_VERB_SET_DIGI_CONVERT_1, val);
1da177e4 3065 }
62932df8 3066 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3067 return change;
3068}
3069
0ba21762
TI		 3070static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3071 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3072{
3073 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3074 hda_nid_t nid = kcontrol->private_value;
3075 unsigned short val;
3076 unsigned int sbits;
3077
3982d17e 3078 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1da177e4
LT		 3079 sbits = convert_to_spdif_status(val);
3080 ucontrol->value.iec958.status[0] = sbits;
3081 ucontrol->value.iec958.status[1] = sbits >> 8;
3082 ucontrol->value.iec958.status[2] = sbits >> 16;
3083 ucontrol->value.iec958.status[3] = sbits >> 24;
3084 return 0;
3085}
3086
c8b6bf9b 3087static struct snd_kcontrol_new dig_in_ctls[] = {
1da177e4
LT		 3088 {
3089 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3090 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
1da177e4
LT		 3091 .info = snd_hda_spdif_in_switch_info,
3092 .get = snd_hda_spdif_in_switch_get,
3093 .put = snd_hda_spdif_in_switch_put,
3094 },
3095 {
3096 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3097 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3098 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
1da177e4
LT		 3099 .info = snd_hda_spdif_mask_info,
3100 .get = snd_hda_spdif_in_status_get,
3101 },
3102 { } /* end */
3103};
3104
3105/**
3106 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3107 * @codec: the HDA codec
3108 * @nid: audio in widget NID
3109 *
3110 * Creates controls related with the SPDIF input.
3111 * Called from each patch supporting the SPDIF in.
3112 *
3113 * Returns 0 if successful, or a negative error code.
3114 */
12f288bf 3115int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1da177e4
LT		 3116{
3117 int err;
c8b6bf9b
TI		 3118 struct snd_kcontrol *kctl;
3119 struct snd_kcontrol_new *dig_mix;
09f99701 3120 int idx;
1da177e4 3121
1afe206a
TI		 3122 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3123 if (idx < 0) {
09f99701
TI		 3124 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3125 return -EBUSY;
3126 }
1da177e4
LT		 3127 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3128 kctl = snd_ctl_new1(dig_mix, codec);
c8dcdf82
TI		 3129 if (!kctl)
3130 return -ENOMEM;
1da177e4 3131 kctl->private_value = nid;
3911a4c1 3132 err = snd_hda_ctl_add(codec, nid, kctl);
0ba21762 3133 if (err < 0)
1da177e4
LT		 3134 return err;
3135 }
0ba21762 3136 codec->spdif_in_enable =
3982d17e
AP		 3137 snd_hda_codec_read(codec, nid, 0,
3138 AC_VERB_GET_DIGI_CONVERT_1, 0) &
0ba21762 3139 AC_DIG1_ENABLE;
1da177e4
LT		 3140 return 0;
3141}
ff7a3267 3142EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
1da177e4 3143
2a43952a 3144#ifdef CONFIG_PM
82beb8fd
TI		 3145/*
3146 * command cache
3147 */
1da177e4 3148
b3ac5636
TI		 3149/* build a 32bit cache key with the widget id and the command parameter */
3150#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3151#define get_cmd_cache_nid(key) ((key) & 0xff)
3152#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3153
3154/**
3155 * snd_hda_codec_write_cache - send a single command with caching
3156 * @codec: the HDA codec
3157 * @nid: NID to send the command
3158 * @direct: direct flag
3159 * @verb: the verb to send
3160 * @parm: the parameter for the verb
3161 *
3162 * Send a single command without waiting for response.
3163 *
3164 * Returns 0 if successful, or a negative error code.
3165 */
3166int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3167 int direct, unsigned int verb, unsigned int parm)
3168{
aa2936f5
TI		 3169 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3170 struct hda_cache_head *c;
3171 u32 key;
33fa35ed 3172
aa2936f5
TI		 3173 if (err < 0)
3174 return err;
3175 /* parm may contain the verb stuff for get/set amp */
3176 verb = verb | (parm >> 8);
3177 parm &= 0xff;
3178 key = build_cmd_cache_key(nid, verb);
3179 mutex_lock(&codec->bus->cmd_mutex);
3180 c = get_alloc_hash(&codec->cmd_cache, key);
3181 if (c)
3182 c->val = parm;
3183 mutex_unlock(&codec->bus->cmd_mutex);
3184 return 0;
b3ac5636 3185}
ff7a3267 3186EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
b3ac5636 3187
a68d5a54
TI		 3188/**
3189 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3190 * @codec: the HDA codec
3191 * @nid: NID to send the command
3192 * @direct: direct flag
3193 * @verb: the verb to send
3194 * @parm: the parameter for the verb
3195 *
3196 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3197 * command if the parameter is already identical with the cached value.
3198 * If not, it sends the command and refreshes the cache.
3199 *
3200 * Returns 0 if successful, or a negative error code.
3201 */
3202int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3203 int direct, unsigned int verb, unsigned int parm)
3204{
3205 struct hda_cache_head *c;
3206 u32 key;
3207
3208 /* parm may contain the verb stuff for get/set amp */
3209 verb = verb | (parm >> 8);
3210 parm &= 0xff;
3211 key = build_cmd_cache_key(nid, verb);
3212 mutex_lock(&codec->bus->cmd_mutex);
3213 c = get_hash(&codec->cmd_cache, key);
3214 if (c && c->val == parm) {
3215 mutex_unlock(&codec->bus->cmd_mutex);
3216 return 0;
3217 }
3218 mutex_unlock(&codec->bus->cmd_mutex);
3219 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3220}
3221EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3222
d5191e50
TI		 3223/**
3224 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3225 * @codec: HD-audio codec
3226 *
3227 * Execute all verbs recorded in the command caches to resume.
3228 */
b3ac5636
TI		 3229void snd_hda_codec_resume_cache(struct hda_codec *codec)
3230{
603c4019 3231 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
b3ac5636
TI		 3232 int i;
3233
603c4019 3234 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
b3ac5636
TI		 3235 u32 key = buffer->key;
3236 if (!key)
3237 continue;
3238 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3239 get_cmd_cache_cmd(key), buffer->val);
3240 }
3241}
ff7a3267 3242EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
b3ac5636
TI		 3243
3244/**
3245 * snd_hda_sequence_write_cache - sequence writes with caching
3246 * @codec: the HDA codec
3247 * @seq: VERB array to send
3248 *
3249 * Send the commands sequentially from the given array.
3250 * Thte commands are recorded on cache for power-save and resume.
3251 * The array must be terminated with NID=0.
3252 */
3253void snd_hda_sequence_write_cache(struct hda_codec *codec,
3254 const struct hda_verb *seq)
3255{
3256 for (; seq->nid; seq++)
3257 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3258 seq->param);
3259}
ff7a3267 3260EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2a43952a 3261#endif /* CONFIG_PM */
b3ac5636 3262
4d7fbdbc
TI		 3263void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3264 unsigned int power_state,
3265 bool eapd_workaround)
54d17403 3266{
4d7fbdbc 3267 hda_nid_t nid = codec->start_nid;
cb53c626 3268 int i;
54d17403 3269
cb53c626 3270 for (i = 0; i < codec->num_nodes; i++, nid++) {
7eba5c9d 3271 unsigned int wcaps = get_wcaps(codec, nid);
4d7fbdbc
TI		 3272 if (!(wcaps & AC_WCAP_POWER))
3273 continue;
3274 /* don't power down the widget if it controls eapd and
3275 * EAPD_BTLENABLE is set.
3276 */
3277 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3278 get_wcaps_type(wcaps) == AC_WID_PIN &&
3279 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3280 int eapd = snd_hda_codec_read(codec, nid, 0,
7eba5c9d 3281 AC_VERB_GET_EAPD_BTLENABLE, 0);
4d7fbdbc
TI		 3282 if (eapd & 0x02)
3283 continue;
1194b5b7 3284 }
4d7fbdbc
TI		 3285 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3286 power_state);
54d17403
TI		 3287 }
3288
cb53c626
TI		 3289 if (power_state == AC_PWRST_D0) {
3290 unsigned long end_time;
3291 int state;
cb53c626
TI		 3292 /* wait until the codec reachs to D0 */
3293 end_time = jiffies + msecs_to_jiffies(500);
3294 do {
3295 state = snd_hda_codec_read(codec, fg, 0,
3296 AC_VERB_GET_POWER_STATE, 0);
3297 if (state == power_state)
3298 break;
3299 msleep(1);
3300 } while (time_after_eq(end_time, jiffies));
3301 }
3302}
4d7fbdbc
TI		 3303EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3304
3305/*
3306 * set power state of the codec
3307 */
3308static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3309 unsigned int power_state)
3310{
3311 if (codec->patch_ops.set_power_state) {
3312 codec->patch_ops.set_power_state(codec, fg, power_state);
3313 return;
3314 }
3315
3316 /* this delay seems necessary to avoid click noise at power-down */
3317 if (power_state == AC_PWRST_D3)
3318 msleep(100);
3319 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3320 power_state);
3321 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3322}
cb53c626 3323
11aeff08
TI		 3324#ifdef CONFIG_SND_HDA_HWDEP
3325/* execute additional init verbs */
3326static void hda_exec_init_verbs(struct hda_codec *codec)
3327{
3328 if (codec->init_verbs.list)
3329 snd_hda_sequence_write(codec, codec->init_verbs.list);
3330}
3331#else
3332static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3333#endif
3334
2a43952a 3335#ifdef CONFIG_PM
cb53c626
TI		 3336/*
3337 * call suspend and power-down; used both from PM and power-save
3338 */
3339static void hda_call_codec_suspend(struct hda_codec *codec)
3340{
3341 if (codec->patch_ops.suspend)
3342 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
eb541337 3343 hda_cleanup_all_streams(codec);
cb53c626
TI		 3344 hda_set_power_state(codec,
3345 codec->afg ? codec->afg : codec->mfg,
3346 AC_PWRST_D3);
3347#ifdef CONFIG_SND_HDA_POWER_SAVE
a2f6309e 3348 snd_hda_update_power_acct(codec);
cb53c626 3349 cancel_delayed_work(&codec->power_work);
95e99fda 3350 codec->power_on = 0;
a221e287 3351 codec->power_transition = 0;
a2f6309e 3352 codec->power_jiffies = jiffies;
cb53c626 3353#endif
54d17403
TI		 3354}
3355
cb53c626
TI		 3356/*
3357 * kick up codec; used both from PM and power-save
3358 */
3359static void hda_call_codec_resume(struct hda_codec *codec)
3360{
3361 hda_set_power_state(codec,
3362 codec->afg ? codec->afg : codec->mfg,
3363 AC_PWRST_D0);
3be14149 3364 restore_pincfgs(codec); /* restore all current pin configs */
ac0547dc 3365 restore_shutup_pins(codec);
11aeff08 3366 hda_exec_init_verbs(codec);
cb53c626
TI		 3367 if (codec->patch_ops.resume)
3368 codec->patch_ops.resume(codec);
3369 else {
9d99f312
TI		 3370 if (codec->patch_ops.init)
3371 codec->patch_ops.init(codec);
cb53c626
TI		 3372 snd_hda_codec_resume_amp(codec);
3373 snd_hda_codec_resume_cache(codec);
3374 }
3375}
2a43952a 3376#endif /* CONFIG_PM */
cb53c626 3377
54d17403 3378
1da177e4
LT		 3379/**
3380 * snd_hda_build_controls - build mixer controls
3381 * @bus: the BUS
3382 *
3383 * Creates mixer controls for each codec included in the bus.
3384 *
3385 * Returns 0 if successful, otherwise a negative error code.
3386 */
1289e9e8 3387int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
1da177e4 3388{
0ba21762 3389 struct hda_codec *codec;
1da177e4 3390
0ba21762 3391 list_for_each_entry(codec, &bus->codec_list, list) {
6c1f45ea 3392 int err = snd_hda_codec_build_controls(codec);
f93d461b 3393 if (err < 0) {
28d1a85e 3394 printk(KERN_ERR "hda_codec: cannot build controls "
28aedaf7 3395 "for #%d (error %d)\n", codec->addr, err);
f93d461b
TI		 3396 err = snd_hda_codec_reset(codec);
3397 if (err < 0) {
3398 printk(KERN_ERR
3399 "hda_codec: cannot revert codec\n");
3400 return err;
3401 }
3402 }
1da177e4 3403 }
6c1f45ea
TI		 3404 return 0;
3405}
ff7a3267 3406EXPORT_SYMBOL_HDA(snd_hda_build_controls);
cb53c626 3407
6c1f45ea
TI		 3408int snd_hda_codec_build_controls(struct hda_codec *codec)
3409{
3410 int err = 0;
11aeff08 3411 hda_exec_init_verbs(codec);
6c1f45ea
TI		 3412 /* continue to initialize... */
3413 if (codec->patch_ops.init)
3414 err = codec->patch_ops.init(codec);
3415 if (!err && codec->patch_ops.build_controls)
3416 err = codec->patch_ops.build_controls(codec);
6c1f45ea
TI		 3417 if (err < 0)
3418 return err;
1da177e4
LT		 3419 return 0;
3420}
3421
1da177e4
LT		 3422/*
3423 * stream formats
3424 */
befdf316
TI		 3425struct hda_rate_tbl {
3426 unsigned int hz;
3427 unsigned int alsa_bits;
3428 unsigned int hda_fmt;
3429};
3430
92f10b3f
TI		 3431/* rate = base * mult / div */
3432#define HDA_RATE(base, mult, div) \
3433 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3434 (((div) - 1) << AC_FMT_DIV_SHIFT))
3435
befdf316 3436static struct hda_rate_tbl rate_bits[] = {
1da177e4 3437 /* rate in Hz, ALSA rate bitmask, HDA format value */
9d8f53f2
NG		 3438
3439 /* autodetected value used in snd_hda_query_supported_pcm */
92f10b3f
TI		 3440 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3441 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3442 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3443 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3444 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3445 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3446 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3447 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3448 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3449 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3450 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
a961f9fe
TI		 3451#define AC_PAR_PCM_RATE_BITS 11
3452 /* up to bits 10, 384kHZ isn't supported properly */
3453
3454 /* not autodetected value */
92f10b3f 3455 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
9d8f53f2 3456
befdf316 3457 { 0 } /* terminator */
1da177e4
LT		 3458};
3459
3460/**
3461 * snd_hda_calc_stream_format - calculate format bitset
3462 * @rate: the sample rate
3463 * @channels: the number of channels
3464 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3465 * @maxbps: the max. bps
3466 *
3467 * Calculate the format bitset from the given rate, channels and th PCM format.
3468 *
3469 * Return zero if invalid.
3470 */
3471unsigned int snd_hda_calc_stream_format(unsigned int rate,
3472 unsigned int channels,
3473 unsigned int format,
32c168c8
AH		 3474 unsigned int maxbps,
3475 unsigned short spdif_ctls)
1da177e4
LT		 3476{
3477 int i;
3478 unsigned int val = 0;
3479
befdf316
TI		 3480 for (i = 0; rate_bits[i].hz; i++)
3481 if (rate_bits[i].hz == rate) {
3482 val = rate_bits[i].hda_fmt;
1da177e4
LT		 3483 break;
3484 }
0ba21762 3485 if (!rate_bits[i].hz) {
1da177e4
LT		 3486 snd_printdd("invalid rate %d\n", rate);
3487 return 0;
3488 }
3489
3490 if (channels == 0 || channels > 8) {
3491 snd_printdd("invalid channels %d\n", channels);
3492 return 0;
3493 }
3494 val |= channels - 1;
3495
3496 switch (snd_pcm_format_width(format)) {
28aedaf7 3497 case 8:
92f10b3f 3498 val |= AC_FMT_BITS_8;
28aedaf7
NL		 3499 break;
3500 case 16:
92f10b3f 3501 val |= AC_FMT_BITS_16;
28aedaf7 3502 break;
1da177e4
LT		 3503 case 20:
3504 case 24:
3505 case 32:
b0bb3aa6 3506 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
92f10b3f 3507 val |= AC_FMT_BITS_32;
1da177e4 3508 else if (maxbps >= 24)
92f10b3f 3509 val |= AC_FMT_BITS_24;
1da177e4 3510 else
92f10b3f 3511 val |= AC_FMT_BITS_20;
1da177e4
LT		 3512 break;
3513 default:
0ba21762
TI		 3514 snd_printdd("invalid format width %d\n",
3515 snd_pcm_format_width(format));
1da177e4
LT		 3516 return 0;
3517 }
3518
32c168c8 3519 if (spdif_ctls & AC_DIG1_NONAUDIO)
92f10b3f 3520 val |= AC_FMT_TYPE_NON_PCM;
32c168c8 3521
1da177e4
LT		 3522 return val;
3523}
ff7a3267 3524EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
1da177e4 3525
92c7c8a7
TI		 3526static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3527{
3528 unsigned int val = 0;
3529 if (nid != codec->afg &&
3530 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3531 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3532 if (!val || val == -1)
3533 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3534 if (!val || val == -1)
3535 return 0;
3536 return val;
3537}
3538
3539static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3540{
3541 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3542 get_pcm_param);
3543}
3544
3545static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3546{
3547 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3548 if (!streams || streams == -1)
3549 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3550 if (!streams || streams == -1)
3551 return 0;
3552 return streams;
3553}
3554
3555static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3556{
3557 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3558 get_stream_param);
3559}
3560
1da177e4
LT		 3561/**
3562 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3563 * @codec: the HDA codec
3564 * @nid: NID to query
3565 * @ratesp: the pointer to store the detected rate bitflags
3566 * @formatsp: the pointer to store the detected formats
3567 * @bpsp: the pointer to store the detected format widths
3568 *
3569 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3570 * or @bsps argument is ignored.
3571 *
3572 * Returns 0 if successful, otherwise a negative error code.
3573 */
384a48d7 3574int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
1da177e4
LT		 3575 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3576{
ee504710 3577 unsigned int i, val, wcaps;
1da177e4 3578
ee504710 3579 wcaps = get_wcaps(codec, nid);
92c7c8a7 3580 val = query_pcm_param(codec, nid);
1da177e4
LT		 3581
3582 if (ratesp) {
3583 u32 rates = 0;
a961f9fe 3584 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
1da177e4 3585 if (val & (1 << i))
befdf316 3586 rates |= rate_bits[i].alsa_bits;
1da177e4 3587 }
ee504710
JK		 3588 if (rates == 0) {
3589 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3590 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3591 nid, val,
3592 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3593 return -EIO;
3594 }
1da177e4
LT		 3595 *ratesp = rates;
3596 }
3597
3598 if (formatsp || bpsp) {
3599 u64 formats = 0;
ee504710 3600 unsigned int streams, bps;
1da177e4 3601
92c7c8a7
TI		 3602 streams = query_stream_param(codec, nid);
3603 if (!streams)
1da177e4 3604 return -EIO;
1da177e4
LT		 3605
3606 bps = 0;
3607 if (streams & AC_SUPFMT_PCM) {
3608 if (val & AC_SUPPCM_BITS_8) {
3609 formats |= SNDRV_PCM_FMTBIT_U8;
3610 bps = 8;
3611 }
3612 if (val & AC_SUPPCM_BITS_16) {
3613 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3614 bps = 16;
3615 }
3616 if (wcaps & AC_WCAP_DIGITAL) {
3617 if (val & AC_SUPPCM_BITS_32)
3618 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3619 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3620 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3621 if (val & AC_SUPPCM_BITS_24)
3622 bps = 24;
3623 else if (val & AC_SUPPCM_BITS_20)
3624 bps = 20;
0ba21762
TI		 3625 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3626 AC_SUPPCM_BITS_32)) {
1da177e4
LT		 3627 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3628 if (val & AC_SUPPCM_BITS_32)
3629 bps = 32;
1da177e4
LT		 3630 else if (val & AC_SUPPCM_BITS_24)
3631 bps = 24;
33ef7651
NG		 3632 else if (val & AC_SUPPCM_BITS_20)
3633 bps = 20;
1da177e4
LT		 3634 }
3635 }
b5025c50 3636 if (streams & AC_SUPFMT_FLOAT32) {
1da177e4 3637 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
b0bb3aa6
TI		 3638 if (!bps)
3639 bps = 32;
b5025c50
TI		 3640 }
3641 if (streams == AC_SUPFMT_AC3) {
0ba21762 3642 /* should be exclusive */
1da177e4
LT		 3643 /* temporary hack: we have still no proper support
3644 * for the direct AC3 stream...
3645 */
3646 formats |= SNDRV_PCM_FMTBIT_U8;
3647 bps = 8;
3648 }
ee504710
JK		 3649 if (formats == 0) {
3650 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3651 "(nid=0x%x, val=0x%x, ovrd=%i, "
3652 "streams=0x%x)\n",
3653 nid, val,
3654 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3655 streams);
3656 return -EIO;
3657 }
1da177e4
LT		 3658 if (formatsp)
3659 *formatsp = formats;
3660 if (bpsp)
3661 *bpsp = bps;
3662 }
3663
3664 return 0;
3665}
384a48d7 3666EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
1da177e4
LT		 3667
3668/**
d5191e50
TI		 3669 * snd_hda_is_supported_format - Check the validity of the format
3670 * @codec: HD-audio codec
3671 * @nid: NID to check
3672 * @format: the HD-audio format value to check
3673 *
3674 * Check whether the given node supports the format value.
1da177e4
LT		 3675 *
3676 * Returns 1 if supported, 0 if not.
3677 */
3678int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3679 unsigned int format)
3680{
3681 int i;
3682 unsigned int val = 0, rate, stream;
3683
92c7c8a7
TI		 3684 val = query_pcm_param(codec, nid);
3685 if (!val)
3686 return 0;
1da177e4
LT		 3687
3688 rate = format & 0xff00;
a961f9fe 3689 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
befdf316 3690 if (rate_bits[i].hda_fmt == rate) {
1da177e4
LT		 3691 if (val & (1 << i))
3692 break;
3693 return 0;
3694 }
a961f9fe 3695 if (i >= AC_PAR_PCM_RATE_BITS)
1da177e4
LT		 3696 return 0;
3697
92c7c8a7
TI		 3698 stream = query_stream_param(codec, nid);
3699 if (!stream)
1da177e4
LT		 3700 return 0;
3701
3702 if (stream & AC_SUPFMT_PCM) {
3703 switch (format & 0xf0) {
3704 case 0x00:
0ba21762 3705 if (!(val & AC_SUPPCM_BITS_8))
1da177e4
LT		 3706 return 0;
3707 break;
3708 case 0x10:
0ba21762 3709 if (!(val & AC_SUPPCM_BITS_16))
1da177e4
LT		 3710 return 0;
3711 break;
3712 case 0x20:
0ba21762 3713 if (!(val & AC_SUPPCM_BITS_20))
1da177e4
LT		 3714 return 0;
3715 break;
3716 case 0x30:
0ba21762 3717 if (!(val & AC_SUPPCM_BITS_24))
1da177e4
LT		 3718 return 0;
3719 break;
3720 case 0x40:
0ba21762 3721 if (!(val & AC_SUPPCM_BITS_32))
1da177e4
LT		 3722 return 0;
3723 break;
3724 default:
3725 return 0;
3726 }
3727 } else {
3728 /* FIXME: check for float32 and AC3? */
3729 }
3730
3731 return 1;
3732}
ff7a3267 3733EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
1da177e4
LT		 3734
3735/*
3736 * PCM stuff
3737 */
3738static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3739 struct hda_codec *codec,
c8b6bf9b 3740 struct snd_pcm_substream *substream)
1da177e4
LT		 3741{
3742 return 0;
3743}
3744
3745static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3746 struct hda_codec *codec,
3747 unsigned int stream_tag,
3748 unsigned int format,
c8b6bf9b 3749 struct snd_pcm_substream *substream)
1da177e4
LT		 3750{
3751 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3752 return 0;
3753}
3754
3755static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3756 struct hda_codec *codec,
c8b6bf9b 3757 struct snd_pcm_substream *substream)
1da177e4 3758{
888afa15 3759 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
1da177e4
LT		 3760 return 0;
3761}
3762
6c1f45ea
TI		 3763static int set_pcm_default_values(struct hda_codec *codec,
3764 struct hda_pcm_stream *info)
1da177e4 3765{
ee504710
JK		 3766 int err;
3767
0ba21762
TI		 3768 /* query support PCM information from the given NID */
3769 if (info->nid && (!info->rates || !info->formats)) {
ee504710 3770 err = snd_hda_query_supported_pcm(codec, info->nid,
0ba21762
TI		 3771 info->rates ? NULL : &info->rates,
3772 info->formats ? NULL : &info->formats,
3773 info->maxbps ? NULL : &info->maxbps);
ee504710
JK		 3774 if (err < 0)
3775 return err;
1da177e4
LT		 3776 }
3777 if (info->ops.open == NULL)
3778 info->ops.open = hda_pcm_default_open_close;
3779 if (info->ops.close == NULL)
3780 info->ops.close = hda_pcm_default_open_close;
3781 if (info->ops.prepare == NULL) {
da3cec35
TI		 3782 if (snd_BUG_ON(!info->nid))
3783 return -EINVAL;
1da177e4
LT		 3784 info->ops.prepare = hda_pcm_default_prepare;
3785 }
1da177e4 3786 if (info->ops.cleanup == NULL) {
da3cec35
TI		 3787 if (snd_BUG_ON(!info->nid))
3788 return -EINVAL;
1da177e4
LT		 3789 info->ops.cleanup = hda_pcm_default_cleanup;
3790 }
3791 return 0;
3792}
3793
eb541337
TI		 3794/*
3795 * codec prepare/cleanup entries
3796 */
3797int snd_hda_codec_prepare(struct hda_codec *codec,
3798 struct hda_pcm_stream *hinfo,
3799 unsigned int stream,
3800 unsigned int format,
3801 struct snd_pcm_substream *substream)
3802{
3803 int ret;
3f50ac6a 3804 mutex_lock(&codec->bus->prepare_mutex);
eb541337
TI		 3805 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
3806 if (ret >= 0)
3807 purify_inactive_streams(codec);
3f50ac6a 3808 mutex_unlock(&codec->bus->prepare_mutex);
eb541337
TI		 3809 return ret;
3810}
3811EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
3812
3813void snd_hda_codec_cleanup(struct hda_codec *codec,
3814 struct hda_pcm_stream *hinfo,
3815 struct snd_pcm_substream *substream)
3816{
3f50ac6a 3817 mutex_lock(&codec->bus->prepare_mutex);
eb541337 3818 hinfo->ops.cleanup(hinfo, codec, substream);
3f50ac6a 3819 mutex_unlock(&codec->bus->prepare_mutex);
eb541337
TI		 3820}
3821EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
3822
d5191e50 3823/* global */
e3303235
JK		 3824const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3825 "Audio", "SPDIF", "HDMI", "Modem"
3826};
3827
529bd6c4
TI		 3828/*
3829 * get the empty PCM device number to assign
c8936222
TI		 3830 *
3831 * note the max device number is limited by HDA_MAX_PCMS, currently 10
529bd6c4
TI		 3832 */
3833static int get_empty_pcm_device(struct hda_bus *bus, int type)
3834{
f5d6def5
WF		 3835 /* audio device indices; not linear to keep compatibility */
3836 static int audio_idx[HDA_PCM_NTYPES][5] = {
3837 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3838 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
92608bad 3839 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
f5d6def5 3840 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
529bd6c4 3841 };
f5d6def5
WF		 3842 int i;
3843
3844 if (type >= HDA_PCM_NTYPES) {
529bd6c4
TI		 3845 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3846 return -EINVAL;
3847 }
f5d6def5
WF		 3848
3849 for (i = 0; audio_idx[type][i] >= 0 ; i++)
3850 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3851 return audio_idx[type][i];
3852
28aedaf7
NL		 3853 snd_printk(KERN_WARNING "Too many %s devices\n",
3854 snd_hda_pcm_type_name[type]);
f5d6def5 3855 return -EAGAIN;
529bd6c4
TI		 3856}
3857
176d5335
TI		 3858/*
3859 * attach a new PCM stream
3860 */
529bd6c4 3861static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
176d5335 3862{
33fa35ed 3863 struct hda_bus *bus = codec->bus;
176d5335
TI		 3864 struct hda_pcm_stream *info;
3865 int stream, err;
3866
b91f080f 3867 if (snd_BUG_ON(!pcm->name))
176d5335
TI		 3868 return -EINVAL;
3869 for (stream = 0; stream < 2; stream++) {
3870 info = &pcm->stream[stream];
3871 if (info->substreams) {
3872 err = set_pcm_default_values(codec, info);
3873 if (err < 0)
3874 return err;
3875 }
3876 }
33fa35ed 3877 return bus->ops.attach_pcm(bus, codec, pcm);
176d5335
TI		 3878}
3879
529bd6c4
TI		 3880/* assign all PCMs of the given codec */
3881int snd_hda_codec_build_pcms(struct hda_codec *codec)
3882{
3883 unsigned int pcm;
3884 int err;
3885
3886 if (!codec->num_pcms) {
3887 if (!codec->patch_ops.build_pcms)
3888 return 0;
3889 err = codec->patch_ops.build_pcms(codec);
6e655bf2
TI		 3890 if (err < 0) {
3891 printk(KERN_ERR "hda_codec: cannot build PCMs"
28aedaf7 3892 "for #%d (error %d)\n", codec->addr, err);
6e655bf2
TI		 3893 err = snd_hda_codec_reset(codec);
3894 if (err < 0) {
3895 printk(KERN_ERR
3896 "hda_codec: cannot revert codec\n");
3897 return err;
3898 }
3899 }
529bd6c4
TI		 3900 }
3901 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
3902 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
3903 int dev;
3904
3905 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
41b5b01a 3906 continue; /* no substreams assigned */
529bd6c4
TI		 3907
3908 if (!cpcm->pcm) {
3909 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
3910 if (dev < 0)
6e655bf2 3911 continue; /* no fatal error */
529bd6c4
TI		 3912 cpcm->device = dev;
3913 err = snd_hda_attach_pcm(codec, cpcm);
6e655bf2
TI		 3914 if (err < 0) {
3915 printk(KERN_ERR "hda_codec: cannot attach "
3916 "PCM stream %d for codec #%d\n",
3917 dev, codec->addr);
3918 continue; /* no fatal error */
3919 }
529bd6c4
TI		 3920 }
3921 }
3922 return 0;
3923}
3924
1da177e4
LT		 3925/**
3926 * snd_hda_build_pcms - build PCM information
3927 * @bus: the BUS
3928 *
3929 * Create PCM information for each codec included in the bus.
3930 *
3931 * The build_pcms codec patch is requested to set up codec->num_pcms and
3932 * codec->pcm_info properly. The array is referred by the top-level driver
3933 * to create its PCM instances.
3934 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3935 * callback.
3936 *
3937 * At least, substreams, channels_min and channels_max must be filled for
3938 * each stream. substreams = 0 indicates that the stream doesn't exist.
3939 * When rates and/or formats are zero, the supported values are queried
3940 * from the given nid. The nid is used also by the default ops.prepare
3941 * and ops.cleanup callbacks.
3942 *
3943 * The driver needs to call ops.open in its open callback. Similarly,
3944 * ops.close is supposed to be called in the close callback.
3945 * ops.prepare should be called in the prepare or hw_params callback
3946 * with the proper parameters for set up.
3947 * ops.cleanup should be called in hw_free for clean up of streams.
3948 *
25985edc 3949 * This function returns 0 if successful, or a negative error code.
1da177e4 3950 */
529bd6c4 3951int __devinit snd_hda_build_pcms(struct hda_bus *bus)
1da177e4 3952{
0ba21762 3953 struct hda_codec *codec;
1da177e4 3954
0ba21762 3955 list_for_each_entry(codec, &bus->codec_list, list) {
529bd6c4
TI		 3956 int err = snd_hda_codec_build_pcms(codec);
3957 if (err < 0)
3958 return err;
1da177e4
LT		 3959 }
3960 return 0;
3961}
ff7a3267 3962EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
1da177e4 3963
1da177e4
LT		 3964/**
3965 * snd_hda_check_board_config - compare the current codec with the config table
3966 * @codec: the HDA codec
f5fcc13c
TI		 3967 * @num_configs: number of config enums
3968 * @models: array of model name strings
1da177e4
LT		 3969 * @tbl: configuration table, terminated by null entries
3970 *
3971 * Compares the modelname or PCI subsystem id of the current codec with the
3972 * given configuration table. If a matching entry is found, returns its
3973 * config value (supposed to be 0 or positive).
3974 *
3975 * If no entries are matching, the function returns a negative value.
3976 */
12f288bf 3977int snd_hda_check_board_config(struct hda_codec *codec,
ea734963 3978 int num_configs, const char * const *models,
12f288bf 3979 const struct snd_pci_quirk *tbl)
1da177e4 3980{
f44ac837 3981 if (codec->modelname && models) {
f5fcc13c
TI		 3982 int i;
3983 for (i = 0; i < num_configs; i++) {
3984 if (models[i] &&
f44ac837 3985 !strcmp(codec->modelname, models[i])) {
f5fcc13c
TI		 3986 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3987 "selected\n", models[i]);
3988 return i;
1da177e4
LT		 3989 }
3990 }
3991 }
3992
f5fcc13c
TI		 3993 if (!codec->bus->pci || !tbl)
3994 return -1;
3995
3996 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3997 if (!tbl)
3998 return -1;
3999 if (tbl->value >= 0 && tbl->value < num_configs) {
62cf872a 4000#ifdef CONFIG_SND_DEBUG_VERBOSE
f5fcc13c
TI		 4001 char tmp[10];
4002 const char *model = NULL;
4003 if (models)
4004 model = models[tbl->value];
4005 if (!model) {
4006 sprintf(tmp, "#%d", tbl->value);
4007 model = tmp;
1da177e4 4008 }
f5fcc13c
TI		 4009 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4010 "for config %x:%x (%s)\n",
4011 model, tbl->subvendor, tbl->subdevice,
4012 (tbl->name ? tbl->name : "Unknown device"));
4013#endif
4014 return tbl->value;
1da177e4
LT		 4015 }
4016 return -1;
4017}
ff7a3267 4018EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
1da177e4 4019
2eda3445
MCC		 4020/**
4021 * snd_hda_check_board_codec_sid_config - compare the current codec
28aedaf7
NL		 4022 subsystem ID with the
4023 config table
2eda3445
MCC		 4024
4025 This is important for Gateway notebooks with SB450 HDA Audio
4026 where the vendor ID of the PCI device is:
4027 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4028 and the vendor/subvendor are found only at the codec.
4029
4030 * @codec: the HDA codec
4031 * @num_configs: number of config enums
4032 * @models: array of model name strings
4033 * @tbl: configuration table, terminated by null entries
4034 *
4035 * Compares the modelname or PCI subsystem id of the current codec with the
4036 * given configuration table. If a matching entry is found, returns its
4037 * config value (supposed to be 0 or positive).
4038 *
4039 * If no entries are matching, the function returns a negative value.
4040 */
4041int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
ea734963 4042 int num_configs, const char * const *models,
2eda3445
MCC		 4043 const struct snd_pci_quirk *tbl)
4044{
4045 const struct snd_pci_quirk *q;
4046
4047 /* Search for codec ID */
4048 for (q = tbl; q->subvendor; q++) {
e2301a4d
TI		 4049 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4050 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4051 if ((codec->subsystem_id & mask) == id)
2eda3445
MCC		 4052 break;
4053 }
4054
4055 if (!q->subvendor)
4056 return -1;
4057
4058 tbl = q;
4059
4060 if (tbl->value >= 0 && tbl->value < num_configs) {
d94ff6b7 4061#ifdef CONFIG_SND_DEBUG_VERBOSE
2eda3445
MCC		 4062 char tmp[10];
4063 const char *model = NULL;
4064 if (models)
4065 model = models[tbl->value];
4066 if (!model) {
4067 sprintf(tmp, "#%d", tbl->value);
4068 model = tmp;
4069 }
4070 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4071 "for config %x:%x (%s)\n",
4072 model, tbl->subvendor, tbl->subdevice,
4073 (tbl->name ? tbl->name : "Unknown device"));
4074#endif
4075 return tbl->value;
4076 }
4077 return -1;
4078}
4079EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4080
1da177e4
LT		 4081/**
4082 * snd_hda_add_new_ctls - create controls from the array
4083 * @codec: the HDA codec
c8b6bf9b 4084 * @knew: the array of struct snd_kcontrol_new
1da177e4
LT		 4085 *
4086 * This helper function creates and add new controls in the given array.
4087 * The array must be terminated with an empty entry as terminator.
4088 *
4089 * Returns 0 if successful, or a negative error code.
4090 */
031024ee
TI		 4091int snd_hda_add_new_ctls(struct hda_codec *codec,
4092 const struct snd_kcontrol_new *knew)
1da177e4 4093{
4d02d1b6 4094 int err;
1da177e4
LT		 4095
4096 for (; knew->name; knew++) {
54d17403 4097 struct snd_kcontrol *kctl;
1afe206a 4098 int addr = 0, idx = 0;
5b0cb1d8
JK		 4099 if (knew->iface == -1) /* skip this codec private value */
4100 continue;
1afe206a 4101 for (;;) {
54d17403 4102 kctl = snd_ctl_new1(knew, codec);
0ba21762 4103 if (!kctl)
54d17403 4104 return -ENOMEM;
1afe206a
TI		 4105 if (addr > 0)
4106 kctl->id.device = addr;
4107 if (idx > 0)
4108 kctl->id.index = idx;
3911a4c1 4109 err = snd_hda_ctl_add(codec, 0, kctl);
1afe206a
TI		 4110 if (!err)
4111 break;
4112 /* try first with another device index corresponding to
4113 * the codec addr; if it still fails (or it's the
4114 * primary codec), then try another control index
4115 */
4116 if (!addr && codec->addr)
4117 addr = codec->addr;
4118 else if (!idx && !knew->index) {
4119 idx = find_empty_mixer_ctl_idx(codec,
4120 knew->name);
4121 if (idx <= 0)
4122 return err;
4123 } else
54d17403
TI		 4124 return err;
4125 }
1da177e4
LT		 4126 }
4127 return 0;
4128}
ff7a3267 4129EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
1da177e4 4130
cb53c626 4131#ifdef CONFIG_SND_HDA_POWER_SAVE
cb53c626
TI		 4132static void hda_power_work(struct work_struct *work)
4133{
4134 struct hda_codec *codec =
4135 container_of(work, struct hda_codec, power_work.work);
33fa35ed 4136 struct hda_bus *bus = codec->bus;
cb53c626 4137
2e492462
ML		 4138 if (!codec->power_on || codec->power_count) {
4139 codec->power_transition = 0;
cb53c626 4140 return;
2e492462 4141 }
cb53c626 4142
d66fee5d 4143 trace_hda_power_down(codec);
cb53c626 4144 hda_call_codec_suspend(codec);
33fa35ed
TI		 4145 if (bus->ops.pm_notify)
4146 bus->ops.pm_notify(bus);
cb53c626
TI		 4147}
4148
4149static void hda_keep_power_on(struct hda_codec *codec)
4150{
4151 codec->power_count++;
4152 codec->power_on = 1;
a2f6309e
TI		 4153 codec->power_jiffies = jiffies;
4154}
4155
d5191e50 4156/* update the power on/off account with the current jiffies */
a2f6309e
TI		 4157void snd_hda_update_power_acct(struct hda_codec *codec)
4158{
4159 unsigned long delta = jiffies - codec->power_jiffies;
4160 if (codec->power_on)
4161 codec->power_on_acct += delta;
4162 else
4163 codec->power_off_acct += delta;
4164 codec->power_jiffies += delta;
cb53c626
TI		 4165}
4166
d5191e50
TI		 4167/**
4168 * snd_hda_power_up - Power-up the codec
4169 * @codec: HD-audio codec
4170 *
4171 * Increment the power-up counter and power up the hardware really when
4172 * not turned on yet.
28aedaf7 4173 */
cb53c626
TI		 4174void snd_hda_power_up(struct hda_codec *codec)
4175{
33fa35ed
TI		 4176 struct hda_bus *bus = codec->bus;
4177
cb53c626 4178 codec->power_count++;
a221e287 4179 if (codec->power_on || codec->power_transition)
cb53c626
TI		 4180 return;
4181
d66fee5d 4182 trace_hda_power_up(codec);
a2f6309e 4183 snd_hda_update_power_acct(codec);
cb53c626 4184 codec->power_on = 1;
a2f6309e 4185 codec->power_jiffies = jiffies;
33fa35ed
TI		 4186 if (bus->ops.pm_notify)
4187 bus->ops.pm_notify(bus);
cb53c626
TI		 4188 hda_call_codec_resume(codec);
4189 cancel_delayed_work(&codec->power_work);
a221e287 4190 codec->power_transition = 0;
cb53c626 4191}
ff7a3267 4192EXPORT_SYMBOL_HDA(snd_hda_power_up);
1289e9e8
TI		 4193
4194#define power_save(codec) \
4195 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
cb53c626 4196
d5191e50
TI		 4197/**
4198 * snd_hda_power_down - Power-down the codec
4199 * @codec: HD-audio codec
4200 *
4201 * Decrement the power-up counter and schedules the power-off work if
4202 * the counter rearches to zero.
28aedaf7 4203 */
cb53c626
TI		 4204void snd_hda_power_down(struct hda_codec *codec)
4205{
4206 --codec->power_count;
a221e287 4207 if (!codec->power_on || codec->power_count || codec->power_transition)
cb53c626 4208 return;
fee2fba3 4209 if (power_save(codec)) {
a221e287 4210 codec->power_transition = 1; /* avoid reentrance */
c107b41c 4211 queue_delayed_work(codec->bus->workq, &codec->power_work,
fee2fba3 4212 msecs_to_jiffies(power_save(codec) * 1000));
a221e287 4213 }
cb53c626 4214}
ff7a3267 4215EXPORT_SYMBOL_HDA(snd_hda_power_down);
cb53c626 4216
d5191e50
TI		 4217/**
4218 * snd_hda_check_amp_list_power - Check the amp list and update the power
4219 * @codec: HD-audio codec
4220 * @check: the object containing an AMP list and the status
4221 * @nid: NID to check / update
4222 *
4223 * Check whether the given NID is in the amp list. If it's in the list,
4224 * check the current AMP status, and update the the power-status according
4225 * to the mute status.
4226 *
4227 * This function is supposed to be set or called from the check_power_status
4228 * patch ops.
28aedaf7 4229 */
cb53c626
TI		 4230int snd_hda_check_amp_list_power(struct hda_codec *codec,
4231 struct hda_loopback_check *check,
4232 hda_nid_t nid)
4233{
031024ee 4234 const struct hda_amp_list *p;
cb53c626
TI		 4235 int ch, v;
4236
4237 if (!check->amplist)
4238 return 0;
4239 for (p = check->amplist; p->nid; p++) {
4240 if (p->nid == nid)
4241 break;
4242 }
4243 if (!p->nid)
4244 return 0; /* nothing changed */
4245
4246 for (p = check->amplist; p->nid; p++) {
4247 for (ch = 0; ch < 2; ch++) {
4248 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4249 p->idx);
4250 if (!(v & HDA_AMP_MUTE) && v > 0) {
4251 if (!check->power_on) {
4252 check->power_on = 1;
4253 snd_hda_power_up(codec);
4254 }
4255 return 1;
4256 }
4257 }
4258 }
4259 if (check->power_on) {
4260 check->power_on = 0;
4261 snd_hda_power_down(codec);
4262 }
4263 return 0;
4264}
ff7a3267 4265EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
cb53c626 4266#endif
1da177e4 4267
c8b6bf9b 4268/*
d2a6d7dc
TI		 4269 * Channel mode helper
4270 */
d5191e50
TI		 4271
4272/**
4273 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4274 */
0ba21762
TI		 4275int snd_hda_ch_mode_info(struct hda_codec *codec,
4276 struct snd_ctl_elem_info *uinfo,
4277 const struct hda_channel_mode *chmode,
4278 int num_chmodes)
d2a6d7dc
TI		 4279{
4280 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4281 uinfo->count = 1;
4282 uinfo->value.enumerated.items = num_chmodes;
4283 if (uinfo->value.enumerated.item >= num_chmodes)
4284 uinfo->value.enumerated.item = num_chmodes - 1;
4285 sprintf(uinfo->value.enumerated.name, "%dch",
4286 chmode[uinfo->value.enumerated.item].channels);
4287 return 0;
4288}
ff7a3267 4289EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
d2a6d7dc 4290
d5191e50
TI		 4291/**
4292 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4293 */
0ba21762
TI		 4294int snd_hda_ch_mode_get(struct hda_codec *codec,
4295 struct snd_ctl_elem_value *ucontrol,
4296 const struct hda_channel_mode *chmode,
4297 int num_chmodes,
d2a6d7dc
TI		 4298 int max_channels)
4299{
4300 int i;
4301
4302 for (i = 0; i < num_chmodes; i++) {
4303 if (max_channels == chmode[i].channels) {
4304 ucontrol->value.enumerated.item[0] = i;
4305 break;
4306 }
4307 }
4308 return 0;
4309}
ff7a3267 4310EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
d2a6d7dc 4311
d5191e50
TI		 4312/**
4313 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4314 */
0ba21762
TI		 4315int snd_hda_ch_mode_put(struct hda_codec *codec,
4316 struct snd_ctl_elem_value *ucontrol,
4317 const struct hda_channel_mode *chmode,
4318 int num_chmodes,
d2a6d7dc
TI		 4319 int *max_channelsp)
4320{
4321 unsigned int mode;
4322
4323 mode = ucontrol->value.enumerated.item[0];
68ea7b2f
TI		 4324 if (mode >= num_chmodes)
4325 return -EINVAL;
82beb8fd 4326 if (*max_channelsp == chmode[mode].channels)
d2a6d7dc
TI		 4327 return 0;
4328 /* change the current channel setting */
4329 *max_channelsp = chmode[mode].channels;
4330 if (chmode[mode].sequence)
82beb8fd 4331 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
d2a6d7dc
TI		 4332 return 1;
4333}
ff7a3267 4334EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
d2a6d7dc 4335
1da177e4
LT		 4336/*
4337 * input MUX helper
4338 */
d5191e50
TI		 4339
4340/**
4341 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4342 */
0ba21762
TI		 4343int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4344 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 4345{
4346 unsigned int index;
4347
4348 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4349 uinfo->count = 1;
4350 uinfo->value.enumerated.items = imux->num_items;
5513b0c5
TI		 4351 if (!imux->num_items)
4352 return 0;
1da177e4
LT		 4353 index = uinfo->value.enumerated.item;
4354 if (index >= imux->num_items)
4355 index = imux->num_items - 1;
4356 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4357 return 0;
4358}
ff7a3267 4359EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
1da177e4 4360
d5191e50
TI		 4361/**
4362 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4363 */
0ba21762
TI		 4364int snd_hda_input_mux_put(struct hda_codec *codec,
4365 const struct hda_input_mux *imux,
4366 struct snd_ctl_elem_value *ucontrol,
4367 hda_nid_t nid,
1da177e4
LT		 4368 unsigned int *cur_val)
4369{
4370 unsigned int idx;
4371
5513b0c5
TI		 4372 if (!imux->num_items)
4373 return 0;
1da177e4
LT		 4374 idx = ucontrol->value.enumerated.item[0];
4375 if (idx >= imux->num_items)
4376 idx = imux->num_items - 1;
82beb8fd 4377 if (*cur_val == idx)
1da177e4 4378 return 0;
82beb8fd
TI		 4379 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4380 imux->items[idx].index);
1da177e4
LT		 4381 *cur_val = idx;
4382 return 1;
4383}
ff7a3267 4384EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
1da177e4
LT		 4385
4386
4387/*
4388 * Multi-channel / digital-out PCM helper functions
4389 */
4390
6b97eb45
TI		 4391/* setup SPDIF output stream */
4392static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4393 unsigned int stream_tag, unsigned int format)
4394{
7c935976
SW		 4395 struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4396
6b97eb45 4397 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
7c935976 4398 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
28aedaf7 4399 set_dig_out_convert(codec, nid,
7c935976 4400 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
2f72853c 4401 -1);
6b97eb45 4402 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2f72853c 4403 if (codec->slave_dig_outs) {
dda14410 4404 const hda_nid_t *d;
2f72853c
TI		 4405 for (d = codec->slave_dig_outs; *d; d++)
4406 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4407 format);
4408 }
6b97eb45 4409 /* turn on again (if needed) */
7c935976 4410 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
2f72853c 4411 set_dig_out_convert(codec, nid,
7c935976 4412 spdif->ctls & 0xff, -1);
2f72853c 4413}
de51ca12 4414
2f72853c
TI		 4415static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4416{
4417 snd_hda_codec_cleanup_stream(codec, nid);
4418 if (codec->slave_dig_outs) {
dda14410 4419 const hda_nid_t *d;
2f72853c
TI		 4420 for (d = codec->slave_dig_outs; *d; d++)
4421 snd_hda_codec_cleanup_stream(codec, *d);
de51ca12 4422 }
6b97eb45
TI		 4423}
4424
d5191e50
TI		 4425/**
4426 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4427 * @bus: HD-audio bus
4428 */
fb8d1a34
TI		 4429void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4430{
4431 struct hda_codec *codec;
4432
4433 if (!bus)
4434 return;
4435 list_for_each_entry(codec, &bus->codec_list, list) {
e581f3db
TI		 4436 if (hda_codec_is_power_on(codec) &&
4437 codec->patch_ops.reboot_notify)
fb8d1a34
TI		 4438 codec->patch_ops.reboot_notify(codec);
4439 }
4440}
8f217a22 4441EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
fb8d1a34 4442
d5191e50
TI		 4443/**
4444 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
1da177e4 4445 */
0ba21762
TI		 4446int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4447 struct hda_multi_out *mout)
1da177e4 4448{
62932df8 4449 mutex_lock(&codec->spdif_mutex);
5930ca41
TI		 4450 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4451 /* already opened as analog dup; reset it once */
2f72853c 4452 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4 4453 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
62932df8 4454 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4455 return 0;
4456}
ff7a3267 4457EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
1da177e4 4458
d5191e50
TI		 4459/**
4460 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4461 */
6b97eb45
TI		 4462int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4463 struct hda_multi_out *mout,
4464 unsigned int stream_tag,
4465 unsigned int format,
4466 struct snd_pcm_substream *substream)
4467{
4468 mutex_lock(&codec->spdif_mutex);
4469 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4470 mutex_unlock(&codec->spdif_mutex);
4471 return 0;
4472}
ff7a3267 4473EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
6b97eb45 4474
d5191e50
TI		 4475/**
4476 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4477 */
9411e21c
TI		 4478int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4479 struct hda_multi_out *mout)
4480{
4481 mutex_lock(&codec->spdif_mutex);
4482 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4483 mutex_unlock(&codec->spdif_mutex);
4484 return 0;
4485}
4486EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4487
d5191e50
TI		 4488/**
4489 * snd_hda_multi_out_dig_close - release the digital out stream
1da177e4 4490 */
0ba21762
TI		 4491int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4492 struct hda_multi_out *mout)
1da177e4 4493{
62932df8 4494 mutex_lock(&codec->spdif_mutex);
1da177e4 4495 mout->dig_out_used = 0;
62932df8 4496 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4497 return 0;
4498}
ff7a3267 4499EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
1da177e4 4500
d5191e50
TI		 4501/**
4502 * snd_hda_multi_out_analog_open - open analog outputs
4503 *
4504 * Open analog outputs and set up the hw-constraints.
4505 * If the digital outputs can be opened as slave, open the digital
4506 * outputs, too.
1da177e4 4507 */
0ba21762
TI		 4508int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4509 struct hda_multi_out *mout,
9a08160b
TI		 4510 struct snd_pcm_substream *substream,
4511 struct hda_pcm_stream *hinfo)
4512{
4513 struct snd_pcm_runtime *runtime = substream->runtime;
4514 runtime->hw.channels_max = mout->max_channels;
4515 if (mout->dig_out_nid) {
4516 if (!mout->analog_rates) {
4517 mout->analog_rates = hinfo->rates;
4518 mout->analog_formats = hinfo->formats;
4519 mout->analog_maxbps = hinfo->maxbps;
4520 } else {
4521 runtime->hw.rates = mout->analog_rates;
4522 runtime->hw.formats = mout->analog_formats;
4523 hinfo->maxbps = mout->analog_maxbps;
4524 }
4525 if (!mout->spdif_rates) {
4526 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4527 &mout->spdif_rates,
4528 &mout->spdif_formats,
4529 &mout->spdif_maxbps);
4530 }
4531 mutex_lock(&codec->spdif_mutex);
4532 if (mout->share_spdif) {
022b466f
TI		 4533 if ((runtime->hw.rates & mout->spdif_rates) &&
4534 (runtime->hw.formats & mout->spdif_formats)) {
4535 runtime->hw.rates &= mout->spdif_rates;
4536 runtime->hw.formats &= mout->spdif_formats;
4537 if (mout->spdif_maxbps < hinfo->maxbps)
4538 hinfo->maxbps = mout->spdif_maxbps;
4539 } else {
4540 mout->share_spdif = 0;
4541 /* FIXME: need notify? */
4542 }
9a08160b 4543 }
eaa9985b 4544 mutex_unlock(&codec->spdif_mutex);
9a08160b 4545 }
1da177e4
LT		 4546 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4547 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4548}
ff7a3267 4549EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
1da177e4 4550
d5191e50
TI		 4551/**
4552 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4553 *
4554 * Set up the i/o for analog out.
4555 * When the digital out is available, copy the front out to digital out, too.
1da177e4 4556 */
0ba21762
TI		 4557int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4558 struct hda_multi_out *mout,
1da177e4
LT		 4559 unsigned int stream_tag,
4560 unsigned int format,
c8b6bf9b 4561 struct snd_pcm_substream *substream)
1da177e4 4562{
dda14410 4563 const hda_nid_t *nids = mout->dac_nids;
1da177e4 4564 int chs = substream->runtime->channels;
7c935976
SW		 4565 struct hda_spdif_out *spdif =
4566 snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
1da177e4
LT		 4567 int i;
4568
62932df8 4569 mutex_lock(&codec->spdif_mutex);
9a08160b
TI		 4570 if (mout->dig_out_nid && mout->share_spdif &&
4571 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
1da177e4 4572 if (chs == 2 &&
0ba21762
TI		 4573 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4574 format) &&
7c935976 4575 !(spdif->status & IEC958_AES0_NONAUDIO)) {
1da177e4 4576 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
6b97eb45
TI		 4577 setup_dig_out_stream(codec, mout->dig_out_nid,
4578 stream_tag, format);
1da177e4
LT		 4579 } else {
4580 mout->dig_out_used = 0;
2f72853c 4581 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 4582 }
4583 }
62932df8 4584 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4585
4586 /* front */
0ba21762
TI		 4587 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4588 0, format);
d29240ce
TI		 4589 if (!mout->no_share_stream &&
4590 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
1da177e4 4591 /* headphone out will just decode front left/right (stereo) */
0ba21762
TI		 4592 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4593 0, format);
82bc955f 4594 /* extra outputs copied from front */
a06dbfc2
TI		 4595 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4596 if (!mout->no_share_stream && mout->hp_out_nid[i])
4597 snd_hda_codec_setup_stream(codec,
4598 mout->hp_out_nid[i],
4599 stream_tag, 0, format);
82bc955f 4600 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
d29240ce 4601 if (!mout->no_share_stream && mout->extra_out_nid[i])
82bc955f
TI		 4602 snd_hda_codec_setup_stream(codec,
4603 mout->extra_out_nid[i],
4604 stream_tag, 0, format);
4605
1da177e4
LT		 4606 /* surrounds */
4607 for (i = 1; i < mout->num_dacs; i++) {
4b3acaf5 4608 if (chs >= (i + 1) * 2) /* independent out */
0ba21762
TI		 4609 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4610 i * 2, format);
d29240ce 4611 else if (!mout->no_share_stream) /* copy front */
0ba21762
TI		 4612 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4613 0, format);
1da177e4
LT		 4614 }
4615 return 0;
4616}
ff7a3267 4617EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
1da177e4 4618
d5191e50
TI		 4619/**
4620 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
1da177e4 4621 */
0ba21762
TI		 4622int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4623 struct hda_multi_out *mout)
1da177e4 4624{
dda14410 4625 const hda_nid_t *nids = mout->dac_nids;
1da177e4
LT		 4626 int i;
4627
4628 for (i = 0; i < mout->num_dacs; i++)
888afa15 4629 snd_hda_codec_cleanup_stream(codec, nids[i]);
1da177e4 4630 if (mout->hp_nid)
888afa15 4631 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
a06dbfc2
TI		 4632 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4633 if (mout->hp_out_nid[i])
4634 snd_hda_codec_cleanup_stream(codec,
4635 mout->hp_out_nid[i]);
82bc955f
TI		 4636 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4637 if (mout->extra_out_nid[i])
888afa15
TI		 4638 snd_hda_codec_cleanup_stream(codec,
4639 mout->extra_out_nid[i]);
62932df8 4640 mutex_lock(&codec->spdif_mutex);
1da177e4 4641 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
2f72853c 4642 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 4643 mout->dig_out_used = 0;
4644 }
62932df8 4645 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4646 return 0;
4647}
ff7a3267 4648EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
1da177e4 4649
e9edcee0 4650/*
6b34500c 4651 * Helper for automatic pin configuration
e9edcee0 4652 */
df694daa 4653
dda14410 4654static int is_in_nid_list(hda_nid_t nid, const hda_nid_t *list)
df694daa
KY		 4655{
4656 for (; *list; list++)
4657 if (*list == nid)
4658 return 1;
4659 return 0;
4660}
4661
81937d3b
SL		 4662
4663/*
4664 * Sort an associated group of pins according to their sequence numbers.
4665 */
28aedaf7 4666static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences,
81937d3b
SL		 4667 int num_pins)
4668{
4669 int i, j;
4670 short seq;
4671 hda_nid_t nid;
28aedaf7 4672
81937d3b
SL		 4673 for (i = 0; i < num_pins; i++) {
4674 for (j = i + 1; j < num_pins; j++) {
4675 if (sequences[i] > sequences[j]) {
4676 seq = sequences[i];
4677 sequences[i] = sequences[j];
4678 sequences[j] = seq;
4679 nid = pins[i];
4680 pins[i] = pins[j];
4681 pins[j] = nid;
4682 }
4683 }
4684 }
4685}
4686
4687
75e0eb24
TI		 4688/* add the found input-pin to the cfg->inputs[] table */
4689static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid,
4690 int type)
4691{
4692 if (cfg->num_inputs < AUTO_CFG_MAX_INS) {
4693 cfg->inputs[cfg->num_inputs].pin = nid;
4694 cfg->inputs[cfg->num_inputs].type = type;
4695 cfg->num_inputs++;
4696 }
4697}
4698
4a4d4a69
TI		 4699/* sort inputs in the order of AUTO_PIN_* type */
4700static void sort_autocfg_input_pins(struct auto_pin_cfg *cfg)
4701{
4702 int i, j;
4703
4704 for (i = 0; i < cfg->num_inputs; i++) {
4705 for (j = i + 1; j < cfg->num_inputs; j++) {
4706 if (cfg->inputs[i].type > cfg->inputs[j].type) {
4707 struct auto_pin_cfg_item tmp;
4708 tmp = cfg->inputs[i];
4709 cfg->inputs[i] = cfg->inputs[j];
4710 cfg->inputs[j] = tmp;
4711 }
4712 }
4713 }
4714}
4715
8fa7ab48
TI		 4716/* Reorder the surround channels
4717 * ALSA sequence is front/surr/clfe/side
4718 * HDA sequence is:
4719 * 4-ch: front/surr => OK as it is
4720 * 6-ch: front/clfe/surr
4721 * 8-ch: front/clfe/rear/side|fc
4722 */
4723static void reorder_outputs(unsigned int nums, hda_nid_t *pins)
4724{
4725 hda_nid_t nid;
4726
4727 switch (nums) {
4728 case 3:
4729 case 4:
4730 nid = pins[1];
4731 pins[1] = pins[2];
4732 pins[2] = nid;
4733 break;
4734 }
4735}
4736
82bc955f
TI		 4737/*
4738 * Parse all pin widgets and store the useful pin nids to cfg
4739 *
4740 * The number of line-outs or any primary output is stored in line_outs,
4741 * and the corresponding output pins are assigned to line_out_pins[],
4742 * in the order of front, rear, CLFE, side, ...
4743 *
4744 * If more extra outputs (speaker and headphone) are found, the pins are
eb06ed8f 4745 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
82bc955f
TI		 4746 * is detected, one of speaker of HP pins is assigned as the primary
4747 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4748 * if any analog output exists.
28aedaf7 4749 *
86e2959a 4750 * The analog input pins are assigned to inputs array.
82bc955f
TI		 4751 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4752 * respectively.
4753 */
d025febc
TI		 4754int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
4755 struct auto_pin_cfg *cfg,
4756 const hda_nid_t *ignore_nids,
4757 unsigned int cond_flags)
e9edcee0 4758{
0ef6ce7b 4759 hda_nid_t nid, end_nid;
965f1b2e 4760 short seq, assoc_line_out;
81937d3b
SL		 4761 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4762 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
f889fa91 4763 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
75e0eb24 4764 int i;
e9edcee0
TI		 4765
4766 memset(cfg, 0, sizeof(*cfg));
4767
81937d3b
SL		 4768 memset(sequences_line_out, 0, sizeof(sequences_line_out));
4769 memset(sequences_speaker, 0, sizeof(sequences_speaker));
f889fa91 4770 memset(sequences_hp, 0, sizeof(sequences_hp));
965f1b2e 4771 assoc_line_out = 0;
e9edcee0 4772
2f451d2a 4773 codec->ignore_misc_bit = true;
0ef6ce7b
TI		 4774 end_nid = codec->start_nid + codec->num_nodes;
4775 for (nid = codec->start_nid; nid < end_nid; nid++) {
54d17403 4776 unsigned int wid_caps = get_wcaps(codec, nid);
a22d543a 4777 unsigned int wid_type = get_wcaps_type(wid_caps);
e9edcee0 4778 unsigned int def_conf;
1af7c5f0 4779 short assoc, loc, conn, dev;
e9edcee0
TI		 4780
4781 /* read all default configuration for pin complex */
4782 if (wid_type != AC_WID_PIN)
4783 continue;
df694daa
KY		 4784 /* ignore the given nids (e.g. pc-beep returns error) */
4785 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4786 continue;
4787
c17a1aba 4788 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2f451d2a
TI		 4789 if (!(get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
4790 AC_DEFCFG_MISC_NO_PRESENCE))
4791 codec->ignore_misc_bit = false;
1af7c5f0
TI		 4792 conn = get_defcfg_connect(def_conf);
4793 if (conn == AC_JACK_PORT_NONE)
e9edcee0
TI		 4794 continue;
4795 loc = get_defcfg_location(def_conf);
1af7c5f0
TI		 4796 dev = get_defcfg_device(def_conf);
4797
4798 /* workaround for buggy BIOS setups */
4799 if (dev == AC_JACK_LINE_OUT) {
4800 if (conn == AC_JACK_PORT_FIXED)
4801 dev = AC_JACK_SPEAKER;
4802 }
4803
4804 switch (dev) {
e9edcee0 4805 case AC_JACK_LINE_OUT:
e9edcee0
TI		 4806 seq = get_defcfg_sequence(def_conf);
4807 assoc = get_defcfg_association(def_conf);
90da78bf
MR		 4808
4809 if (!(wid_caps & AC_WCAP_STEREO))
4810 if (!cfg->mono_out_pin)
4811 cfg->mono_out_pin = nid;
0ba21762 4812 if (!assoc)
e9edcee0 4813 continue;
0ba21762 4814 if (!assoc_line_out)
e9edcee0
TI		 4815 assoc_line_out = assoc;
4816 else if (assoc_line_out != assoc)
4817 continue;
4818 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4819 continue;
4820 cfg->line_out_pins[cfg->line_outs] = nid;
81937d3b 4821 sequences_line_out[cfg->line_outs] = seq;
e9edcee0
TI		 4822 cfg->line_outs++;
4823 break;
8d88bc3d 4824 case AC_JACK_SPEAKER:
81937d3b
SL		 4825 seq = get_defcfg_sequence(def_conf);
4826 assoc = get_defcfg_association(def_conf);
82bc955f
TI		 4827 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4828 continue;
4829 cfg->speaker_pins[cfg->speaker_outs] = nid;
965f1b2e 4830 sequences_speaker[cfg->speaker_outs] = (assoc << 4) | seq;
82bc955f 4831 cfg->speaker_outs++;
8d88bc3d 4832 break;
e9edcee0 4833 case AC_JACK_HP_OUT:
f889fa91
TI		 4834 seq = get_defcfg_sequence(def_conf);
4835 assoc = get_defcfg_association(def_conf);
eb06ed8f
TI		 4836 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4837 continue;
4838 cfg->hp_pins[cfg->hp_outs] = nid;
f889fa91 4839 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
eb06ed8f 4840 cfg->hp_outs++;
e9edcee0 4841 break;
86e2959a
TI		 4842 case AC_JACK_MIC_IN:
4843 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_MIC);
e9edcee0 4844 break;
86e2959a
TI		 4845 case AC_JACK_LINE_IN:
4846 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_LINE_IN);
e9edcee0
TI		 4847 break;
4848 case AC_JACK_CD:
75e0eb24 4849 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD);
e9edcee0
TI		 4850 break;
4851 case AC_JACK_AUX:
75e0eb24 4852 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX);
e9edcee0
TI		 4853 break;
4854 case AC_JACK_SPDIF_OUT:
1b52ae70 4855 case AC_JACK_DIG_OTHER_OUT:
0852d7a6
TI		 4856 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
4857 continue;
4858 cfg->dig_out_pins[cfg->dig_outs] = nid;
4859 cfg->dig_out_type[cfg->dig_outs] =
4860 (loc == AC_JACK_LOC_HDMI) ?
4861 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
4862 cfg->dig_outs++;
e9edcee0
TI		 4863 break;
4864 case AC_JACK_SPDIF_IN:
1b52ae70 4865 case AC_JACK_DIG_OTHER_IN:
e9edcee0 4866 cfg->dig_in_pin = nid;
2297bd6e
TI		 4867 if (loc == AC_JACK_LOC_HDMI)
4868 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
4869 else
4870 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
e9edcee0
TI		 4871 break;
4872 }
4873 }
4874
5832fcf8
TI		 4875 /* FIX-UP:
4876 * If no line-out is defined but multiple HPs are found,
4877 * some of them might be the real line-outs.
4878 */
d025febc
TI		 4879 if (!cfg->line_outs && cfg->hp_outs > 1 &&
4880 !(cond_flags & HDA_PINCFG_NO_HP_FIXUP)) {
5832fcf8
TI		 4881 int i = 0;
4882 while (i < cfg->hp_outs) {
4883 /* The real HPs should have the sequence 0x0f */
4884 if ((sequences_hp[i] & 0x0f) == 0x0f) {
4885 i++;
4886 continue;
4887 }
4888 /* Move it to the line-out table */
4889 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
4890 sequences_line_out[cfg->line_outs] = sequences_hp[i];
4891 cfg->line_outs++;
4892 cfg->hp_outs--;
4893 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
4894 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
122661b6 4895 memmove(sequences_hp + i, sequences_hp + i + 1,
5832fcf8
TI		 4896 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
4897 }
03642c9a
TI		 4898 memset(cfg->hp_pins + cfg->hp_outs, 0,
4899 sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs));
b2d05760
TI		 4900 if (!cfg->hp_outs)
4901 cfg->line_out_type = AUTO_PIN_HP_OUT;
4902
5832fcf8
TI		 4903 }
4904
e9edcee0 4905 /* sort by sequence */
81937d3b
SL		 4906 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
4907 cfg->line_outs);
4908 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
4909 cfg->speaker_outs);
f889fa91
TI		 4910 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
4911 cfg->hp_outs);
28aedaf7 4912
81937d3b
SL		 4913 /*
4914 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4915 * as a primary output
4916 */
d025febc
TI		 4917 if (!cfg->line_outs &&
4918 !(cond_flags & HDA_PINCFG_NO_LO_FIXUP)) {
81937d3b
SL		 4919 if (cfg->speaker_outs) {
4920 cfg->line_outs = cfg->speaker_outs;
4921 memcpy(cfg->line_out_pins, cfg->speaker_pins,
4922 sizeof(cfg->speaker_pins));
4923 cfg->speaker_outs = 0;
4924 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
4925 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
4926 } else if (cfg->hp_outs) {
4927 cfg->line_outs = cfg->hp_outs;
4928 memcpy(cfg->line_out_pins, cfg->hp_pins,
4929 sizeof(cfg->hp_pins));
4930 cfg->hp_outs = 0;
4931 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4932 cfg->line_out_type = AUTO_PIN_HP_OUT;
4933 }
4934 }
e9edcee0 4935
8fa7ab48
TI		 4936 reorder_outputs(cfg->line_outs, cfg->line_out_pins);
4937 reorder_outputs(cfg->hp_outs, cfg->hp_pins);
4938 reorder_outputs(cfg->speaker_outs, cfg->speaker_pins);
e9edcee0 4939
4a4d4a69
TI		 4940 sort_autocfg_input_pins(cfg);
4941
82bc955f
TI		 4942 /*
4943 * debug prints of the parsed results
4944 */
c2de187e 4945 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
82bc955f
TI		 4946 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
4947 cfg->line_out_pins[2], cfg->line_out_pins[3],
c2de187e
TI		 4948 cfg->line_out_pins[4],
4949 cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
4950 (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT ?
4951 "speaker" : "line"));
82bc955f
TI		 4952 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4953 cfg->speaker_outs, cfg->speaker_pins[0],
4954 cfg->speaker_pins[1], cfg->speaker_pins[2],
4955 cfg->speaker_pins[3], cfg->speaker_pins[4]);
eb06ed8f
TI		 4956 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4957 cfg->hp_outs, cfg->hp_pins[0],
4958 cfg->hp_pins[1], cfg->hp_pins[2],
4959 cfg->hp_pins[3], cfg->hp_pins[4]);
90da78bf 4960 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
0852d7a6
TI		 4961 if (cfg->dig_outs)
4962 snd_printd(" dig-out=0x%x/0x%x\n",
4963 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
75e0eb24
TI		 4964 snd_printd(" inputs:");
4965 for (i = 0; i < cfg->num_inputs; i++) {
0b626737 4966 snd_printd(" %s=0x%x",
10a20af7 4967 hda_get_autocfg_input_label(codec, cfg, i),
75e0eb24
TI		 4968 cfg->inputs[i].pin);
4969 }
4970 snd_printd("\n");
32d2c7fa 4971 if (cfg->dig_in_pin)
89ce9e87 4972 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
82bc955f 4973
e9edcee0
TI		 4974 return 0;
4975}
d025febc 4976EXPORT_SYMBOL_HDA(snd_hda_parse_pin_defcfg);
e9edcee0 4977
99ae28be 4978int snd_hda_get_input_pin_attr(unsigned int def_conf)
a1c98515
TI		 4979{
4980 unsigned int loc = get_defcfg_location(def_conf);
41c89ef3 4981 unsigned int conn = get_defcfg_connect(def_conf);
99ae28be
TI		 4982 if (conn == AC_JACK_PORT_NONE)
4983 return INPUT_PIN_ATTR_UNUSED;
41c89ef3
TI		 4984 /* Windows may claim the internal mic to be BOTH, too */
4985 if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH)
99ae28be 4986 return INPUT_PIN_ATTR_INT;
41c89ef3 4987 if ((loc & 0x30) == AC_JACK_LOC_INTERNAL)
99ae28be 4988 return INPUT_PIN_ATTR_INT;
a1c98515 4989 if ((loc & 0x30) == AC_JACK_LOC_SEPARATE)
99ae28be 4990 return INPUT_PIN_ATTR_DOCK;
a1c98515 4991 if (loc == AC_JACK_LOC_REAR)
99ae28be 4992 return INPUT_PIN_ATTR_REAR;
a1c98515 4993 if (loc == AC_JACK_LOC_FRONT)
99ae28be
TI		 4994 return INPUT_PIN_ATTR_FRONT;
4995 return INPUT_PIN_ATTR_NORMAL;
a1c98515 4996}
99ae28be 4997EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
a1c98515 4998
990061c2
TI		 4999/**
5000 * hda_get_input_pin_label - Give a label for the given input pin
5001 *
5002 * When check_location is true, the function checks the pin location
5003 * for mic and line-in pins, and set an appropriate prefix like "Front",
5004 * "Rear", "Internal".
5005 */
5006
10a20af7
TI		 5007const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin,
5008 int check_location)
5009{
a1c98515 5010 unsigned int def_conf;
ea734963 5011 static const char * const mic_names[] = {
a1c98515
TI		 5012 "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic",
5013 };
99ae28be 5014 int attr;
10a20af7
TI		 5015
5016 def_conf = snd_hda_codec_get_pincfg(codec, pin);
10a20af7
TI		 5017
5018 switch (get_defcfg_device(def_conf)) {
5019 case AC_JACK_MIC_IN:
5020 if (!check_location)
5021 return "Mic";
99ae28be
TI		 5022 attr = snd_hda_get_input_pin_attr(def_conf);
5023 if (!attr)
5024 return "None";
5025 return mic_names[attr - 1];
10a20af7
TI		 5026 case AC_JACK_LINE_IN:
5027 if (!check_location)
5028 return "Line";
99ae28be
TI		 5029 attr = snd_hda_get_input_pin_attr(def_conf);
5030 if (!attr)
5031 return "None";
5032 if (attr == INPUT_PIN_ATTR_DOCK)
5033 return "Dock Line";
5034 return "Line";
10a20af7
TI		 5035 case AC_JACK_AUX:
5036 return "Aux";
5037 case AC_JACK_CD:
5038 return "CD";
5039 case AC_JACK_SPDIF_IN:
5040 return "SPDIF In";
5041 case AC_JACK_DIG_OTHER_IN:
5042 return "Digital In";
5043 default:
5044 return "Misc";
5045 }
5046}
5047EXPORT_SYMBOL_HDA(hda_get_input_pin_label);
4a471b7d 5048
a1c98515
TI		 5049/* Check whether the location prefix needs to be added to the label.
5050 * If all mic-jacks are in the same location (e.g. rear panel), we don't
5051 * have to put "Front" prefix to each label. In such a case, returns false.
5052 */
5053static int check_mic_location_need(struct hda_codec *codec,
5054 const struct auto_pin_cfg *cfg,
5055 int input)
5056{
5057 unsigned int defc;
5058 int i, attr, attr2;
5059
5060 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin);
99ae28be 5061 attr = snd_hda_get_input_pin_attr(defc);
a1c98515 5062 /* for internal or docking mics, we need locations */
99ae28be 5063 if (attr <= INPUT_PIN_ATTR_NORMAL)
a1c98515
TI		 5064 return 1;
5065
5066 attr = 0;
5067 for (i = 0; i < cfg->num_inputs; i++) {
5068 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin);
99ae28be
TI		 5069 attr2 = snd_hda_get_input_pin_attr(defc);
5070 if (attr2 >= INPUT_PIN_ATTR_NORMAL) {
a1c98515
TI		 5071 if (attr && attr != attr2)
5072 return 1; /* different locations found */
5073 attr = attr2;
5074 }
5075 }
5076 return 0;
5077}
5078
990061c2
TI		 5079/**
5080 * hda_get_autocfg_input_label - Get a label for the given input
5081 *
5082 * Get a label for the given input pin defined by the autocfg item.
5083 * Unlike hda_get_input_pin_label(), this function checks all inputs
5084 * defined in autocfg and avoids the redundant mic/line prefix as much as
5085 * possible.
5086 */
10a20af7
TI		 5087const char *hda_get_autocfg_input_label(struct hda_codec *codec,
5088 const struct auto_pin_cfg *cfg,
5089 int input)
d7b1ae9d
TI		 5090{
5091 int type = cfg->inputs[input].type;
10a20af7 5092 int has_multiple_pins = 0;
d7b1ae9d 5093
10a20af7
TI		 5094 if ((input > 0 && cfg->inputs[input - 1].type == type) ||
5095 (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type))
5096 has_multiple_pins = 1;
a1c98515
TI		 5097 if (has_multiple_pins && type == AUTO_PIN_MIC)
5098 has_multiple_pins &= check_mic_location_need(codec, cfg, input);
10a20af7
TI		 5099 return hda_get_input_pin_label(codec, cfg->inputs[input].pin,
5100 has_multiple_pins);
5101}
5102EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
5103
990061c2
TI		 5104/**
5105 * snd_hda_add_imux_item - Add an item to input_mux
5106 *
5107 * When the same label is used already in the existing items, the number
5108 * suffix is appended to the label. This label index number is stored
5109 * to type_idx when non-NULL pointer is given.
5110 */
10a20af7
TI		 5111int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5112 int index, int *type_idx)
5113{
5114 int i, label_idx = 0;
5115 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5116 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5117 return -EINVAL;
5118 }
5119 for (i = 0; i < imux->num_items; i++) {
5120 if (!strncmp(label, imux->items[i].label, strlen(label)))
5121 label_idx++;
d7b1ae9d 5122 }
10a20af7
TI		 5123 if (type_idx)
5124 *type_idx = label_idx;
5125 if (label_idx > 0)
5126 snprintf(imux->items[imux->num_items].label,
5127 sizeof(imux->items[imux->num_items].label),
5128 "%s %d", label, label_idx);
b5786e85 5129 else
10a20af7
TI		 5130 strlcpy(imux->items[imux->num_items].label, label,
5131 sizeof(imux->items[imux->num_items].label));
5132 imux->items[imux->num_items].index = index;
5133 imux->num_items++;
5134 return 0;
d7b1ae9d 5135}
10a20af7 5136EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
d7b1ae9d 5137
4a471b7d 5138
1da177e4
LT		 5139#ifdef CONFIG_PM
5140/*
5141 * power management
5142 */
5143
5144/**
5145 * snd_hda_suspend - suspend the codecs
5146 * @bus: the HDA bus
1da177e4
LT		 5147 *
5148 * Returns 0 if successful.
5149 */
8dd78330 5150int snd_hda_suspend(struct hda_bus *bus)
1da177e4 5151{
0ba21762 5152 struct hda_codec *codec;
1da177e4 5153
0ba21762 5154 list_for_each_entry(codec, &bus->codec_list, list) {
e581f3db
TI		 5155 if (hda_codec_is_power_on(codec))
5156 hda_call_codec_suspend(codec);
5157 if (codec->patch_ops.post_suspend)
5158 codec->patch_ops.post_suspend(codec);
1da177e4
LT		 5159 }
5160 return 0;
5161}
ff7a3267 5162EXPORT_SYMBOL_HDA(snd_hda_suspend);
1da177e4
LT		 5163
5164/**
5165 * snd_hda_resume - resume the codecs
5166 * @bus: the HDA bus
1da177e4
LT		 5167 *
5168 * Returns 0 if successful.
cb53c626 5169 *
25985edc 5170 * This function is defined only when POWER_SAVE isn't set.
cb53c626 5171 * In the power-save mode, the codec is resumed dynamically.
1da177e4
LT		 5172 */
5173int snd_hda_resume(struct hda_bus *bus)
5174{
0ba21762 5175 struct hda_codec *codec;
1da177e4 5176
0ba21762 5177 list_for_each_entry(codec, &bus->codec_list, list) {
d02667e6
VK		 5178 if (codec->patch_ops.pre_resume)
5179 codec->patch_ops.pre_resume(codec);
d804ad92
ML		 5180 if (snd_hda_codec_needs_resume(codec))
5181 hda_call_codec_resume(codec);
1da177e4 5182 }
1da177e4
LT		 5183 return 0;
5184}
ff7a3267 5185EXPORT_SYMBOL_HDA(snd_hda_resume);
1289e9e8 5186#endif /* CONFIG_PM */
b2e18597
TI		 5187
5188/*
5189 * generic arrays
5190 */
5191
d5191e50
TI		 5192/**
5193 * snd_array_new - get a new element from the given array
5194 * @array: the array object
28aedaf7 5195 *
d5191e50
TI		 5196 * Get a new element from the given array. If it exceeds the
5197 * pre-allocated array size, re-allocate the array.
5198 *
5199 * Returns NULL if allocation failed.
b2e18597
TI		 5200 */
5201void *snd_array_new(struct snd_array *array)
5202{
5203 if (array->used >= array->alloced) {
5204 int num = array->alloced + array->alloc_align;
3101ba03 5205 int size = (num + 1) * array->elem_size;
00ef9610 5206 int oldsize = array->alloced * array->elem_size;
b910d9ae
TI		 5207 void *nlist;
5208 if (snd_BUG_ON(num >= 4096))
5209 return NULL;
3101ba03 5210 nlist = krealloc(array->list, size, GFP_KERNEL);
b2e18597
TI		 5211 if (!nlist)
5212 return NULL;
00ef9610 5213 memset(nlist + oldsize, 0, size - oldsize);
b2e18597
TI		 5214 array->list = nlist;
5215 array->alloced = num;
5216 }
f43aa025 5217 return snd_array_elem(array, array->used++);
b2e18597 5218}
ff7a3267 5219EXPORT_SYMBOL_HDA(snd_array_new);
b2e18597 5220
d5191e50
TI		 5221/**
5222 * snd_array_free - free the given array elements
5223 * @array: the array object
5224 */
b2e18597
TI		 5225void snd_array_free(struct snd_array *array)
5226{
5227 kfree(array->list);
5228 array->used = 0;
5229 array->alloced = 0;
5230 array->list = NULL;
5231}
ff7a3267 5232EXPORT_SYMBOL_HDA(snd_array_free);
b2022266 5233
d5191e50
TI		 5234/**
5235 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5236 * @pcm: PCM caps bits
5237 * @buf: the string buffer to write
5238 * @buflen: the max buffer length
5239 *
5240 * used by hda_proc.c and hda_eld.c
5241 */
b2022266
TI		 5242void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5243{
5244 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5245 int i, j;
5246
5247 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5248 if (pcm & (AC_SUPPCM_BITS_8 << i))
5249 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5250
5251 buf[j] = '\0'; /* necessary when j == 0 */
5252}
ff7a3267 5253EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
1289e9e8 5254
cd372fb3
TI		 5255#ifdef CONFIG_SND_HDA_INPUT_JACK
5256/*
5257 * Input-jack notification support
5258 */
5259struct hda_jack_item {
5260 hda_nid_t nid;
5261 int type;
5262 struct snd_jack *jack;
5263};
5264
5265static const char *get_jack_default_name(struct hda_codec *codec, hda_nid_t nid,
5266 int type)
5267{
5268 switch (type) {
5269 case SND_JACK_HEADPHONE:
5270 return "Headphone";
5271 case SND_JACK_MICROPHONE:
5272 return "Mic";
5273 case SND_JACK_LINEOUT:
5274 return "Line-out";
7c2f8e40
DH		 5275 case SND_JACK_LINEIN:
5276 return "Line-in";
cd372fb3
TI		 5277 case SND_JACK_HEADSET:
5278 return "Headset";
07acecc1
DH		 5279 case SND_JACK_VIDEOOUT:
5280 return "HDMI/DP";
cd372fb3
TI		 5281 default:
5282 return "Misc";
5283 }
5284}
5285
5286static void hda_free_jack_priv(struct snd_jack *jack)
5287{
5288 struct hda_jack_item *jacks = jack->private_data;
5289 jacks->nid = 0;
5290 jacks->jack = NULL;
5291}
5292
5293int snd_hda_input_jack_add(struct hda_codec *codec, hda_nid_t nid, int type,
5294 const char *name)
5295{
5296 struct hda_jack_item *jack;
5297 int err;
5298
5299 snd_array_init(&codec->jacks, sizeof(*jack), 32);
5300 jack = snd_array_new(&codec->jacks);
5301 if (!jack)
5302 return -ENOMEM;
5303
5304 jack->nid = nid;
5305 jack->type = type;
5306 if (!name)
5307 name = get_jack_default_name(codec, nid, type);
5308 err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
5309 if (err < 0) {
5310 jack->nid = 0;
5311 return err;
5312 }
5313 jack->jack->private_data = jack;
5314 jack->jack->private_free = hda_free_jack_priv;
5315 return 0;
5316}
5317EXPORT_SYMBOL_HDA(snd_hda_input_jack_add);
5318
5319void snd_hda_input_jack_report(struct hda_codec *codec, hda_nid_t nid)
5320{
5321 struct hda_jack_item *jacks = codec->jacks.list;
5322 int i;
5323
5324 if (!jacks)
5325 return;
5326
5327 for (i = 0; i < codec->jacks.used; i++, jacks++) {
5328 unsigned int pin_ctl;
5329 unsigned int present;
5330 int type;
5331
5332 if (jacks->nid != nid)
5333 continue;
5334 present = snd_hda_jack_detect(codec, nid);
5335 type = jacks->type;
5336 if (type == (SND_JACK_HEADPHONE | SND_JACK_LINEOUT)) {
5337 pin_ctl = snd_hda_codec_read(codec, nid, 0,
5338 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5339 type = (pin_ctl & AC_PINCTL_HP_EN) ?
5340 SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
5341 }
5342 snd_jack_report(jacks->jack, present ? type : 0);
5343 }
5344}
5345EXPORT_SYMBOL_HDA(snd_hda_input_jack_report);
5346
5347/* free jack instances manually when clearing/reconfiguring */
5348void snd_hda_input_jack_free(struct hda_codec *codec)
5349{
5350 if (!codec->bus->shutdown && codec->jacks.list) {
5351 struct hda_jack_item *jacks = codec->jacks.list;
5352 int i;
5353 for (i = 0; i < codec->jacks.used; i++, jacks++) {
5354 if (jacks->jack)
5355 snd_device_free(codec->bus->card, jacks->jack);
5356 }
5357 }
5358 snd_array_free(&codec->jacks);
5359}
5360EXPORT_SYMBOL_HDA(snd_hda_input_jack_free);
5361#endif /* CONFIG_SND_HDA_INPUT_JACK */
5362
1289e9e8
TI		 5363MODULE_DESCRIPTION("HDA codec core");
5364MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.86392 seconds and 5 git commands to generate.