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