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