projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: usb-audio: Remove obsoleted fields in struct snd_usb_substream
[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;
5d908ab9 811 unsigned 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
5d6147f1 1323#ifdef CONFIG_SND_HDA_POWER_SAVE
b8dfc462
ML		 1324 codec->d3_stop_clk = snd_hda_codec_get_supported_ps(codec,
1325 codec->afg ? codec->afg : codec->mfg,
1326 AC_PWRST_CLKSTOP);
1327 if (!codec->d3_stop_clk)
1328 bus->power_keep_link_on = 1;
5d6147f1 1329#endif
983f6b93
TI		 1330 codec->epss = snd_hda_codec_get_supported_ps(codec,
1331 codec->afg ? codec->afg : codec->mfg,
1332 AC_PWRST_EPSS);
b8dfc462 1333
bb6ac72f
TI		 1334 /* power-up all before initialization */
1335 hda_set_power_state(codec,
1336 codec->afg ? codec->afg : codec->mfg,
1337 AC_PWRST_D0);
1338
6c1f45ea
TI		 1339 snd_hda_codec_proc_new(codec);
1340
6c1f45ea 1341 snd_hda_create_hwdep(codec);
6c1f45ea
TI		 1342
1343 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1344 codec->subsystem_id, codec->revision_id);
1345 snd_component_add(codec->bus->card, component);
1346
1347 if (codecp)
1348 *codecp = codec;
1349 return 0;
3be14149
TI		 1350
1351 error:
1352 snd_hda_codec_free(codec);
1353 return err;
6c1f45ea 1354}
ff7a3267 1355EXPORT_SYMBOL_HDA(snd_hda_codec_new);
6c1f45ea 1356
d5191e50
TI		 1357/**
1358 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1359 * @codec: the HDA codec
1360 *
1361 * Start parsing of the given codec tree and (re-)initialize the whole
1362 * patch instance.
1363 *
1364 * Returns 0 if successful or a negative error code.
1365 */
6c1f45ea
TI		 1366int snd_hda_codec_configure(struct hda_codec *codec)
1367{
1368 int err;
1369
d5ad630b 1370 codec->preset = find_codec_preset(codec);
812a2cca 1371 if (!codec->vendor_name || !codec->chip_name) {
f44ac837
TI		 1372 err = get_codec_name(codec);
1373 if (err < 0)
1374 return err;
1375 }
1da177e4 1376
82467611 1377 if (is_generic_config(codec)) {
1da177e4 1378 err = snd_hda_parse_generic_codec(codec);
82467611
TI		 1379 goto patched;
1380 }
82467611
TI		 1381 if (codec->preset && codec->preset->patch) {
1382 err = codec->preset->patch(codec);
1383 goto patched;
1384 }
1385
1386 /* call the default parser */
82467611 1387 err = snd_hda_parse_generic_codec(codec);
35a1e0cc
TI		 1388 if (err < 0)
1389 printk(KERN_ERR "hda-codec: No codec parser is available\n");
82467611
TI		 1390
1391 patched:
6c1f45ea
TI		 1392 if (!err && codec->patch_ops.unsol_event)
1393 err = init_unsol_queue(codec->bus);
f62faedb
TI		 1394 /* audio codec should override the mixer name */
1395 if (!err && (codec->afg || !*codec->bus->card->mixername))
1396 snprintf(codec->bus->card->mixername,
1397 sizeof(codec->bus->card->mixername),
1398 "%s %s", codec->vendor_name, codec->chip_name);
6c1f45ea 1399 return err;
1da177e4 1400}
a1e21c90 1401EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1da177e4 1402
ed360813
TI		 1403/* update the stream-id if changed */
1404static void update_pcm_stream_id(struct hda_codec *codec,
1405 struct hda_cvt_setup *p, hda_nid_t nid,
1406 u32 stream_tag, int channel_id)
1407{
1408 unsigned int oldval, newval;
1409
1410 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1411 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1412 newval = (stream_tag << 4) | channel_id;
1413 if (oldval != newval)
1414 snd_hda_codec_write(codec, nid, 0,
1415 AC_VERB_SET_CHANNEL_STREAMID,
1416 newval);
1417 p->stream_tag = stream_tag;
1418 p->channel_id = channel_id;
1419 }
1420}
1421
1422/* update the format-id if changed */
1423static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1424 hda_nid_t nid, int format)
1425{
1426 unsigned int oldval;
1427
1428 if (p->format_id != format) {
1429 oldval = snd_hda_codec_read(codec, nid, 0,
1430 AC_VERB_GET_STREAM_FORMAT, 0);
1431 if (oldval != format) {
1432 msleep(1);
1433 snd_hda_codec_write(codec, nid, 0,
1434 AC_VERB_SET_STREAM_FORMAT,
1435 format);
1436 }
1437 p->format_id = format;
1438 }
1439}
1440
1da177e4
LT		 1441/**
1442 * snd_hda_codec_setup_stream - set up the codec for streaming
1443 * @codec: the CODEC to set up
1444 * @nid: the NID to set up
1445 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1446 * @channel_id: channel id to pass, zero based.
1447 * @format: stream format.
1448 */
0ba21762
TI		 1449void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1450 u32 stream_tag,
1da177e4
LT		 1451 int channel_id, int format)
1452{
3f50ac6a 1453 struct hda_codec *c;
eb541337 1454 struct hda_cvt_setup *p;
62b7e5e0 1455 int type;
eb541337
TI		 1456 int i;
1457
0ba21762 1458 if (!nid)
d21b37ea
TI		 1459 return;
1460
0ba21762
TI		 1461 snd_printdd("hda_codec_setup_stream: "
1462 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1da177e4 1463 nid, stream_tag, channel_id, format);
eb541337
TI		 1464 p = get_hda_cvt_setup(codec, nid);
1465 if (!p)
1466 return;
ed360813
TI		 1467
1468 if (codec->pcm_format_first)
1469 update_pcm_format(codec, p, nid, format);
1470 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1471 if (!codec->pcm_format_first)
1472 update_pcm_format(codec, p, nid, format);
1473
eb541337
TI		 1474 p->active = 1;
1475 p->dirty = 0;
1476
1477 /* make other inactive cvts with the same stream-tag dirty */
62b7e5e0 1478 type = get_wcaps_type(get_wcaps(codec, nid));
3f50ac6a
TI		 1479 list_for_each_entry(c, &codec->bus->codec_list, list) {
1480 for (i = 0; i < c->cvt_setups.used; i++) {
1481 p = snd_array_elem(&c->cvt_setups, i);
62b7e5e0 1482 if (!p->active && p->stream_tag == stream_tag &&
54c2a89f 1483 get_wcaps_type(get_wcaps(c, p->nid)) == type)
3f50ac6a
TI		 1484 p->dirty = 1;
1485 }
eb541337 1486 }
1da177e4 1487}
ff7a3267 1488EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1da177e4 1489
f0cea797
TI		 1490static void really_cleanup_stream(struct hda_codec *codec,
1491 struct hda_cvt_setup *q);
1492
d5191e50 1493/**
f0cea797 1494 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
d5191e50
TI		 1495 * @codec: the CODEC to clean up
1496 * @nid: the NID to clean up
f0cea797 1497 * @do_now: really clean up the stream instead of clearing the active flag
d5191e50 1498 */
f0cea797
TI		 1499void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1500 int do_now)
888afa15 1501{
eb541337
TI		 1502 struct hda_cvt_setup *p;
1503
888afa15
TI		 1504 if (!nid)
1505 return;
1506
0e7adbe2
TI		 1507 if (codec->no_sticky_stream)
1508 do_now = 1;
1509
888afa15 1510 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
eb541337 1511 p = get_hda_cvt_setup(codec, nid);
f0cea797
TI		 1512 if (p) {
1513 /* here we just clear the active flag when do_now isn't set;
1514 * actual clean-ups will be done later in
1515 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1516 */
1517 if (do_now)
1518 really_cleanup_stream(codec, p);
1519 else
1520 p->active = 0;
1521 }
eb541337 1522}
f0cea797 1523EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
eb541337
TI		 1524
1525static void really_cleanup_stream(struct hda_codec *codec,
1526 struct hda_cvt_setup *q)
1527{
1528 hda_nid_t nid = q->nid;
218264ae
TI		 1529 if (q->stream_tag || q->channel_id)
1530 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1531 if (q->format_id)
1532 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1533);
eb541337
TI		 1534 memset(q, 0, sizeof(*q));
1535 q->nid = nid;
1536}
1537
1538/* clean up the all conflicting obsolete streams */
1539static void purify_inactive_streams(struct hda_codec *codec)
1540{
3f50ac6a 1541 struct hda_codec *c;
eb541337
TI		 1542 int i;
1543
3f50ac6a
TI		 1544 list_for_each_entry(c, &codec->bus->codec_list, list) {
1545 for (i = 0; i < c->cvt_setups.used; i++) {
1546 struct hda_cvt_setup *p;
1547 p = snd_array_elem(&c->cvt_setups, i);
1548 if (p->dirty)
1549 really_cleanup_stream(c, p);
1550 }
eb541337
TI		 1551 }
1552}
1553
2a43952a 1554#ifdef CONFIG_PM
eb541337
TI		 1555/* clean up all streams; called from suspend */
1556static void hda_cleanup_all_streams(struct hda_codec *codec)
1557{
1558 int i;
1559
1560 for (i = 0; i < codec->cvt_setups.used; i++) {
1561 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1562 if (p->stream_tag)
1563 really_cleanup_stream(codec, p);
1564 }
888afa15 1565}
1c7276cf 1566#endif
888afa15 1567
1da177e4
LT		 1568/*
1569 * amp access functions
1570 */
1571
4a19faee 1572/* FIXME: more better hash key? */
28aedaf7 1573#define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1327a32b 1574#define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
92c7c8a7
TI		 1575#define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1576#define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1da177e4 1577#define INFO_AMP_CAPS (1<<0)
4a19faee 1578#define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1da177e4
LT		 1579
1580/* initialize the hash table */
1289e9e8 1581static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
01751f54
TI		 1582 unsigned int record_size)
1583{
1584 memset(cache, 0, sizeof(*cache));
1585 memset(cache->hash, 0xff, sizeof(cache->hash));
603c4019 1586 snd_array_init(&cache->buf, record_size, 64);
01751f54
TI		 1587}
1588
1fcaee6e 1589static void free_hda_cache(struct hda_cache_rec *cache)
1da177e4 1590{
603c4019 1591 snd_array_free(&cache->buf);
1da177e4
LT		 1592}
1593
1594/* query the hash. allocate an entry if not found. */
a68d5a54 1595static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1da177e4 1596{
01751f54
TI		 1597 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1598 u16 cur = cache->hash[idx];
1599 struct hda_cache_head *info;
1da177e4
LT		 1600
1601 while (cur != 0xffff) {
f43aa025 1602 info = snd_array_elem(&cache->buf, cur);
1da177e4
LT		 1603 if (info->key == key)
1604 return info;
1605 cur = info->next;
1606 }
a68d5a54
TI		 1607 return NULL;
1608}
1da177e4 1609
a68d5a54
TI		 1610/* query the hash. allocate an entry if not found. */
1611static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1612 u32 key)
1613{
1614 struct hda_cache_head *info = get_hash(cache, key);
1615 if (!info) {
1616 u16 idx, cur;
1617 /* add a new hash entry */
1618 info = snd_array_new(&cache->buf);
1619 if (!info)
1620 return NULL;
1621 cur = snd_array_index(&cache->buf, info);
1622 info->key = key;
1623 info->val = 0;
1624 idx = key % (u16)ARRAY_SIZE(cache->hash);
1625 info->next = cache->hash[idx];
1626 cache->hash[idx] = cur;
1627 }
1da177e4
LT		 1628 return info;
1629}
1630
01751f54
TI		 1631/* query and allocate an amp hash entry */
1632static inline struct hda_amp_info *
1633get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1634{
1635 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1636}
1637
c3b6bcc2
TI		 1638/* overwrite the value with the key in the caps hash */
1639static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1640{
1641 struct hda_amp_info *info;
1642
1643 mutex_lock(&codec->hash_mutex);
1644 info = get_alloc_amp_hash(codec, key);
1645 if (!info) {
1646 mutex_unlock(&codec->hash_mutex);
1647 return -EINVAL;
1648 }
1649 info->amp_caps = val;
1650 info->head.val |= INFO_AMP_CAPS;
1651 mutex_unlock(&codec->hash_mutex);
1652 return 0;
1653}
1654
1655/* query the value from the caps hash; if not found, fetch the current
1656 * value from the given function and store in the hash
1657 */
1658static unsigned int
1659query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1660 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1661{
1662 struct hda_amp_info *info;
1663 unsigned int val;
1664
1665 mutex_lock(&codec->hash_mutex);
1666 info = get_alloc_amp_hash(codec, key);
1667 if (!info) {
1668 mutex_unlock(&codec->hash_mutex);
1669 return 0;
1670 }
1671 if (!(info->head.val & INFO_AMP_CAPS)) {
1672 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1673 val = func(codec, nid, dir);
1674 write_caps_hash(codec, key, val);
1675 } else {
1676 val = info->amp_caps;
1677 mutex_unlock(&codec->hash_mutex);
1678 }
1679 return val;
1680}
1681
1682static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1683 int direction)
1684{
1685 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1686 nid = codec->afg;
1687 return snd_hda_param_read(codec, nid,
1688 direction == HDA_OUTPUT ?
1689 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1690}
1691
d5191e50
TI		 1692/**
1693 * query_amp_caps - query AMP capabilities
1694 * @codec: the HD-auio codec
1695 * @nid: the NID to query
1696 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1697 *
1698 * Query AMP capabilities for the given widget and direction.
1699 * Returns the obtained capability bits.
1700 *
1701 * When cap bits have been already read, this doesn't read again but
1702 * returns the cached value.
1da177e4 1703 */
09a99959 1704u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1da177e4 1705{
c3b6bcc2
TI		 1706 return query_caps_hash(codec, nid, direction,
1707 HDA_HASH_KEY(nid, direction, 0),
1708 read_amp_cap);
1da177e4 1709}
ff7a3267 1710EXPORT_SYMBOL_HDA(query_amp_caps);
1da177e4 1711
d5191e50
TI		 1712/**
1713 * snd_hda_override_amp_caps - Override the AMP capabilities
1714 * @codec: the CODEC to clean up
1715 * @nid: the NID to clean up
1716 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1717 * @caps: the capability bits to set
1718 *
1719 * Override the cached AMP caps bits value by the given one.
1720 * This function is useful if the driver needs to adjust the AMP ranges,
1721 * e.g. limit to 0dB, etc.
1722 *
1723 * Returns zero if successful or a negative error code.
1724 */
897cc188
TI		 1725int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1726 unsigned int caps)
1727{
c3b6bcc2 1728 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
897cc188 1729}
ff7a3267 1730EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1327a32b 1731
c3b6bcc2
TI		 1732static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1733 int dir)
92c7c8a7
TI		 1734{
1735 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1736}
1737
d5191e50
TI		 1738/**
1739 * snd_hda_query_pin_caps - Query PIN capabilities
1740 * @codec: the HD-auio codec
1741 * @nid: the NID to query
1742 *
1743 * Query PIN capabilities for the given widget.
1744 * Returns the obtained capability bits.
1745 *
1746 * When cap bits have been already read, this doesn't read again but
1747 * returns the cached value.
1748 */
92c7c8a7
TI		 1749u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1750{
c3b6bcc2 1751 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
92c7c8a7
TI		 1752 read_pin_cap);
1753}
1327a32b 1754EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
897cc188 1755
f57c2565
TI		 1756/**
1757 * snd_hda_override_pin_caps - Override the pin capabilities
1758 * @codec: the CODEC
1759 * @nid: the NID to override
1760 * @caps: the capability bits to set
1761 *
1762 * Override the cached PIN capabilitiy bits value by the given one.
1763 *
1764 * Returns zero if successful or a negative error code.
1765 */
1766int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1767 unsigned int caps)
1768{
c3b6bcc2 1769 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
f57c2565
TI		 1770}
1771EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1772
c3b6bcc2
TI		 1773/* read or sync the hash value with the current value;
1774 * call within hash_mutex
1da177e4 1775 */
c3b6bcc2
TI		 1776static struct hda_amp_info *
1777update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
1778 int direction, int index)
1da177e4 1779{
c3b6bcc2
TI		 1780 struct hda_amp_info *info;
1781 unsigned int parm, val = 0;
1782 bool val_read = false;
1da177e4 1783
c3b6bcc2
TI		 1784 retry:
1785 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1786 if (!info)
1787 return NULL;
1788 if (!(info->head.val & INFO_AMP_VOL(ch))) {
1789 if (!val_read) {
1790 mutex_unlock(&codec->hash_mutex);
1791 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1792 parm |= direction == HDA_OUTPUT ?
1793 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1794 parm |= index;
1795 val = snd_hda_codec_read(codec, nid, 0,
0ba21762 1796 AC_VERB_GET_AMP_GAIN_MUTE, parm);
c3b6bcc2
TI		 1797 val &= 0xff;
1798 val_read = true;
1799 mutex_lock(&codec->hash_mutex);
1800 goto retry;
1801 }
1802 info->vol[ch] = val;
1803 info->head.val |= INFO_AMP_VOL(ch);
1804 }
1805 return info;
1da177e4
LT		 1806}
1807
1808/*
c3b6bcc2 1809 * write the current volume in info to the h/w
1da177e4 1810 */
4a19faee 1811static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
0ba21762
TI		 1812 hda_nid_t nid, int ch, int direction, int index,
1813 int val)
1da177e4
LT		 1814{
1815 u32 parm;
1816
1817 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1818 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1819 parm |= index << AC_AMP_SET_INDEX_SHIFT;
3868137e
TI		 1820 if ((val & HDA_AMP_MUTE) && !(info->amp_caps & AC_AMPCAP_MUTE) &&
1821 (info->amp_caps & AC_AMPCAP_MIN_MUTE))
1822 ; /* set the zero value as a fake mute */
1823 else
1824 parm |= val;
1da177e4
LT		 1825 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1826}
1827
d5191e50
TI		 1828/**
1829 * snd_hda_codec_amp_read - Read AMP value
1830 * @codec: HD-audio codec
1831 * @nid: NID to read the AMP value
1832 * @ch: channel (left=0 or right=1)
1833 * @direction: #HDA_INPUT or #HDA_OUTPUT
1834 * @index: the index value (only for input direction)
1835 *
1836 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1da177e4 1837 */
834be88d
TI		 1838int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1839 int direction, int index)
1da177e4 1840{
0ba21762 1841 struct hda_amp_info *info;
c3b6bcc2
TI		 1842 unsigned int val = 0;
1843
1844 mutex_lock(&codec->hash_mutex);
1845 info = update_amp_hash(codec, nid, ch, direction, index);
1846 if (info)
1847 val = info->vol[ch];
1848 mutex_unlock(&codec->hash_mutex);
1849 return val;
1da177e4 1850}
ff7a3267 1851EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1da177e4 1852
d5191e50
TI		 1853/**
1854 * snd_hda_codec_amp_update - update the AMP value
1855 * @codec: HD-audio codec
1856 * @nid: NID to read the AMP value
1857 * @ch: channel (left=0 or right=1)
1858 * @direction: #HDA_INPUT or #HDA_OUTPUT
1859 * @idx: the index value (only for input direction)
1860 * @mask: bit mask to set
1861 * @val: the bits value to set
1862 *
1863 * Update the AMP value with a bit mask.
1864 * Returns 0 if the value is unchanged, 1 if changed.
4a19faee 1865 */
834be88d
TI		 1866int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1867 int direction, int idx, int mask, int val)
1da177e4 1868{
0ba21762 1869 struct hda_amp_info *info;
4a19faee 1870
46712646
TI		 1871 if (snd_BUG_ON(mask & ~0xff))
1872 mask &= 0xff;
4a19faee 1873 val &= mask;
c3b6bcc2
TI		 1874
1875 mutex_lock(&codec->hash_mutex);
1876 info = update_amp_hash(codec, nid, ch, direction, idx);
1877 if (!info) {
1878 mutex_unlock(&codec->hash_mutex);
1879 return 0;
1880 }
1881 val |= info->vol[ch] & ~mask;
1882 if (info->vol[ch] == val) {
1883 mutex_unlock(&codec->hash_mutex);
1da177e4 1884 return 0;
c3b6bcc2
TI		 1885 }
1886 info->vol[ch] = val;
1887 mutex_unlock(&codec->hash_mutex);
4a19faee 1888 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1da177e4
LT		 1889 return 1;
1890}
ff7a3267 1891EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1da177e4 1892
d5191e50
TI		 1893/**
1894 * snd_hda_codec_amp_stereo - update the AMP stereo values
1895 * @codec: HD-audio codec
1896 * @nid: NID to read the AMP value
1897 * @direction: #HDA_INPUT or #HDA_OUTPUT
1898 * @idx: the index value (only for input direction)
1899 * @mask: bit mask to set
1900 * @val: the bits value to set
1901 *
1902 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1903 * stereo widget with the same mask and value.
47fd830a
TI		 1904 */
1905int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1906 int direction, int idx, int mask, int val)
1907{
1908 int ch, ret = 0;
46712646
TI		 1909
1910 if (snd_BUG_ON(mask & ~0xff))
1911 mask &= 0xff;
47fd830a
TI		 1912 for (ch = 0; ch < 2; ch++)
1913 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1914 idx, mask, val);
1915 return ret;
1916}
ff7a3267 1917EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
47fd830a 1918
2a43952a 1919#ifdef CONFIG_PM
d5191e50
TI		 1920/**
1921 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1922 * @codec: HD-audio codec
1923 *
1924 * Resume the all amp commands from the cache.
1925 */
b3ac5636
TI		 1926void snd_hda_codec_resume_amp(struct hda_codec *codec)
1927{
603c4019 1928 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
b3ac5636
TI		 1929 int i;
1930
603c4019 1931 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
b3ac5636
TI		 1932 u32 key = buffer->head.key;
1933 hda_nid_t nid;
1934 unsigned int idx, dir, ch;
1935 if (!key)
1936 continue;
1937 nid = key & 0xff;
1938 idx = (key >> 16) & 0xff;
1939 dir = (key >> 24) & 0xff;
1940 for (ch = 0; ch < 2; ch++) {
1941 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1942 continue;
1943 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1944 buffer->vol[ch]);
1945 }
1946 }
1947}
ff7a3267 1948EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
2a43952a 1949#endif /* CONFIG_PM */
1da177e4 1950
afbd9b84
TI		 1951static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1952 unsigned int ofs)
1953{
1954 u32 caps = query_amp_caps(codec, nid, dir);
1955 /* get num steps */
1956 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1957 if (ofs < caps)
1958 caps -= ofs;
1959 return caps;
1960}
1961
d5191e50
TI		 1962/**
1963 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1964 *
1965 * The control element is supposed to have the private_value field
1966 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1967 */
0ba21762
TI		 1968int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1969 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 1970{
1971 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1972 u16 nid = get_amp_nid(kcontrol);
1973 u8 chs = get_amp_channels(kcontrol);
1974 int dir = get_amp_direction(kcontrol);
29fdbec2 1975 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4 1976
afbd9b84
TI		 1977 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1978 uinfo->count = chs == 3 ? 2 : 1;
1979 uinfo->value.integer.min = 0;
1980 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1981 if (!uinfo->value.integer.max) {
0ba21762 1982 printk(KERN_WARNING "hda_codec: "
9c8f2abd
TI		 1983 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1984 kcontrol->id.name);
1da177e4
LT		 1985 return -EINVAL;
1986 }
1da177e4
LT		 1987 return 0;
1988}
ff7a3267 1989EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1da177e4 1990
29fdbec2
TI		 1991
1992static inline unsigned int
1993read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1994 int ch, int dir, int idx, unsigned int ofs)
1995{
1996 unsigned int val;
1997 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1998 val &= HDA_AMP_VOLMASK;
1999 if (val >= ofs)
2000 val -= ofs;
2001 else
2002 val = 0;
2003 return val;
2004}
2005
2006static inline int
2007update_amp_value(struct hda_codec *codec, hda_nid_t nid,
2008 int ch, int dir, int idx, unsigned int ofs,
2009 unsigned int val)
2010{
afbd9b84
TI		 2011 unsigned int maxval;
2012
29fdbec2
TI		 2013 if (val > 0)
2014 val += ofs;
7ccc3efa
TI		 2015 /* ofs = 0: raw max value */
2016 maxval = get_amp_max_value(codec, nid, dir, 0);
afbd9b84
TI		 2017 if (val > maxval)
2018 val = maxval;
29fdbec2
TI		 2019 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
2020 HDA_AMP_VOLMASK, val);
2021}
2022
d5191e50
TI		 2023/**
2024 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
2025 *
2026 * The control element is supposed to have the private_value field
2027 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2028 */
0ba21762
TI		 2029int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
2030 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2031{
2032 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2033 hda_nid_t nid = get_amp_nid(kcontrol);
2034 int chs = get_amp_channels(kcontrol);
2035 int dir = get_amp_direction(kcontrol);
2036 int idx = get_amp_index(kcontrol);
29fdbec2 2037 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 2038 long *valp = ucontrol->value.integer.value;
2039
2040 if (chs & 1)
29fdbec2 2041 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1da177e4 2042 if (chs & 2)
29fdbec2 2043 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1da177e4
LT		 2044 return 0;
2045}
ff7a3267 2046EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1da177e4 2047
d5191e50
TI		 2048/**
2049 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2050 *
2051 * The control element is supposed to have the private_value field
2052 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2053 */
0ba21762
TI		 2054int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2055 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2056{
2057 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2058 hda_nid_t nid = get_amp_nid(kcontrol);
2059 int chs = get_amp_channels(kcontrol);
2060 int dir = get_amp_direction(kcontrol);
2061 int idx = get_amp_index(kcontrol);
29fdbec2 2062 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 2063 long *valp = ucontrol->value.integer.value;
2064 int change = 0;
2065
cb53c626 2066 snd_hda_power_up(codec);
b9f5a89c 2067 if (chs & 1) {
29fdbec2 2068 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
b9f5a89c
NG		 2069 valp++;
2070 }
4a19faee 2071 if (chs & 2)
29fdbec2 2072 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
cb53c626 2073 snd_hda_power_down(codec);
1da177e4
LT		 2074 return change;
2075}
ff7a3267 2076EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1da177e4 2077
d5191e50
TI		 2078/**
2079 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2080 *
2081 * The control element is supposed to have the private_value field
2082 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2083 */
302e9c5a
JK		 2084int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2085 unsigned int size, unsigned int __user *_tlv)
2086{
2087 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2088 hda_nid_t nid = get_amp_nid(kcontrol);
2089 int dir = get_amp_direction(kcontrol);
29fdbec2 2090 unsigned int ofs = get_amp_offset(kcontrol);
de8c85f7 2091 bool min_mute = get_amp_min_mute(kcontrol);
302e9c5a
JK		 2092 u32 caps, val1, val2;
2093
2094 if (size < 4 * sizeof(unsigned int))
2095 return -ENOMEM;
2096 caps = query_amp_caps(codec, nid, dir);
0ba21762
TI		 2097 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2098 val2 = (val2 + 1) * 25;
302e9c5a 2099 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
29fdbec2 2100 val1 += ofs;
302e9c5a 2101 val1 = ((int)val1) * ((int)val2);
3868137e 2102 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
c08d9169 2103 val2 |= TLV_DB_SCALE_MUTE;
302e9c5a
JK		 2104 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2105 return -EFAULT;
2106 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2107 return -EFAULT;
2108 if (put_user(val1, _tlv + 2))
2109 return -EFAULT;
2110 if (put_user(val2, _tlv + 3))
2111 return -EFAULT;
2112 return 0;
2113}
ff7a3267 2114EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
302e9c5a 2115
d5191e50
TI		 2116/**
2117 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2118 * @codec: HD-audio codec
2119 * @nid: NID of a reference widget
2120 * @dir: #HDA_INPUT or #HDA_OUTPUT
2121 * @tlv: TLV data to be stored, at least 4 elements
2122 *
2123 * Set (static) TLV data for a virtual master volume using the AMP caps
2124 * obtained from the reference NID.
2125 * The volume range is recalculated as if the max volume is 0dB.
2134ea4f
TI		 2126 */
2127void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2128 unsigned int *tlv)
2129{
2130 u32 caps;
2131 int nums, step;
2132
2133 caps = query_amp_caps(codec, nid, dir);
2134 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2135 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2136 step = (step + 1) * 25;
2137 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2138 tlv[1] = 2 * sizeof(unsigned int);
2139 tlv[2] = -nums * step;
2140 tlv[3] = step;
2141}
ff7a3267 2142EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2134ea4f
TI		 2143
2144/* find a mixer control element with the given name */
09f99701
TI		 2145static struct snd_kcontrol *
2146_snd_hda_find_mixer_ctl(struct hda_codec *codec,
2147 const char *name, int idx)
2134ea4f
TI		 2148{
2149 struct snd_ctl_elem_id id;
2150 memset(&id, 0, sizeof(id));
2151 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
09f99701 2152 id.index = idx;
18cb7109
TI		 2153 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2154 return NULL;
2134ea4f
TI		 2155 strcpy(id.name, name);
2156 return snd_ctl_find_id(codec->bus->card, &id);
2157}
2158
d5191e50
TI		 2159/**
2160 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2161 * @codec: HD-audio codec
2162 * @name: ctl id name string
2163 *
2164 * Get the control element with the given id string and IFACE_MIXER.
2165 */
09f99701
TI		 2166struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2167 const char *name)
2168{
2169 return _snd_hda_find_mixer_ctl(codec, name, 0);
2170}
ff7a3267 2171EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
09f99701 2172
1afe206a
TI		 2173static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name)
2174{
2175 int idx;
2176 for (idx = 0; idx < 16; idx++) { /* 16 ctlrs should be large enough */
2177 if (!_snd_hda_find_mixer_ctl(codec, name, idx))
2178 return idx;
2179 }
2180 return -EBUSY;
2181}
2182
d5191e50 2183/**
5b0cb1d8 2184 * snd_hda_ctl_add - Add a control element and assign to the codec
d5191e50
TI		 2185 * @codec: HD-audio codec
2186 * @nid: corresponding NID (optional)
2187 * @kctl: the control element to assign
2188 *
2189 * Add the given control element to an array inside the codec instance.
2190 * All control elements belonging to a codec are supposed to be added
2191 * by this function so that a proper clean-up works at the free or
2192 * reconfiguration time.
2193 *
2194 * If non-zero @nid is passed, the NID is assigned to the control element.
2195 * The assignment is shown in the codec proc file.
2196 *
2197 * snd_hda_ctl_add() checks the control subdev id field whether
2198 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
9e3fd871
JK		 2199 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2200 * specifies if kctl->private_value is a HDA amplifier value.
d5191e50 2201 */
3911a4c1
JK		 2202int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2203 struct snd_kcontrol *kctl)
d13bd412
TI		 2204{
2205 int err;
9e3fd871 2206 unsigned short flags = 0;
3911a4c1 2207 struct hda_nid_item *item;
d13bd412 2208
5e26dfd0 2209 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
9e3fd871 2210 flags |= HDA_NID_ITEM_AMP;
5e26dfd0
JK		 2211 if (nid == 0)
2212 nid = get_amp_nid_(kctl->private_value);
2213 }
9e3fd871
JK		 2214 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2215 nid = kctl->id.subdevice & 0xffff;
5e26dfd0 2216 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
4d02d1b6 2217 kctl->id.subdevice = 0;
d13bd412
TI		 2218 err = snd_ctl_add(codec->bus->card, kctl);
2219 if (err < 0)
2220 return err;
3911a4c1
JK		 2221 item = snd_array_new(&codec->mixers);
2222 if (!item)
d13bd412 2223 return -ENOMEM;
3911a4c1
JK		 2224 item->kctl = kctl;
2225 item->nid = nid;
9e3fd871 2226 item->flags = flags;
d13bd412
TI		 2227 return 0;
2228}
ff7a3267 2229EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
d13bd412 2230
5b0cb1d8
JK		 2231/**
2232 * snd_hda_add_nid - Assign a NID to a control element
2233 * @codec: HD-audio codec
2234 * @nid: corresponding NID (optional)
2235 * @kctl: the control element to assign
2236 * @index: index to kctl
2237 *
2238 * Add the given control element to an array inside the codec instance.
2239 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2240 * NID:KCTL mapping - for example "Capture Source" selector.
2241 */
2242int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2243 unsigned int index, hda_nid_t nid)
2244{
2245 struct hda_nid_item *item;
2246
2247 if (nid > 0) {
2248 item = snd_array_new(&codec->nids);
2249 if (!item)
2250 return -ENOMEM;
2251 item->kctl = kctl;
2252 item->index = index;
2253 item->nid = nid;
2254 return 0;
2255 }
28d1a85e
TI		 2256 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2257 kctl->id.name, kctl->id.index, index);
5b0cb1d8
JK		 2258 return -EINVAL;
2259}
2260EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2261
d5191e50
TI		 2262/**
2263 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2264 * @codec: HD-audio codec
2265 */
d13bd412
TI		 2266void snd_hda_ctls_clear(struct hda_codec *codec)
2267{
2268 int i;
3911a4c1 2269 struct hda_nid_item *items = codec->mixers.list;
d13bd412 2270 for (i = 0; i < codec->mixers.used; i++)
3911a4c1 2271 snd_ctl_remove(codec->bus->card, items[i].kctl);
d13bd412 2272 snd_array_free(&codec->mixers);
5b0cb1d8 2273 snd_array_free(&codec->nids);
d13bd412
TI		 2274}
2275
a65d629c
TI		 2276/* pseudo device locking
2277 * toggle card->shutdown to allow/disallow the device access (as a hack)
2278 */
d3d020bd 2279int snd_hda_lock_devices(struct hda_bus *bus)
6c1f45ea 2280{
d3d020bd
TI		 2281 struct snd_card *card = bus->card;
2282 struct hda_codec *codec;
2283
a65d629c 2284 spin_lock(&card->files_lock);
d3d020bd
TI		 2285 if (card->shutdown)
2286 goto err_unlock;
a65d629c 2287 card->shutdown = 1;
d3d020bd
TI		 2288 if (!list_empty(&card->ctl_files))
2289 goto err_clear;
2290
2291 list_for_each_entry(codec, &bus->codec_list, list) {
2292 int pcm;
2293 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2294 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2295 if (!cpcm->pcm)
2296 continue;
2297 if (cpcm->pcm->streams[0].substream_opened ||
2298 cpcm->pcm->streams[1].substream_opened)
2299 goto err_clear;
2300 }
2301 }
a65d629c
TI		 2302 spin_unlock(&card->files_lock);
2303 return 0;
d3d020bd
TI		 2304
2305 err_clear:
2306 card->shutdown = 0;
2307 err_unlock:
2308 spin_unlock(&card->files_lock);
2309 return -EINVAL;
a65d629c 2310}
d3d020bd 2311EXPORT_SYMBOL_HDA(snd_hda_lock_devices);
a65d629c 2312
d3d020bd 2313void snd_hda_unlock_devices(struct hda_bus *bus)
a65d629c 2314{
d3d020bd
TI		 2315 struct snd_card *card = bus->card;
2316
2317 card = bus->card;
a65d629c
TI		 2318 spin_lock(&card->files_lock);
2319 card->shutdown = 0;
2320 spin_unlock(&card->files_lock);
2321}
d3d020bd 2322EXPORT_SYMBOL_HDA(snd_hda_unlock_devices);
a65d629c 2323
d5191e50
TI		 2324/**
2325 * snd_hda_codec_reset - Clear all objects assigned to the codec
2326 * @codec: HD-audio codec
2327 *
2328 * This frees the all PCM and control elements assigned to the codec, and
2329 * clears the caches and restores the pin default configurations.
2330 *
2331 * When a device is being used, it returns -EBSY. If successfully freed,
2332 * returns zero.
2333 */
a65d629c
TI		 2334int snd_hda_codec_reset(struct hda_codec *codec)
2335{
d3d020bd
TI		 2336 struct hda_bus *bus = codec->bus;
2337 struct snd_card *card = bus->card;
2338 int i;
a65d629c 2339
d3d020bd 2340 if (snd_hda_lock_devices(bus) < 0)
a65d629c 2341 return -EBUSY;
a65d629c
TI		 2342
2343 /* OK, let it free */
6c1f45ea
TI		 2344
2345#ifdef CONFIG_SND_HDA_POWER_SAVE
a2d96e77 2346 cancel_delayed_work_sync(&codec->power_work);
339876d7
TI		 2347 codec->power_on = 0;
2348 codec->power_transition = 0;
2349 codec->power_jiffies = jiffies;
d3d020bd 2350 flush_workqueue(bus->workq);
6c1f45ea
TI		 2351#endif
2352 snd_hda_ctls_clear(codec);
2353 /* relase PCMs */
2354 for (i = 0; i < codec->num_pcms; i++) {
529bd6c4 2355 if (codec->pcm_info[i].pcm) {
a65d629c 2356 snd_device_free(card, codec->pcm_info[i].pcm);
529bd6c4 2357 clear_bit(codec->pcm_info[i].device,
d3d020bd 2358 bus->pcm_dev_bits);
529bd6c4 2359 }
6c1f45ea
TI		 2360 }
2361 if (codec->patch_ops.free)
2362 codec->patch_ops.free(codec);
1835a0f9 2363 snd_hda_jack_tbl_clear(codec);
56d17712 2364 codec->proc_widget_hook = NULL;
6c1f45ea
TI		 2365 codec->spec = NULL;
2366 free_hda_cache(&codec->amp_cache);
2367 free_hda_cache(&codec->cmd_cache);
827057f5
TI		 2368 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2369 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
346ff70f
TI		 2370 /* free only driver_pins so that init_pins + user_pins are restored */
2371 snd_array_free(&codec->driver_pins);
3be14149 2372 restore_pincfgs(codec);
09a6071b
TI		 2373 snd_array_free(&codec->cvt_setups);
2374 snd_array_free(&codec->spdif_out);
6c1f45ea
TI		 2375 codec->num_pcms = 0;
2376 codec->pcm_info = NULL;
2377 codec->preset = NULL;
d1f1af2d
TI		 2378 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2379 codec->slave_dig_outs = NULL;
2380 codec->spdif_status_reset = 0;
1289e9e8
TI		 2381 module_put(codec->owner);
2382 codec->owner = NULL;
a65d629c
TI		 2383
2384 /* allow device access again */
d3d020bd 2385 snd_hda_unlock_devices(bus);
a65d629c 2386 return 0;
6c1f45ea
TI		 2387}
2388
aeb4b88e
TI		 2389typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2390
2391/* apply the function to all matching slave ctls in the mixer list */
2392static int map_slaves(struct hda_codec *codec, const char * const *slaves,
9322ca54 2393 const char *suffix, map_slave_func_t func, void *data)
aeb4b88e
TI		 2394{
2395 struct hda_nid_item *items;
2396 const char * const *s;
2397 int i, err;
2398
2399 items = codec->mixers.list;
2400 for (i = 0; i < codec->mixers.used; i++) {
2401 struct snd_kcontrol *sctl = items[i].kctl;
2402 if (!sctl || !sctl->id.name ||
2403 sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2404 continue;
2405 for (s = slaves; *s; s++) {
9322ca54
TI		 2406 char tmpname[sizeof(sctl->id.name)];
2407 const char *name = *s;
2408 if (suffix) {
2409 snprintf(tmpname, sizeof(tmpname), "%s %s",
2410 name, suffix);
2411 name = tmpname;
2412 }
9322ca54 2413 if (!strcmp(sctl->id.name, name)) {
aeb4b88e
TI		 2414 err = func(data, sctl);
2415 if (err)
2416 return err;
2417 break;
2418 }
2419 }
2420 }
2421 return 0;
2422}
2423
2424static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2425{
2426 return 1;
2427}
2428
18478e8b
TI		 2429/* guess the value corresponding to 0dB */
2430static int get_kctl_0dB_offset(struct snd_kcontrol *kctl)
2431{
2432 int _tlv[4];
2433 const int *tlv = NULL;
2434 int val = -1;
2435
2436 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2437 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2438 mm_segment_t fs = get_fs();
2439 set_fs(get_ds());
2440 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2441 tlv = _tlv;
2442 set_fs(fs);
2443 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2444 tlv = kctl->tlv.p;
2445 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE)
2446 val = -tlv[2] / tlv[3];
2447 return val;
2448}
2449
2450/* call kctl->put with the given value(s) */
2451static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2452{
2453 struct snd_ctl_elem_value *ucontrol;
2454 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2455 if (!ucontrol)
2456 return -ENOMEM;
2457 ucontrol->value.integer.value[0] = val;
2458 ucontrol->value.integer.value[1] = val;
2459 kctl->put(kctl, ucontrol);
2460 kfree(ucontrol);
2461 return 0;
2462}
2463
2464/* initialize the slave volume with 0dB */
2465static int init_slave_0dB(void *data, struct snd_kcontrol *slave)
2466{
2467 int offset = get_kctl_0dB_offset(slave);
2468 if (offset > 0)
2469 put_kctl_with_value(slave, offset);
2470 return 0;
2471}
2472
2473/* unmute the slave */
2474static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2475{
2476 return put_kctl_with_value(slave, 1);
2477}
2478
d5191e50
TI		 2479/**
2480 * snd_hda_add_vmaster - create a virtual master control and add slaves
2481 * @codec: HD-audio codec
2482 * @name: vmaster control name
2483 * @tlv: TLV data (optional)
2484 * @slaves: slave control names (optional)
9322ca54 2485 * @suffix: suffix string to each slave name (optional)
18478e8b 2486 * @init_slave_vol: initialize slaves to unmute/0dB
29e5853d 2487 * @ctl_ret: store the vmaster kcontrol in return
d5191e50
TI		 2488 *
2489 * Create a virtual master control with the given name. The TLV data
2490 * must be either NULL or a valid data.
2491 *
2492 * @slaves is a NULL-terminated array of strings, each of which is a
2493 * slave control name. All controls with these names are assigned to
2494 * the new virtual master control.
2495 *
2496 * This function returns zero if successful or a negative error code.
2497 */
18478e8b 2498int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
9322ca54 2499 unsigned int *tlv, const char * const *slaves,
29e5853d
TI		 2500 const char *suffix, bool init_slave_vol,
2501 struct snd_kcontrol **ctl_ret)
2134ea4f
TI		 2502{
2503 struct snd_kcontrol *kctl;
2134ea4f
TI		 2504 int err;
2505
29e5853d
TI		 2506 if (ctl_ret)
2507 *ctl_ret = NULL;
2508
9322ca54 2509 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
aeb4b88e 2510 if (err != 1) {
2f085549
TI		 2511 snd_printdd("No slave found for %s\n", name);
2512 return 0;
2513 }
2134ea4f
TI		 2514 kctl = snd_ctl_make_virtual_master(name, tlv);
2515 if (!kctl)
2516 return -ENOMEM;
3911a4c1 2517 err = snd_hda_ctl_add(codec, 0, kctl);
2134ea4f
TI		 2518 if (err < 0)
2519 return err;
28aedaf7 2520
9322ca54
TI		 2521 err = map_slaves(codec, slaves, suffix,
2522 (map_slave_func_t)snd_ctl_add_slave, kctl);
aeb4b88e
TI		 2523 if (err < 0)
2524 return err;
18478e8b
TI		 2525
2526 /* init with master mute & zero volume */
2527 put_kctl_with_value(kctl, 0);
2528 if (init_slave_vol)
2529 map_slaves(codec, slaves, suffix,
2530 tlv ? init_slave_0dB : init_slave_unmute, kctl);
2531
29e5853d
TI		 2532 if (ctl_ret)
2533 *ctl_ret = kctl;
2134ea4f
TI		 2534 return 0;
2535}
18478e8b 2536EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
2134ea4f 2537
d2f344b5
TI		 2538/*
2539 * mute-LED control using vmaster
2540 */
2541static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2542 struct snd_ctl_elem_info *uinfo)
2543{
2544 static const char * const texts[] = {
2545 "Off", "On", "Follow Master"
2546 };
2547 unsigned int index;
2548
2549 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2550 uinfo->count = 1;
2551 uinfo->value.enumerated.items = 3;
2552 index = uinfo->value.enumerated.item;
2553 if (index >= 3)
2554 index = 2;
2555 strcpy(uinfo->value.enumerated.name, texts[index]);
2556 return 0;
2557}
2558
2559static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2560 struct snd_ctl_elem_value *ucontrol)
2561{
2562 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2563 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2564 return 0;
2565}
2566
2567static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2568 struct snd_ctl_elem_value *ucontrol)
2569{
2570 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2571 unsigned int old_mode = hook->mute_mode;
2572
2573 hook->mute_mode = ucontrol->value.enumerated.item[0];
2574 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2575 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2576 if (old_mode == hook->mute_mode)
2577 return 0;
2578 snd_hda_sync_vmaster_hook(hook);
2579 return 1;
2580}
2581
2582static struct snd_kcontrol_new vmaster_mute_mode = {
2583 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2584 .name = "Mute-LED Mode",
2585 .info = vmaster_mute_mode_info,
2586 .get = vmaster_mute_mode_get,
2587 .put = vmaster_mute_mode_put,
2588};
2589
2590/*
2591 * Add a mute-LED hook with the given vmaster switch kctl
2592 * "Mute-LED Mode" control is automatically created and associated with
2593 * the given hook.
2594 */
2595int snd_hda_add_vmaster_hook(struct hda_codec *codec,
f29735cb
TI		 2596 struct hda_vmaster_mute_hook *hook,
2597 bool expose_enum_ctl)
d2f344b5
TI		 2598{
2599 struct snd_kcontrol *kctl;
2600
2601 if (!hook->hook || !hook->sw_kctl)
2602 return 0;
2603 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2604 hook->codec = codec;
2605 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
f29735cb
TI		 2606 if (!expose_enum_ctl)
2607 return 0;
d2f344b5
TI		 2608 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2609 if (!kctl)
2610 return -ENOMEM;
2611 return snd_hda_ctl_add(codec, 0, kctl);
2612}
2613EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
2614
2615/*
2616 * Call the hook with the current value for synchronization
2617 * Should be called in init callback
2618 */
2619void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2620{
2621 if (!hook->hook || !hook->codec)
2622 return;
2623 switch (hook->mute_mode) {
2624 case HDA_VMUTE_FOLLOW_MASTER:
2625 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2626 break;
2627 default:
2628 hook->hook(hook->codec, hook->mute_mode);
2629 break;
2630 }
2631}
2632EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
2633
2634
d5191e50
TI		 2635/**
2636 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2637 *
2638 * The control element is supposed to have the private_value field
2639 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2640 */
0ba21762
TI		 2641int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2642 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 2643{
2644 int chs = get_amp_channels(kcontrol);
2645
2646 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2647 uinfo->count = chs == 3 ? 2 : 1;
2648 uinfo->value.integer.min = 0;
2649 uinfo->value.integer.max = 1;
2650 return 0;
2651}
ff7a3267 2652EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1da177e4 2653
d5191e50
TI		 2654/**
2655 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2656 *
2657 * The control element is supposed to have the private_value field
2658 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2659 */
0ba21762
TI		 2660int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2661 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2662{
2663 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2664 hda_nid_t nid = get_amp_nid(kcontrol);
2665 int chs = get_amp_channels(kcontrol);
2666 int dir = get_amp_direction(kcontrol);
2667 int idx = get_amp_index(kcontrol);
2668 long *valp = ucontrol->value.integer.value;
2669
2670 if (chs & 1)
0ba21762 2671 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
47fd830a 2672 HDA_AMP_MUTE) ? 0 : 1;
1da177e4 2673 if (chs & 2)
0ba21762 2674 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
47fd830a 2675 HDA_AMP_MUTE) ? 0 : 1;
1da177e4
LT		 2676 return 0;
2677}
ff7a3267 2678EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1da177e4 2679
d5191e50
TI		 2680/**
2681 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2682 *
2683 * The control element is supposed to have the private_value field
2684 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2685 */
0ba21762
TI		 2686int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2687 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2688{
2689 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2690 hda_nid_t nid = get_amp_nid(kcontrol);
2691 int chs = get_amp_channels(kcontrol);
2692 int dir = get_amp_direction(kcontrol);
2693 int idx = get_amp_index(kcontrol);
1da177e4
LT		 2694 long *valp = ucontrol->value.integer.value;
2695 int change = 0;
2696
cb53c626 2697 snd_hda_power_up(codec);
b9f5a89c 2698 if (chs & 1) {
4a19faee 2699 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
47fd830a
TI		 2700 HDA_AMP_MUTE,
2701 *valp ? 0 : HDA_AMP_MUTE);
b9f5a89c
NG		 2702 valp++;
2703 }
4a19faee
TI		 2704 if (chs & 2)
2705 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
47fd830a
TI		 2706 HDA_AMP_MUTE,
2707 *valp ? 0 : HDA_AMP_MUTE);
9e5341b9 2708 hda_call_check_power_status(codec, nid);
cb53c626 2709 snd_hda_power_down(codec);
1da177e4
LT		 2710 return change;
2711}
ff7a3267 2712EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1da177e4 2713
985be54b
TI		 2714/*
2715 * bound volume controls
2716 *
2717 * bind multiple volumes (# indices, from 0)
2718 */
2719
2720#define AMP_VAL_IDX_SHIFT 19
2721#define AMP_VAL_IDX_MASK (0x0f<<19)
2722
d5191e50
TI		 2723/**
2724 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2725 *
2726 * The control element is supposed to have the private_value field
2727 * set up via HDA_BIND_MUTE*() macros.
2728 */
0ba21762
TI		 2729int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2730 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 2731{
2732 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2733 unsigned long pval;
2734 int err;
2735
5a9e02e9 2736 mutex_lock(&codec->control_mutex);
985be54b
TI		 2737 pval = kcontrol->private_value;
2738 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2739 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2740 kcontrol->private_value = pval;
5a9e02e9 2741 mutex_unlock(&codec->control_mutex);
985be54b
TI		 2742 return err;
2743}
ff7a3267 2744EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
985be54b 2745
d5191e50
TI		 2746/**
2747 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2748 *
2749 * The control element is supposed to have the private_value field
2750 * set up via HDA_BIND_MUTE*() macros.
2751 */
0ba21762
TI		 2752int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2753 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 2754{
2755 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2756 unsigned long pval;
2757 int i, indices, err = 0, change = 0;
2758
5a9e02e9 2759 mutex_lock(&codec->control_mutex);
985be54b
TI		 2760 pval = kcontrol->private_value;
2761 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2762 for (i = 0; i < indices; i++) {
0ba21762
TI		 2763 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2764 (i << AMP_VAL_IDX_SHIFT);
985be54b
TI		 2765 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2766 if (err < 0)
2767 break;
2768 change |= err;
2769 }
2770 kcontrol->private_value = pval;
5a9e02e9 2771 mutex_unlock(&codec->control_mutex);
985be54b
TI		 2772 return err < 0 ? err : change;
2773}
ff7a3267 2774EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
985be54b 2775
d5191e50
TI		 2776/**
2777 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2778 *
2779 * The control element is supposed to have the private_value field
2780 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
532d5381
TI		 2781 */
2782int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2783 struct snd_ctl_elem_info *uinfo)
2784{
2785 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2786 struct hda_bind_ctls *c;
2787 int err;
2788
5a9e02e9 2789 mutex_lock(&codec->control_mutex);
14c65f98 2790 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2791 kcontrol->private_value = *c->values;
2792 err = c->ops->info(kcontrol, uinfo);
2793 kcontrol->private_value = (long)c;
5a9e02e9 2794 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2795 return err;
2796}
ff7a3267 2797EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
532d5381 2798
d5191e50
TI		 2799/**
2800 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2801 *
2802 * The control element is supposed to have the private_value field
2803 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2804 */
532d5381
TI		 2805int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2806 struct snd_ctl_elem_value *ucontrol)
2807{
2808 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2809 struct hda_bind_ctls *c;
2810 int err;
2811
5a9e02e9 2812 mutex_lock(&codec->control_mutex);
14c65f98 2813 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2814 kcontrol->private_value = *c->values;
2815 err = c->ops->get(kcontrol, ucontrol);
2816 kcontrol->private_value = (long)c;
5a9e02e9 2817 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2818 return err;
2819}
ff7a3267 2820EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
532d5381 2821
d5191e50
TI		 2822/**
2823 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2824 *
2825 * The control element is supposed to have the private_value field
2826 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2827 */
532d5381
TI		 2828int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2829 struct snd_ctl_elem_value *ucontrol)
2830{
2831 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2832 struct hda_bind_ctls *c;
2833 unsigned long *vals;
2834 int err = 0, change = 0;
2835
5a9e02e9 2836 mutex_lock(&codec->control_mutex);
14c65f98 2837 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2838 for (vals = c->values; *vals; vals++) {
2839 kcontrol->private_value = *vals;
2840 err = c->ops->put(kcontrol, ucontrol);
2841 if (err < 0)
2842 break;
2843 change |= err;
2844 }
2845 kcontrol->private_value = (long)c;
5a9e02e9 2846 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2847 return err < 0 ? err : change;
2848}
ff7a3267 2849EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
532d5381 2850
d5191e50
TI		 2851/**
2852 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2853 *
2854 * The control element is supposed to have the private_value field
2855 * set up via HDA_BIND_VOL() macro.
2856 */
532d5381
TI		 2857int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2858 unsigned int size, unsigned int __user *tlv)
2859{
2860 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2861 struct hda_bind_ctls *c;
2862 int err;
2863
5a9e02e9 2864 mutex_lock(&codec->control_mutex);
14c65f98 2865 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2866 kcontrol->private_value = *c->values;
2867 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2868 kcontrol->private_value = (long)c;
5a9e02e9 2869 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2870 return err;
2871}
ff7a3267 2872EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
532d5381
TI		 2873
2874struct hda_ctl_ops snd_hda_bind_vol = {
2875 .info = snd_hda_mixer_amp_volume_info,
2876 .get = snd_hda_mixer_amp_volume_get,
2877 .put = snd_hda_mixer_amp_volume_put,
2878 .tlv = snd_hda_mixer_amp_tlv
2879};
ff7a3267 2880EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
532d5381
TI		 2881
2882struct hda_ctl_ops snd_hda_bind_sw = {
2883 .info = snd_hda_mixer_amp_switch_info,
2884 .get = snd_hda_mixer_amp_switch_get,
2885 .put = snd_hda_mixer_amp_switch_put,
2886 .tlv = snd_hda_mixer_amp_tlv
2887};
ff7a3267 2888EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
532d5381 2889
1da177e4
LT		 2890/*
2891 * SPDIF out controls
2892 */
2893
0ba21762
TI		 2894static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2895 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 2896{
2897 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2898 uinfo->count = 1;
2899 return 0;
2900}
2901
0ba21762
TI		 2902static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2903 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2904{
2905 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2906 IEC958_AES0_NONAUDIO |
2907 IEC958_AES0_CON_EMPHASIS_5015 |
2908 IEC958_AES0_CON_NOT_COPYRIGHT;
2909 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2910 IEC958_AES1_CON_ORIGINAL;
2911 return 0;
2912}
2913
0ba21762
TI		 2914static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2915 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2916{
2917 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2918 IEC958_AES0_NONAUDIO |
2919 IEC958_AES0_PRO_EMPHASIS_5015;
2920 return 0;
2921}
2922
0ba21762
TI		 2923static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2924 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2925{
2926 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 2927 int idx = kcontrol->private_value;
e3245cdd 2928 struct hda_spdif_out *spdif;
1da177e4 2929
e3245cdd
TI		 2930 mutex_lock(&codec->spdif_mutex);
2931 spdif = snd_array_elem(&codec->spdif_out, idx);
7c935976
SW		 2932 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2933 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2934 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2935 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
e3245cdd 2936 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2937
2938 return 0;
2939}
2940
2941/* convert from SPDIF status bits to HDA SPDIF bits
2942 * bit 0 (DigEn) is always set zero (to be filled later)
2943 */
2944static unsigned short convert_from_spdif_status(unsigned int sbits)
2945{
2946 unsigned short val = 0;
2947
2948 if (sbits & IEC958_AES0_PROFESSIONAL)
0ba21762 2949 val |= AC_DIG1_PROFESSIONAL;
1da177e4 2950 if (sbits & IEC958_AES0_NONAUDIO)
0ba21762 2951 val |= AC_DIG1_NONAUDIO;
1da177e4 2952 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762
TI		 2953 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2954 IEC958_AES0_PRO_EMPHASIS_5015)
2955 val |= AC_DIG1_EMPHASIS;
1da177e4 2956 } else {
0ba21762
TI		 2957 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2958 IEC958_AES0_CON_EMPHASIS_5015)
2959 val |= AC_DIG1_EMPHASIS;
2960 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2961 val |= AC_DIG1_COPYRIGHT;
1da177e4 2962 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
0ba21762 2963 val |= AC_DIG1_LEVEL;
1da177e4
LT		 2964 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2965 }
2966 return val;
2967}
2968
2969/* convert to SPDIF status bits from HDA SPDIF bits
2970 */
2971static unsigned int convert_to_spdif_status(unsigned short val)
2972{
2973 unsigned int sbits = 0;
2974
0ba21762 2975 if (val & AC_DIG1_NONAUDIO)
1da177e4 2976 sbits |= IEC958_AES0_NONAUDIO;
0ba21762 2977 if (val & AC_DIG1_PROFESSIONAL)
1da177e4
LT		 2978 sbits |= IEC958_AES0_PROFESSIONAL;
2979 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762 2980 if (sbits & AC_DIG1_EMPHASIS)
1da177e4
LT		 2981 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2982 } else {
0ba21762 2983 if (val & AC_DIG1_EMPHASIS)
1da177e4 2984 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
0ba21762 2985 if (!(val & AC_DIG1_COPYRIGHT))
1da177e4 2986 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
0ba21762 2987 if (val & AC_DIG1_LEVEL)
1da177e4
LT		 2988 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2989 sbits |= val & (0x7f << 8);
2990 }
2991 return sbits;
2992}
2993
2f72853c
TI		 2994/* set digital convert verbs both for the given NID and its slaves */
2995static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2996 int verb, int val)
2997{
dda14410 2998 const hda_nid_t *d;
2f72853c 2999
9e976976 3000 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2f72853c
TI		 3001 d = codec->slave_dig_outs;
3002 if (!d)
3003 return;
3004 for (; *d; d++)
9e976976 3005 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2f72853c
TI		 3006}
3007
3008static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
3009 int dig1, int dig2)
3010{
3011 if (dig1 != -1)
3012 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
3013 if (dig2 != -1)
3014 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
3015}
3016
0ba21762
TI		 3017static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
3018 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3019{
3020 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 3021 int idx = kcontrol->private_value;
e3245cdd
TI		 3022 struct hda_spdif_out *spdif;
3023 hda_nid_t nid;
1da177e4
LT		 3024 unsigned short val;
3025 int change;
3026
62932df8 3027 mutex_lock(&codec->spdif_mutex);
e3245cdd
TI		 3028 spdif = snd_array_elem(&codec->spdif_out, idx);
3029 nid = spdif->nid;
7c935976 3030 spdif->status = ucontrol->value.iec958.status[0] |
1da177e4
LT		 3031 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
3032 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
3033 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
7c935976
SW		 3034 val = convert_from_spdif_status(spdif->status);
3035 val |= spdif->ctls & 1;
3036 change = spdif->ctls != val;
3037 spdif->ctls = val;
74b654c9 3038 if (change && nid != (u16)-1)
2f72853c 3039 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
62932df8 3040 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3041 return change;
3042}
3043
a5ce8890 3044#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1da177e4 3045
0ba21762
TI		 3046static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3047 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3048{
3049 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 3050 int idx = kcontrol->private_value;
e3245cdd 3051 struct hda_spdif_out *spdif;
1da177e4 3052
e3245cdd
TI		 3053 mutex_lock(&codec->spdif_mutex);
3054 spdif = snd_array_elem(&codec->spdif_out, idx);
7c935976 3055 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
e3245cdd 3056 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3057 return 0;
3058}
3059
74b654c9
SW		 3060static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3061 int dig1, int dig2)
3062{
3063 set_dig_out_convert(codec, nid, dig1, dig2);
3064 /* unmute amp switch (if any) */
3065 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3066 (dig1 & AC_DIG1_ENABLE))
3067 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3068 HDA_AMP_MUTE, 0);
3069}
3070
0ba21762
TI		 3071static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3072 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3073{
3074 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 3075 int idx = kcontrol->private_value;
e3245cdd
TI		 3076 struct hda_spdif_out *spdif;
3077 hda_nid_t nid;
1da177e4
LT		 3078 unsigned short val;
3079 int change;
3080
62932df8 3081 mutex_lock(&codec->spdif_mutex);
e3245cdd
TI		 3082 spdif = snd_array_elem(&codec->spdif_out, idx);
3083 nid = spdif->nid;
7c935976 3084 val = spdif->ctls & ~AC_DIG1_ENABLE;
1da177e4 3085 if (ucontrol->value.integer.value[0])
0ba21762 3086 val |= AC_DIG1_ENABLE;
7c935976 3087 change = spdif->ctls != val;
74b654c9
SW		 3088 spdif->ctls = val;
3089 if (change && nid != (u16)-1)
3090 set_spdif_ctls(codec, nid, val & 0xff, -1);
62932df8 3091 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3092 return change;
3093}
3094
c8b6bf9b 3095static struct snd_kcontrol_new dig_mixes[] = {
1da177e4
LT		 3096 {
3097 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3098 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3099 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
1da177e4
LT		 3100 .info = snd_hda_spdif_mask_info,
3101 .get = snd_hda_spdif_cmask_get,
3102 },
3103 {
3104 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3105 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3106 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
1da177e4
LT		 3107 .info = snd_hda_spdif_mask_info,
3108 .get = snd_hda_spdif_pmask_get,
3109 },
3110 {
3111 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3112 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1da177e4
LT		 3113 .info = snd_hda_spdif_mask_info,
3114 .get = snd_hda_spdif_default_get,
3115 .put = snd_hda_spdif_default_put,
3116 },
3117 {
3118 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3119 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1da177e4
LT		 3120 .info = snd_hda_spdif_out_switch_info,
3121 .get = snd_hda_spdif_out_switch_get,
3122 .put = snd_hda_spdif_out_switch_put,
3123 },
3124 { } /* end */
3125};
3126
3127/**
3128 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
3129 * @codec: the HDA codec
3130 * @nid: audio out widget NID
3131 *
3132 * Creates controls related with the SPDIF output.
3133 * Called from each patch supporting the SPDIF out.
3134 *
3135 * Returns 0 if successful, or a negative error code.
3136 */
74b654c9
SW		 3137int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
3138 hda_nid_t associated_nid,
3139 hda_nid_t cvt_nid)
1da177e4
LT		 3140{
3141 int err;
c8b6bf9b
TI		 3142 struct snd_kcontrol *kctl;
3143 struct snd_kcontrol_new *dig_mix;
09f99701 3144 int idx;
7c935976 3145 struct hda_spdif_out *spdif;
1da177e4 3146
1afe206a
TI		 3147 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
3148 if (idx < 0) {
09f99701
TI		 3149 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3150 return -EBUSY;
3151 }
7c935976 3152 spdif = snd_array_new(&codec->spdif_out);
1da177e4
LT		 3153 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3154 kctl = snd_ctl_new1(dig_mix, codec);
b91f080f
TI		 3155 if (!kctl)
3156 return -ENOMEM;
09f99701 3157 kctl->id.index = idx;
7c935976 3158 kctl->private_value = codec->spdif_out.used - 1;
74b654c9 3159 err = snd_hda_ctl_add(codec, associated_nid, kctl);
0ba21762 3160 if (err < 0)
1da177e4
LT		 3161 return err;
3162 }
74b654c9
SW		 3163 spdif->nid = cvt_nid;
3164 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
7c935976
SW		 3165 AC_VERB_GET_DIGI_CONVERT_1, 0);
3166 spdif->status = convert_to_spdif_status(spdif->ctls);
1da177e4
LT		 3167 return 0;
3168}
ff7a3267 3169EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1da177e4 3170
e3245cdd
TI		 3171/* get the hda_spdif_out entry from the given NID
3172 * call within spdif_mutex lock
3173 */
7c935976
SW		 3174struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3175 hda_nid_t nid)
3176{
3177 int i;
3178 for (i = 0; i < codec->spdif_out.used; i++) {
3179 struct hda_spdif_out *spdif =
3180 snd_array_elem(&codec->spdif_out, i);
3181 if (spdif->nid == nid)
3182 return spdif;
3183 }
3184 return NULL;
3185}
3186EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3187
74b654c9
SW		 3188void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3189{
e3245cdd 3190 struct hda_spdif_out *spdif;
74b654c9
SW		 3191
3192 mutex_lock(&codec->spdif_mutex);
e3245cdd 3193 spdif = snd_array_elem(&codec->spdif_out, idx);
74b654c9
SW		 3194 spdif->nid = (u16)-1;
3195 mutex_unlock(&codec->spdif_mutex);
3196}
3197EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3198
3199void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3200{
e3245cdd 3201 struct hda_spdif_out *spdif;
74b654c9
SW		 3202 unsigned short val;
3203
3204 mutex_lock(&codec->spdif_mutex);
e3245cdd 3205 spdif = snd_array_elem(&codec->spdif_out, idx);
74b654c9
SW		 3206 if (spdif->nid != nid) {
3207 spdif->nid = nid;
3208 val = spdif->ctls;
3209 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3210 }
3211 mutex_unlock(&codec->spdif_mutex);
3212}
3213EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3214
9a08160b
TI		 3215/*
3216 * SPDIF sharing with analog output
3217 */
3218static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3219 struct snd_ctl_elem_value *ucontrol)
3220{
3221 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3222 ucontrol->value.integer.value[0] = mout->share_spdif;
3223 return 0;
3224}
3225
3226static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3227 struct snd_ctl_elem_value *ucontrol)
3228{
3229 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3230 mout->share_spdif = !!ucontrol->value.integer.value[0];
3231 return 0;
3232}
3233
3234static struct snd_kcontrol_new spdif_share_sw = {
3235 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3236 .name = "IEC958 Default PCM Playback Switch",
3237 .info = snd_ctl_boolean_mono_info,
3238 .get = spdif_share_sw_get,
3239 .put = spdif_share_sw_put,
3240};
3241
d5191e50
TI		 3242/**
3243 * snd_hda_create_spdif_share_sw - create Default PCM switch
3244 * @codec: the HDA codec
3245 * @mout: multi-out instance
3246 */
9a08160b
TI		 3247int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3248 struct hda_multi_out *mout)
3249{
3250 if (!mout->dig_out_nid)
3251 return 0;
3252 /* ATTENTION: here mout is passed as private_data, instead of codec */
3911a4c1
JK		 3253 return snd_hda_ctl_add(codec, mout->dig_out_nid,
3254 snd_ctl_new1(&spdif_share_sw, mout));
9a08160b 3255}
ff7a3267 3256EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
9a08160b 3257
1da177e4
LT		 3258/*
3259 * SPDIF input
3260 */
3261
3262#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3263
0ba21762
TI		 3264static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3265 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3266{
3267 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3268
3269 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3270 return 0;
3271}
3272
0ba21762
TI		 3273static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3274 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3275{
3276 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3277 hda_nid_t nid = kcontrol->private_value;
3278 unsigned int val = !!ucontrol->value.integer.value[0];
3279 int change;
3280
62932df8 3281 mutex_lock(&codec->spdif_mutex);
1da177e4 3282 change = codec->spdif_in_enable != val;
82beb8fd 3283 if (change) {
1da177e4 3284 codec->spdif_in_enable = val;
82beb8fd
TI		 3285 snd_hda_codec_write_cache(codec, nid, 0,
3286 AC_VERB_SET_DIGI_CONVERT_1, val);
1da177e4 3287 }
62932df8 3288 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3289 return change;
3290}
3291
0ba21762
TI		 3292static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3293 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3294{
3295 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3296 hda_nid_t nid = kcontrol->private_value;
3297 unsigned short val;
3298 unsigned int sbits;
3299
3982d17e 3300 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1da177e4
LT		 3301 sbits = convert_to_spdif_status(val);
3302 ucontrol->value.iec958.status[0] = sbits;
3303 ucontrol->value.iec958.status[1] = sbits >> 8;
3304 ucontrol->value.iec958.status[2] = sbits >> 16;
3305 ucontrol->value.iec958.status[3] = sbits >> 24;
3306 return 0;
3307}
3308
c8b6bf9b 3309static struct snd_kcontrol_new dig_in_ctls[] = {
1da177e4
LT		 3310 {
3311 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3312 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
1da177e4
LT		 3313 .info = snd_hda_spdif_in_switch_info,
3314 .get = snd_hda_spdif_in_switch_get,
3315 .put = snd_hda_spdif_in_switch_put,
3316 },
3317 {
3318 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3319 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3320 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
1da177e4
LT		 3321 .info = snd_hda_spdif_mask_info,
3322 .get = snd_hda_spdif_in_status_get,
3323 },
3324 { } /* end */
3325};
3326
3327/**
3328 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3329 * @codec: the HDA codec
3330 * @nid: audio in widget NID
3331 *
3332 * Creates controls related with the SPDIF input.
3333 * Called from each patch supporting the SPDIF in.
3334 *
3335 * Returns 0 if successful, or a negative error code.
3336 */
12f288bf 3337int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1da177e4
LT		 3338{
3339 int err;
c8b6bf9b
TI		 3340 struct snd_kcontrol *kctl;
3341 struct snd_kcontrol_new *dig_mix;
09f99701 3342 int idx;
1da177e4 3343
1afe206a
TI		 3344 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3345 if (idx < 0) {
09f99701
TI		 3346 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3347 return -EBUSY;
3348 }
1da177e4
LT		 3349 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3350 kctl = snd_ctl_new1(dig_mix, codec);
c8dcdf82
TI		 3351 if (!kctl)
3352 return -ENOMEM;
1da177e4 3353 kctl->private_value = nid;
3911a4c1 3354 err = snd_hda_ctl_add(codec, nid, kctl);
0ba21762 3355 if (err < 0)
1da177e4
LT		 3356 return err;
3357 }
0ba21762 3358 codec->spdif_in_enable =
3982d17e
AP		 3359 snd_hda_codec_read(codec, nid, 0,
3360 AC_VERB_GET_DIGI_CONVERT_1, 0) &
0ba21762 3361 AC_DIG1_ENABLE;
1da177e4
LT		 3362 return 0;
3363}
ff7a3267 3364EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
1da177e4 3365
2a43952a 3366#ifdef CONFIG_PM
82beb8fd
TI		 3367/*
3368 * command cache
3369 */
1da177e4 3370
b3ac5636
TI		 3371/* build a 32bit cache key with the widget id and the command parameter */
3372#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3373#define get_cmd_cache_nid(key) ((key) & 0xff)
3374#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3375
3376/**
3377 * snd_hda_codec_write_cache - send a single command with caching
3378 * @codec: the HDA codec
3379 * @nid: NID to send the command
3380 * @direct: direct flag
3381 * @verb: the verb to send
3382 * @parm: the parameter for the verb
3383 *
3384 * Send a single command without waiting for response.
3385 *
3386 * Returns 0 if successful, or a negative error code.
3387 */
3388int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3389 int direct, unsigned int verb, unsigned int parm)
3390{
aa2936f5
TI		 3391 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3392 struct hda_cache_head *c;
3393 u32 key;
33fa35ed 3394
aa2936f5
TI		 3395 if (err < 0)
3396 return err;
3397 /* parm may contain the verb stuff for get/set amp */
3398 verb = verb | (parm >> 8);
3399 parm &= 0xff;
3400 key = build_cmd_cache_key(nid, verb);
3401 mutex_lock(&codec->bus->cmd_mutex);
3402 c = get_alloc_hash(&codec->cmd_cache, key);
3403 if (c)
3404 c->val = parm;
3405 mutex_unlock(&codec->bus->cmd_mutex);
3406 return 0;
b3ac5636 3407}
ff7a3267 3408EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
b3ac5636 3409
a68d5a54
TI		 3410/**
3411 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3412 * @codec: the HDA codec
3413 * @nid: NID to send the command
3414 * @direct: direct flag
3415 * @verb: the verb to send
3416 * @parm: the parameter for the verb
3417 *
3418 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3419 * command if the parameter is already identical with the cached value.
3420 * If not, it sends the command and refreshes the cache.
3421 *
3422 * Returns 0 if successful, or a negative error code.
3423 */
3424int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3425 int direct, unsigned int verb, unsigned int parm)
3426{
3427 struct hda_cache_head *c;
3428 u32 key;
3429
3430 /* parm may contain the verb stuff for get/set amp */
3431 verb = verb | (parm >> 8);
3432 parm &= 0xff;
3433 key = build_cmd_cache_key(nid, verb);
3434 mutex_lock(&codec->bus->cmd_mutex);
3435 c = get_hash(&codec->cmd_cache, key);
3436 if (c && c->val == parm) {
3437 mutex_unlock(&codec->bus->cmd_mutex);
3438 return 0;
3439 }
3440 mutex_unlock(&codec->bus->cmd_mutex);
3441 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3442}
3443EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3444
d5191e50
TI		 3445/**
3446 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3447 * @codec: HD-audio codec
3448 *
3449 * Execute all verbs recorded in the command caches to resume.
3450 */
b3ac5636
TI		 3451void snd_hda_codec_resume_cache(struct hda_codec *codec)
3452{
603c4019 3453 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
b3ac5636
TI		 3454 int i;
3455
603c4019 3456 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
b3ac5636
TI		 3457 u32 key = buffer->key;
3458 if (!key)
3459 continue;
3460 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3461 get_cmd_cache_cmd(key), buffer->val);
3462 }
3463}
ff7a3267 3464EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
b3ac5636
TI		 3465
3466/**
3467 * snd_hda_sequence_write_cache - sequence writes with caching
3468 * @codec: the HDA codec
3469 * @seq: VERB array to send
3470 *
3471 * Send the commands sequentially from the given array.
3472 * Thte commands are recorded on cache for power-save and resume.
3473 * The array must be terminated with NID=0.
3474 */
3475void snd_hda_sequence_write_cache(struct hda_codec *codec,
3476 const struct hda_verb *seq)
3477{
3478 for (; seq->nid; seq++)
3479 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3480 seq->param);
3481}
ff7a3267 3482EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2a43952a 3483#endif /* CONFIG_PM */
b3ac5636 3484
4d7fbdbc
TI		 3485void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3486 unsigned int power_state,
3487 bool eapd_workaround)
54d17403 3488{
4d7fbdbc 3489 hda_nid_t nid = codec->start_nid;
cb53c626 3490 int i;
54d17403 3491
cb53c626 3492 for (i = 0; i < codec->num_nodes; i++, nid++) {
7eba5c9d 3493 unsigned int wcaps = get_wcaps(codec, nid);
4d7fbdbc
TI		 3494 if (!(wcaps & AC_WCAP_POWER))
3495 continue;
3496 /* don't power down the widget if it controls eapd and
3497 * EAPD_BTLENABLE is set.
3498 */
3499 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3500 get_wcaps_type(wcaps) == AC_WID_PIN &&
3501 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3502 int eapd = snd_hda_codec_read(codec, nid, 0,
7eba5c9d 3503 AC_VERB_GET_EAPD_BTLENABLE, 0);
4d7fbdbc
TI		 3504 if (eapd & 0x02)
3505 continue;
1194b5b7 3506 }
4d7fbdbc
TI		 3507 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3508 power_state);
54d17403
TI		 3509 }
3510
cb53c626
TI		 3511 if (power_state == AC_PWRST_D0) {
3512 unsigned long end_time;
3513 int state;
cb53c626
TI		 3514 /* wait until the codec reachs to D0 */
3515 end_time = jiffies + msecs_to_jiffies(500);
3516 do {
3517 state = snd_hda_codec_read(codec, fg, 0,
3518 AC_VERB_GET_POWER_STATE, 0);
3519 if (state == power_state)
3520 break;
3521 msleep(1);
3522 } while (time_after_eq(end_time, jiffies));
3523 }
3524}
4d7fbdbc
TI		 3525EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3526
0c7f46ad
WX		 3527/*
3528 * supported power states check
3529 */
3530static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
3531 unsigned int power_state)
3532{
3533 int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
3534
e037cb4a 3535 if (sup == -1)
0c7f46ad
WX		 3536 return false;
3537 if (sup & power_state)
3538 return true;
3539 else
3540 return false;
3541}
3542
4d7fbdbc
TI		 3543/*
3544 * set power state of the codec
3545 */
3546static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3547 unsigned int power_state)
3548{
09617ce4
WX		 3549 int count;
3550 unsigned int state;
3551
5d6147f1 3552#ifdef CONFIG_SND_HDA_POWER_SAVE
b8dfc462 3553 codec->d3_stop_clk_ok = 0;
5d6147f1 3554#endif
b8dfc462 3555
4d7fbdbc
TI		 3556 if (codec->patch_ops.set_power_state) {
3557 codec->patch_ops.set_power_state(codec, fg, power_state);
3558 return;
3559 }
3560
3561 /* this delay seems necessary to avoid click noise at power-down */
0f4ccbb0
WX		 3562 if (power_state == AC_PWRST_D3) {
3563 /* transition time less than 10ms for power down */
983f6b93 3564 msleep(codec->epss ? 10 : 100);
0f4ccbb0 3565 }
09617ce4
WX		 3566
3567 /* repeat power states setting at most 10 times*/
3568 for (count = 0; count < 10; count++) {
3569 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3570 power_state);
3571 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3572 state = snd_hda_codec_read(codec, fg, 0,
3573 AC_VERB_GET_POWER_STATE, 0);
3574 if (!(state & AC_PWRST_ERROR))
3575 break;
3576 }
b8dfc462 3577
5d6147f1 3578#ifdef CONFIG_SND_HDA_POWER_SAVE
b8dfc462
ML		 3579 if ((power_state == AC_PWRST_D3)
3580 && codec->d3_stop_clk && (state & AC_PWRST_CLK_STOP_OK))
3581 codec->d3_stop_clk_ok = 1;
5d6147f1 3582#endif
4d7fbdbc 3583}
cb53c626 3584
11aeff08
TI		 3585#ifdef CONFIG_SND_HDA_HWDEP
3586/* execute additional init verbs */
3587static void hda_exec_init_verbs(struct hda_codec *codec)
3588{
3589 if (codec->init_verbs.list)
3590 snd_hda_sequence_write(codec, codec->init_verbs.list);
3591}
3592#else
3593static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3594#endif
3595
2a43952a 3596#ifdef CONFIG_PM
cb53c626
TI		 3597/*
3598 * call suspend and power-down; used both from PM and power-save
3599 */
3600static void hda_call_codec_suspend(struct hda_codec *codec)
3601{
3602 if (codec->patch_ops.suspend)
68cb2b55 3603 codec->patch_ops.suspend(codec);
eb541337 3604 hda_cleanup_all_streams(codec);
cb53c626
TI		 3605 hda_set_power_state(codec,
3606 codec->afg ? codec->afg : codec->mfg,
3607 AC_PWRST_D3);
3608#ifdef CONFIG_SND_HDA_POWER_SAVE
3609 cancel_delayed_work(&codec->power_work);
a2d96e77
TI		 3610 spin_lock(&codec->power_lock);
3611 snd_hda_update_power_acct(codec);
3612 trace_hda_power_down(codec);
95e99fda 3613 codec->power_on = 0;
a221e287 3614 codec->power_transition = 0;
a2f6309e 3615 codec->power_jiffies = jiffies;
a2d96e77 3616 spin_unlock(&codec->power_lock);
cb53c626 3617#endif
54d17403
TI		 3618}
3619
cb53c626
TI		 3620/*
3621 * kick up codec; used both from PM and power-save
3622 */
3623static void hda_call_codec_resume(struct hda_codec *codec)
3624{
7f30830b
TI		 3625 /* set as if powered on for avoiding re-entering the resume
3626 * in the resume / power-save sequence
3627 */
3628 hda_keep_power_on(codec);
cb53c626
TI		 3629 hda_set_power_state(codec,
3630 codec->afg ? codec->afg : codec->mfg,
3631 AC_PWRST_D0);
3be14149 3632 restore_pincfgs(codec); /* restore all current pin configs */
ac0547dc 3633 restore_shutup_pins(codec);
11aeff08 3634 hda_exec_init_verbs(codec);
1835a0f9 3635 snd_hda_jack_set_dirty_all(codec);
cb53c626
TI		 3636 if (codec->patch_ops.resume)
3637 codec->patch_ops.resume(codec);
3638 else {
9d99f312
TI		 3639 if (codec->patch_ops.init)
3640 codec->patch_ops.init(codec);
cb53c626
TI		 3641 snd_hda_codec_resume_amp(codec);
3642 snd_hda_codec_resume_cache(codec);
3643 }
8a535414 3644 snd_hda_jack_report_sync(codec);
7f30830b 3645 snd_hda_power_down(codec); /* flag down before returning */
cb53c626 3646}
2a43952a 3647#endif /* CONFIG_PM */
cb53c626 3648
54d17403 3649
1da177e4
LT		 3650/**
3651 * snd_hda_build_controls - build mixer controls
3652 * @bus: the BUS
3653 *
3654 * Creates mixer controls for each codec included in the bus.
3655 *
3656 * Returns 0 if successful, otherwise a negative error code.
3657 */
1289e9e8 3658int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
1da177e4 3659{
0ba21762 3660 struct hda_codec *codec;
1da177e4 3661
0ba21762 3662 list_for_each_entry(codec, &bus->codec_list, list) {
6c1f45ea 3663 int err = snd_hda_codec_build_controls(codec);
f93d461b 3664 if (err < 0) {
28d1a85e 3665 printk(KERN_ERR "hda_codec: cannot build controls "
28aedaf7 3666 "for #%d (error %d)\n", codec->addr, err);
f93d461b
TI		 3667 err = snd_hda_codec_reset(codec);
3668 if (err < 0) {
3669 printk(KERN_ERR
3670 "hda_codec: cannot revert codec\n");
3671 return err;
3672 }
3673 }
1da177e4 3674 }
6c1f45ea
TI		 3675 return 0;
3676}
ff7a3267 3677EXPORT_SYMBOL_HDA(snd_hda_build_controls);
cb53c626 3678
6c1f45ea
TI		 3679int snd_hda_codec_build_controls(struct hda_codec *codec)
3680{
3681 int err = 0;
11aeff08 3682 hda_exec_init_verbs(codec);
6c1f45ea
TI		 3683 /* continue to initialize... */
3684 if (codec->patch_ops.init)
3685 err = codec->patch_ops.init(codec);
3686 if (!err && codec->patch_ops.build_controls)
3687 err = codec->patch_ops.build_controls(codec);
6c1f45ea
TI		 3688 if (err < 0)
3689 return err;
8a535414 3690 snd_hda_jack_report_sync(codec); /* call at the last init point */
1da177e4
LT		 3691 return 0;
3692}
3693
1da177e4
LT		 3694/*
3695 * stream formats
3696 */
befdf316
TI		 3697struct hda_rate_tbl {
3698 unsigned int hz;
3699 unsigned int alsa_bits;
3700 unsigned int hda_fmt;
3701};
3702
92f10b3f
TI		 3703/* rate = base * mult / div */
3704#define HDA_RATE(base, mult, div) \
3705 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3706 (((div) - 1) << AC_FMT_DIV_SHIFT))
3707
befdf316 3708static struct hda_rate_tbl rate_bits[] = {
1da177e4 3709 /* rate in Hz, ALSA rate bitmask, HDA format value */
9d8f53f2
NG		 3710
3711 /* autodetected value used in snd_hda_query_supported_pcm */
92f10b3f
TI		 3712 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3713 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3714 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3715 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3716 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3717 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3718 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3719 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3720 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3721 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3722 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
a961f9fe
TI		 3723#define AC_PAR_PCM_RATE_BITS 11
3724 /* up to bits 10, 384kHZ isn't supported properly */
3725
3726 /* not autodetected value */
92f10b3f 3727 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
9d8f53f2 3728
befdf316 3729 { 0 } /* terminator */
1da177e4
LT		 3730};
3731
3732/**
3733 * snd_hda_calc_stream_format - calculate format bitset
3734 * @rate: the sample rate
3735 * @channels: the number of channels
3736 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3737 * @maxbps: the max. bps
3738 *
3739 * Calculate the format bitset from the given rate, channels and th PCM format.
3740 *
3741 * Return zero if invalid.
3742 */
3743unsigned int snd_hda_calc_stream_format(unsigned int rate,
3744 unsigned int channels,
3745 unsigned int format,
32c168c8
AH		 3746 unsigned int maxbps,
3747 unsigned short spdif_ctls)
1da177e4
LT		 3748{
3749 int i;
3750 unsigned int val = 0;
3751
befdf316
TI		 3752 for (i = 0; rate_bits[i].hz; i++)
3753 if (rate_bits[i].hz == rate) {
3754 val = rate_bits[i].hda_fmt;
1da177e4
LT		 3755 break;
3756 }
0ba21762 3757 if (!rate_bits[i].hz) {
1da177e4
LT		 3758 snd_printdd("invalid rate %d\n", rate);
3759 return 0;
3760 }
3761
3762 if (channels == 0 || channels > 8) {
3763 snd_printdd("invalid channels %d\n", channels);
3764 return 0;
3765 }
3766 val |= channels - 1;
3767
3768 switch (snd_pcm_format_width(format)) {
28aedaf7 3769 case 8:
92f10b3f 3770 val |= AC_FMT_BITS_8;
28aedaf7
NL		 3771 break;
3772 case 16:
92f10b3f 3773 val |= AC_FMT_BITS_16;
28aedaf7 3774 break;
1da177e4
LT		 3775 case 20:
3776 case 24:
3777 case 32:
b0bb3aa6 3778 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
92f10b3f 3779 val |= AC_FMT_BITS_32;
1da177e4 3780 else if (maxbps >= 24)
92f10b3f 3781 val |= AC_FMT_BITS_24;
1da177e4 3782 else
92f10b3f 3783 val |= AC_FMT_BITS_20;
1da177e4
LT		 3784 break;
3785 default:
0ba21762
TI		 3786 snd_printdd("invalid format width %d\n",
3787 snd_pcm_format_width(format));
1da177e4
LT		 3788 return 0;
3789 }
3790
32c168c8 3791 if (spdif_ctls & AC_DIG1_NONAUDIO)
92f10b3f 3792 val |= AC_FMT_TYPE_NON_PCM;
32c168c8 3793
1da177e4
LT		 3794 return val;
3795}
ff7a3267 3796EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
1da177e4 3797
c3b6bcc2
TI		 3798static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
3799 int dir)
92c7c8a7
TI		 3800{
3801 unsigned int val = 0;
3802 if (nid != codec->afg &&
3803 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3804 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3805 if (!val || val == -1)
3806 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3807 if (!val || val == -1)
3808 return 0;
3809 return val;
3810}
3811
3812static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3813{
c3b6bcc2 3814 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
92c7c8a7
TI		 3815 get_pcm_param);
3816}
3817
c3b6bcc2
TI		 3818static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
3819 int dir)
92c7c8a7
TI		 3820{
3821 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3822 if (!streams || streams == -1)
3823 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3824 if (!streams || streams == -1)
3825 return 0;
3826 return streams;
3827}
3828
3829static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3830{
c3b6bcc2 3831 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
92c7c8a7
TI		 3832 get_stream_param);
3833}
3834
1da177e4
LT		 3835/**
3836 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3837 * @codec: the HDA codec
3838 * @nid: NID to query
3839 * @ratesp: the pointer to store the detected rate bitflags
3840 * @formatsp: the pointer to store the detected formats
3841 * @bpsp: the pointer to store the detected format widths
3842 *
3843 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3844 * or @bsps argument is ignored.
3845 *
3846 * Returns 0 if successful, otherwise a negative error code.
3847 */
384a48d7 3848int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
1da177e4
LT		 3849 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3850{
ee504710 3851 unsigned int i, val, wcaps;
1da177e4 3852
ee504710 3853 wcaps = get_wcaps(codec, nid);
92c7c8a7 3854 val = query_pcm_param(codec, nid);
1da177e4
LT		 3855
3856 if (ratesp) {
3857 u32 rates = 0;
a961f9fe 3858 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
1da177e4 3859 if (val & (1 << i))
befdf316 3860 rates |= rate_bits[i].alsa_bits;
1da177e4 3861 }
ee504710
JK		 3862 if (rates == 0) {
3863 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3864 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3865 nid, val,
3866 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3867 return -EIO;
3868 }
1da177e4
LT		 3869 *ratesp = rates;
3870 }
3871
3872 if (formatsp || bpsp) {
3873 u64 formats = 0;
ee504710 3874 unsigned int streams, bps;
1da177e4 3875
92c7c8a7
TI		 3876 streams = query_stream_param(codec, nid);
3877 if (!streams)
1da177e4 3878 return -EIO;
1da177e4
LT		 3879
3880 bps = 0;
3881 if (streams & AC_SUPFMT_PCM) {
3882 if (val & AC_SUPPCM_BITS_8) {
3883 formats |= SNDRV_PCM_FMTBIT_U8;
3884 bps = 8;
3885 }
3886 if (val & AC_SUPPCM_BITS_16) {
3887 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3888 bps = 16;
3889 }
3890 if (wcaps & AC_WCAP_DIGITAL) {
3891 if (val & AC_SUPPCM_BITS_32)
3892 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3893 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3894 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3895 if (val & AC_SUPPCM_BITS_24)
3896 bps = 24;
3897 else if (val & AC_SUPPCM_BITS_20)
3898 bps = 20;
0ba21762
TI		 3899 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3900 AC_SUPPCM_BITS_32)) {
1da177e4
LT		 3901 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3902 if (val & AC_SUPPCM_BITS_32)
3903 bps = 32;
1da177e4
LT		 3904 else if (val & AC_SUPPCM_BITS_24)
3905 bps = 24;
33ef7651
NG		 3906 else if (val & AC_SUPPCM_BITS_20)
3907 bps = 20;
1da177e4
LT		 3908 }
3909 }
8c7dd890 3910#if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
b5025c50 3911 if (streams & AC_SUPFMT_FLOAT32) {
1da177e4 3912 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
b0bb3aa6
TI		 3913 if (!bps)
3914 bps = 32;
b5025c50 3915 }
8c7dd890 3916#endif
b5025c50 3917 if (streams == AC_SUPFMT_AC3) {
0ba21762 3918 /* should be exclusive */
1da177e4
LT		 3919 /* temporary hack: we have still no proper support
3920 * for the direct AC3 stream...
3921 */
3922 formats |= SNDRV_PCM_FMTBIT_U8;
3923 bps = 8;
3924 }
ee504710
JK		 3925 if (formats == 0) {
3926 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3927 "(nid=0x%x, val=0x%x, ovrd=%i, "
3928 "streams=0x%x)\n",
3929 nid, val,
3930 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3931 streams);
3932 return -EIO;
3933 }
1da177e4
LT		 3934 if (formatsp)
3935 *formatsp = formats;
3936 if (bpsp)
3937 *bpsp = bps;
3938 }
3939
3940 return 0;
3941}
384a48d7 3942EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
1da177e4
LT		 3943
3944/**
d5191e50
TI		 3945 * snd_hda_is_supported_format - Check the validity of the format
3946 * @codec: HD-audio codec
3947 * @nid: NID to check
3948 * @format: the HD-audio format value to check
3949 *
3950 * Check whether the given node supports the format value.
1da177e4
LT		 3951 *
3952 * Returns 1 if supported, 0 if not.
3953 */
3954int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3955 unsigned int format)
3956{
3957 int i;
3958 unsigned int val = 0, rate, stream;
3959
92c7c8a7
TI		 3960 val = query_pcm_param(codec, nid);
3961 if (!val)
3962 return 0;
1da177e4
LT		 3963
3964 rate = format & 0xff00;
a961f9fe 3965 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
befdf316 3966 if (rate_bits[i].hda_fmt == rate) {
1da177e4
LT		 3967 if (val & (1 << i))
3968 break;
3969 return 0;
3970 }
a961f9fe 3971 if (i >= AC_PAR_PCM_RATE_BITS)
1da177e4
LT		 3972 return 0;
3973
92c7c8a7
TI		 3974 stream = query_stream_param(codec, nid);
3975 if (!stream)
1da177e4
LT		 3976 return 0;
3977
3978 if (stream & AC_SUPFMT_PCM) {
3979 switch (format & 0xf0) {
3980 case 0x00:
0ba21762 3981 if (!(val & AC_SUPPCM_BITS_8))
1da177e4
LT		 3982 return 0;
3983 break;
3984 case 0x10:
0ba21762 3985 if (!(val & AC_SUPPCM_BITS_16))
1da177e4
LT		 3986 return 0;
3987 break;
3988 case 0x20:
0ba21762 3989 if (!(val & AC_SUPPCM_BITS_20))
1da177e4
LT		 3990 return 0;
3991 break;
3992 case 0x30:
0ba21762 3993 if (!(val & AC_SUPPCM_BITS_24))
1da177e4
LT		 3994 return 0;
3995 break;
3996 case 0x40:
0ba21762 3997 if (!(val & AC_SUPPCM_BITS_32))
1da177e4
LT		 3998 return 0;
3999 break;
4000 default:
4001 return 0;
4002 }
4003 } else {
4004 /* FIXME: check for float32 and AC3? */
4005 }
4006
4007 return 1;
4008}
ff7a3267 4009EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
1da177e4
LT		 4010
4011/*
4012 * PCM stuff
4013 */
4014static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
4015 struct hda_codec *codec,
c8b6bf9b 4016 struct snd_pcm_substream *substream)
1da177e4
LT		 4017{
4018 return 0;
4019}
4020
4021static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
4022 struct hda_codec *codec,
4023 unsigned int stream_tag,
4024 unsigned int format,
c8b6bf9b 4025 struct snd_pcm_substream *substream)
1da177e4
LT		 4026{
4027 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4028 return 0;
4029}
4030
4031static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
4032 struct hda_codec *codec,
c8b6bf9b 4033 struct snd_pcm_substream *substream)
1da177e4 4034{
888afa15 4035 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
1da177e4
LT		 4036 return 0;
4037}
4038
6c1f45ea
TI		 4039static int set_pcm_default_values(struct hda_codec *codec,
4040 struct hda_pcm_stream *info)
1da177e4 4041{
ee504710
JK		 4042 int err;
4043
0ba21762
TI		 4044 /* query support PCM information from the given NID */
4045 if (info->nid && (!info->rates || !info->formats)) {
ee504710 4046 err = snd_hda_query_supported_pcm(codec, info->nid,
0ba21762
TI		 4047 info->rates ? NULL : &info->rates,
4048 info->formats ? NULL : &info->formats,
4049 info->maxbps ? NULL : &info->maxbps);
ee504710
JK		 4050 if (err < 0)
4051 return err;
1da177e4
LT		 4052 }
4053 if (info->ops.open == NULL)
4054 info->ops.open = hda_pcm_default_open_close;
4055 if (info->ops.close == NULL)
4056 info->ops.close = hda_pcm_default_open_close;
4057 if (info->ops.prepare == NULL) {
da3cec35
TI		 4058 if (snd_BUG_ON(!info->nid))
4059 return -EINVAL;
1da177e4
LT		 4060 info->ops.prepare = hda_pcm_default_prepare;
4061 }
1da177e4 4062 if (info->ops.cleanup == NULL) {
da3cec35
TI		 4063 if (snd_BUG_ON(!info->nid))
4064 return -EINVAL;
1da177e4
LT		 4065 info->ops.cleanup = hda_pcm_default_cleanup;
4066 }
4067 return 0;
4068}
4069
eb541337
TI		 4070/*
4071 * codec prepare/cleanup entries
4072 */
4073int snd_hda_codec_prepare(struct hda_codec *codec,
4074 struct hda_pcm_stream *hinfo,
4075 unsigned int stream,
4076 unsigned int format,
4077 struct snd_pcm_substream *substream)
4078{
4079 int ret;
3f50ac6a 4080 mutex_lock(&codec->bus->prepare_mutex);
eb541337
TI		 4081 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4082 if (ret >= 0)
4083 purify_inactive_streams(codec);
3f50ac6a 4084 mutex_unlock(&codec->bus->prepare_mutex);
eb541337
TI		 4085 return ret;
4086}
4087EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
4088
4089void snd_hda_codec_cleanup(struct hda_codec *codec,
4090 struct hda_pcm_stream *hinfo,
4091 struct snd_pcm_substream *substream)
4092{
3f50ac6a 4093 mutex_lock(&codec->bus->prepare_mutex);
eb541337 4094 hinfo->ops.cleanup(hinfo, codec, substream);
3f50ac6a 4095 mutex_unlock(&codec->bus->prepare_mutex);
eb541337
TI		 4096}
4097EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
4098
d5191e50 4099/* global */
e3303235
JK		 4100const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4101 "Audio", "SPDIF", "HDMI", "Modem"
4102};
4103
529bd6c4
TI		 4104/*
4105 * get the empty PCM device number to assign
c8936222
TI		 4106 *
4107 * note the max device number is limited by HDA_MAX_PCMS, currently 10
529bd6c4
TI		 4108 */
4109static int get_empty_pcm_device(struct hda_bus *bus, int type)
4110{
f5d6def5
WF		 4111 /* audio device indices; not linear to keep compatibility */
4112 static int audio_idx[HDA_PCM_NTYPES][5] = {
4113 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4114 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
92608bad 4115 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
f5d6def5 4116 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
529bd6c4 4117 };
f5d6def5
WF		 4118 int i;
4119
4120 if (type >= HDA_PCM_NTYPES) {
529bd6c4
TI		 4121 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4122 return -EINVAL;
4123 }
f5d6def5
WF		 4124
4125 for (i = 0; audio_idx[type][i] >= 0 ; i++)
4126 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4127 return audio_idx[type][i];
4128
01b65bfb
TI		 4129 /* non-fixed slots starting from 10 */
4130 for (i = 10; i < 32; i++) {
4131 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4132 return i;
4133 }
4134
28aedaf7
NL		 4135 snd_printk(KERN_WARNING "Too many %s devices\n",
4136 snd_hda_pcm_type_name[type]);
f5d6def5 4137 return -EAGAIN;
529bd6c4
TI		 4138}
4139
176d5335
TI		 4140/*
4141 * attach a new PCM stream
4142 */
529bd6c4 4143static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
176d5335 4144{
33fa35ed 4145 struct hda_bus *bus = codec->bus;
176d5335
TI		 4146 struct hda_pcm_stream *info;
4147 int stream, err;
4148
b91f080f 4149 if (snd_BUG_ON(!pcm->name))
176d5335
TI		 4150 return -EINVAL;
4151 for (stream = 0; stream < 2; stream++) {
4152 info = &pcm->stream[stream];
4153 if (info->substreams) {
4154 err = set_pcm_default_values(codec, info);
4155 if (err < 0)
4156 return err;
4157 }
4158 }
33fa35ed 4159 return bus->ops.attach_pcm(bus, codec, pcm);
176d5335
TI		 4160}
4161
529bd6c4
TI		 4162/* assign all PCMs of the given codec */
4163int snd_hda_codec_build_pcms(struct hda_codec *codec)
4164{
4165 unsigned int pcm;
4166 int err;
4167
4168 if (!codec->num_pcms) {
4169 if (!codec->patch_ops.build_pcms)
4170 return 0;
4171 err = codec->patch_ops.build_pcms(codec);
6e655bf2
TI		 4172 if (err < 0) {
4173 printk(KERN_ERR "hda_codec: cannot build PCMs"
28aedaf7 4174 "for #%d (error %d)\n", codec->addr, err);
6e655bf2
TI		 4175 err = snd_hda_codec_reset(codec);
4176 if (err < 0) {
4177 printk(KERN_ERR
4178 "hda_codec: cannot revert codec\n");
4179 return err;
4180 }
4181 }
529bd6c4
TI		 4182 }
4183 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4184 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4185 int dev;
4186
4187 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
41b5b01a 4188 continue; /* no substreams assigned */
529bd6c4
TI		 4189
4190 if (!cpcm->pcm) {
4191 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4192 if (dev < 0)
6e655bf2 4193 continue; /* no fatal error */
529bd6c4
TI		 4194 cpcm->device = dev;
4195 err = snd_hda_attach_pcm(codec, cpcm);
6e655bf2
TI		 4196 if (err < 0) {
4197 printk(KERN_ERR "hda_codec: cannot attach "
4198 "PCM stream %d for codec #%d\n",
4199 dev, codec->addr);
4200 continue; /* no fatal error */
4201 }
529bd6c4
TI		 4202 }
4203 }
4204 return 0;
4205}
4206
1da177e4
LT		 4207/**
4208 * snd_hda_build_pcms - build PCM information
4209 * @bus: the BUS
4210 *
4211 * Create PCM information for each codec included in the bus.
4212 *
4213 * The build_pcms codec patch is requested to set up codec->num_pcms and
4214 * codec->pcm_info properly. The array is referred by the top-level driver
4215 * to create its PCM instances.
4216 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4217 * callback.
4218 *
4219 * At least, substreams, channels_min and channels_max must be filled for
4220 * each stream. substreams = 0 indicates that the stream doesn't exist.
4221 * When rates and/or formats are zero, the supported values are queried
4222 * from the given nid. The nid is used also by the default ops.prepare
4223 * and ops.cleanup callbacks.
4224 *
4225 * The driver needs to call ops.open in its open callback. Similarly,
4226 * ops.close is supposed to be called in the close callback.
4227 * ops.prepare should be called in the prepare or hw_params callback
4228 * with the proper parameters for set up.
4229 * ops.cleanup should be called in hw_free for clean up of streams.
4230 *
25985edc 4231 * This function returns 0 if successful, or a negative error code.
1da177e4 4232 */
5cb543db 4233int snd_hda_build_pcms(struct hda_bus *bus)
1da177e4 4234{
0ba21762 4235 struct hda_codec *codec;
1da177e4 4236
0ba21762 4237 list_for_each_entry(codec, &bus->codec_list, list) {
529bd6c4
TI		 4238 int err = snd_hda_codec_build_pcms(codec);
4239 if (err < 0)
4240 return err;
1da177e4
LT		 4241 }
4242 return 0;
4243}
ff7a3267 4244EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
1da177e4 4245
1da177e4
LT		 4246/**
4247 * snd_hda_check_board_config - compare the current codec with the config table
4248 * @codec: the HDA codec
f5fcc13c
TI		 4249 * @num_configs: number of config enums
4250 * @models: array of model name strings
1da177e4
LT		 4251 * @tbl: configuration table, terminated by null entries
4252 *
4253 * Compares the modelname or PCI subsystem id of the current codec with the
4254 * given configuration table. If a matching entry is found, returns its
4255 * config value (supposed to be 0 or positive).
4256 *
4257 * If no entries are matching, the function returns a negative value.
4258 */
12f288bf 4259int snd_hda_check_board_config(struct hda_codec *codec,
ea734963 4260 int num_configs, const char * const *models,
12f288bf 4261 const struct snd_pci_quirk *tbl)
1da177e4 4262{
f44ac837 4263 if (codec->modelname && models) {
f5fcc13c
TI		 4264 int i;
4265 for (i = 0; i < num_configs; i++) {
4266 if (models[i] &&
f44ac837 4267 !strcmp(codec->modelname, models[i])) {
f5fcc13c
TI		 4268 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4269 "selected\n", models[i]);
4270 return i;
1da177e4
LT		 4271 }
4272 }
4273 }
4274
f5fcc13c
TI		 4275 if (!codec->bus->pci || !tbl)
4276 return -1;
4277
4278 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4279 if (!tbl)
4280 return -1;
4281 if (tbl->value >= 0 && tbl->value < num_configs) {
62cf872a 4282#ifdef CONFIG_SND_DEBUG_VERBOSE
f5fcc13c
TI		 4283 char tmp[10];
4284 const char *model = NULL;
4285 if (models)
4286 model = models[tbl->value];
4287 if (!model) {
4288 sprintf(tmp, "#%d", tbl->value);
4289 model = tmp;
1da177e4 4290 }
f5fcc13c
TI		 4291 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4292 "for config %x:%x (%s)\n",
4293 model, tbl->subvendor, tbl->subdevice,
4294 (tbl->name ? tbl->name : "Unknown device"));
4295#endif
4296 return tbl->value;
1da177e4
LT		 4297 }
4298 return -1;
4299}
ff7a3267 4300EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
1da177e4 4301
2eda3445
MCC		 4302/**
4303 * snd_hda_check_board_codec_sid_config - compare the current codec
28aedaf7
NL		 4304 subsystem ID with the
4305 config table
2eda3445
MCC		 4306
4307 This is important for Gateway notebooks with SB450 HDA Audio
4308 where the vendor ID of the PCI device is:
4309 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4310 and the vendor/subvendor are found only at the codec.
4311
4312 * @codec: the HDA codec
4313 * @num_configs: number of config enums
4314 * @models: array of model name strings
4315 * @tbl: configuration table, terminated by null entries
4316 *
4317 * Compares the modelname or PCI subsystem id of the current codec with the
4318 * given configuration table. If a matching entry is found, returns its
4319 * config value (supposed to be 0 or positive).
4320 *
4321 * If no entries are matching, the function returns a negative value.
4322 */
4323int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
ea734963 4324 int num_configs, const char * const *models,
2eda3445
MCC		 4325 const struct snd_pci_quirk *tbl)
4326{
4327 const struct snd_pci_quirk *q;
4328
4329 /* Search for codec ID */
4330 for (q = tbl; q->subvendor; q++) {
e2301a4d
TI		 4331 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4332 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4333 if ((codec->subsystem_id & mask) == id)
2eda3445
MCC		 4334 break;
4335 }
4336
4337 if (!q->subvendor)
4338 return -1;
4339
4340 tbl = q;
4341
4342 if (tbl->value >= 0 && tbl->value < num_configs) {
d94ff6b7 4343#ifdef CONFIG_SND_DEBUG_VERBOSE
2eda3445
MCC		 4344 char tmp[10];
4345 const char *model = NULL;
4346 if (models)
4347 model = models[tbl->value];
4348 if (!model) {
4349 sprintf(tmp, "#%d", tbl->value);
4350 model = tmp;
4351 }
4352 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4353 "for config %x:%x (%s)\n",
4354 model, tbl->subvendor, tbl->subdevice,
4355 (tbl->name ? tbl->name : "Unknown device"));
4356#endif
4357 return tbl->value;
4358 }
4359 return -1;
4360}
4361EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4362
1da177e4
LT		 4363/**
4364 * snd_hda_add_new_ctls - create controls from the array
4365 * @codec: the HDA codec
c8b6bf9b 4366 * @knew: the array of struct snd_kcontrol_new
1da177e4
LT		 4367 *
4368 * This helper function creates and add new controls in the given array.
4369 * The array must be terminated with an empty entry as terminator.
4370 *
4371 * Returns 0 if successful, or a negative error code.
4372 */
031024ee
TI		 4373int snd_hda_add_new_ctls(struct hda_codec *codec,
4374 const struct snd_kcontrol_new *knew)
1da177e4 4375{
4d02d1b6 4376 int err;
1da177e4
LT		 4377
4378 for (; knew->name; knew++) {
54d17403 4379 struct snd_kcontrol *kctl;
1afe206a 4380 int addr = 0, idx = 0;
5b0cb1d8
JK		 4381 if (knew->iface == -1) /* skip this codec private value */
4382 continue;
1afe206a 4383 for (;;) {
54d17403 4384 kctl = snd_ctl_new1(knew, codec);
0ba21762 4385 if (!kctl)
54d17403 4386 return -ENOMEM;
1afe206a
TI		 4387 if (addr > 0)
4388 kctl->id.device = addr;
4389 if (idx > 0)
4390 kctl->id.index = idx;
3911a4c1 4391 err = snd_hda_ctl_add(codec, 0, kctl);
1afe206a
TI		 4392 if (!err)
4393 break;
4394 /* try first with another device index corresponding to
4395 * the codec addr; if it still fails (or it's the
4396 * primary codec), then try another control index
4397 */
4398 if (!addr && codec->addr)
4399 addr = codec->addr;
4400 else if (!idx && !knew->index) {
4401 idx = find_empty_mixer_ctl_idx(codec,
4402 knew->name);
4403 if (idx <= 0)
4404 return err;
4405 } else
54d17403
TI		 4406 return err;
4407 }
1da177e4
LT		 4408 }
4409 return 0;
4410}
ff7a3267 4411EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
1da177e4 4412
cb53c626 4413#ifdef CONFIG_SND_HDA_POWER_SAVE
cb53c626
TI		 4414static void hda_power_work(struct work_struct *work)
4415{
4416 struct hda_codec *codec =
4417 container_of(work, struct hda_codec, power_work.work);
33fa35ed 4418 struct hda_bus *bus = codec->bus;
cb53c626 4419
5536c6d6 4420 spin_lock(&codec->power_lock);
a2d96e77
TI		 4421 if (codec->power_transition > 0) { /* during power-up sequence? */
4422 spin_unlock(&codec->power_lock);
4423 return;
4424 }
2e492462
ML		 4425 if (!codec->power_on || codec->power_count) {
4426 codec->power_transition = 0;
5536c6d6 4427 spin_unlock(&codec->power_lock);
cb53c626 4428 return;
2e492462 4429 }
5536c6d6
TI		 4430 spin_unlock(&codec->power_lock);
4431
cb53c626 4432 hda_call_codec_suspend(codec);
33fa35ed 4433 if (bus->ops.pm_notify)
b8dfc462 4434 bus->ops.pm_notify(bus, codec);
cb53c626
TI		 4435}
4436
4437static void hda_keep_power_on(struct hda_codec *codec)
4438{
5536c6d6 4439 spin_lock(&codec->power_lock);
cb53c626
TI		 4440 codec->power_count++;
4441 codec->power_on = 1;
a2f6309e 4442 codec->power_jiffies = jiffies;
5536c6d6 4443 spin_unlock(&codec->power_lock);
a2f6309e
TI		 4444}
4445
d5191e50 4446/* update the power on/off account with the current jiffies */
a2f6309e
TI		 4447void snd_hda_update_power_acct(struct hda_codec *codec)
4448{
4449 unsigned long delta = jiffies - codec->power_jiffies;
4450 if (codec->power_on)
4451 codec->power_on_acct += delta;
4452 else
4453 codec->power_off_acct += delta;
4454 codec->power_jiffies += delta;
cb53c626
TI		 4455}
4456
b4a91cf0
DR		 4457/* Transition to powered up, if wait_power_down then wait for a pending
4458 * transition to D3 to complete. A pending D3 transition is indicated
4459 * with power_transition == -1. */
c376e2c7 4460/* call this with codec->power_lock held! */
b4a91cf0 4461static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
cb53c626 4462{
33fa35ed
TI		 4463 struct hda_bus *bus = codec->bus;
4464
b4a91cf0
DR		 4465 /* Return if power_on or transitioning to power_on, unless currently
4466 * powering down. */
4467 if ((codec->power_on || codec->power_transition > 0) &&
c376e2c7 4468 !(wait_power_down && codec->power_transition < 0))
cb53c626 4469 return;
a2d96e77 4470 spin_unlock(&codec->power_lock);
cb53c626 4471
a2d96e77
TI		 4472 cancel_delayed_work_sync(&codec->power_work);
4473
4474 spin_lock(&codec->power_lock);
b43d2247
DR		 4475 /* If the power down delayed work was cancelled above before starting,
4476 * then there is no need to go through power up here.
4477 */
4478 if (codec->power_on) {
535b6c51
TI		 4479 if (codec->power_transition < 0)
4480 codec->power_transition = 0;
b43d2247
DR		 4481 return;
4482 }
c376e2c7 4483
d66fee5d 4484 trace_hda_power_up(codec);
a2f6309e 4485 snd_hda_update_power_acct(codec);
cb53c626 4486 codec->power_on = 1;
a2f6309e 4487 codec->power_jiffies = jiffies;
7f30830b 4488 codec->power_transition = 1; /* avoid reentrance */
5536c6d6
TI		 4489 spin_unlock(&codec->power_lock);
4490
33fa35ed 4491 if (bus->ops.pm_notify)
b8dfc462 4492 bus->ops.pm_notify(bus, codec);
cb53c626 4493 hda_call_codec_resume(codec);
5536c6d6
TI		 4494
4495 spin_lock(&codec->power_lock);
a221e287 4496 codec->power_transition = 0;
cb53c626 4497}
b4a91cf0 4498
c376e2c7
TI		 4499#define power_save(codec) \
4500 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
1289e9e8 4501
c376e2c7
TI		 4502/* Transition to powered down */
4503static void __snd_hda_power_down(struct hda_codec *codec)
b4a91cf0 4504{
c376e2c7
TI		 4505 if (!codec->power_on || codec->power_count || codec->power_transition)
4506 return;
b4a91cf0 4507
c376e2c7
TI		 4508 if (power_save(codec)) {
4509 codec->power_transition = -1; /* avoid reentrance */
4510 queue_delayed_work(codec->bus->workq, &codec->power_work,
4511 msecs_to_jiffies(power_save(codec) * 1000));
4512 }
4513}
cb53c626 4514
d5191e50 4515/**
c376e2c7 4516 * snd_hda_power_save - Power-up/down/sync the codec
d5191e50 4517 * @codec: HD-audio codec
c376e2c7 4518 * @delta: the counter delta to change
d5191e50 4519 *
c376e2c7
TI		 4520 * Change the power-up counter via @delta, and power up or down the hardware
4521 * appropriately. For the power-down, queue to the delayed action.
4522 * Passing zero to @delta means to synchronize the power state.
28aedaf7 4523 */
c376e2c7 4524void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait)
cb53c626 4525{
5536c6d6 4526 spin_lock(&codec->power_lock);
c376e2c7 4527 codec->power_count += delta;
b244d335 4528 trace_hda_power_count(codec);
c376e2c7
TI		 4529 if (delta > 0)
4530 __snd_hda_power_up(codec, d3wait);
4531 else
4532 __snd_hda_power_down(codec);
5536c6d6 4533 spin_unlock(&codec->power_lock);
cb53c626 4534}
c376e2c7 4535EXPORT_SYMBOL_HDA(snd_hda_power_save);
cb53c626 4536
d5191e50
TI		 4537/**
4538 * snd_hda_check_amp_list_power - Check the amp list and update the power
4539 * @codec: HD-audio codec
4540 * @check: the object containing an AMP list and the status
4541 * @nid: NID to check / update
4542 *
4543 * Check whether the given NID is in the amp list. If it's in the list,
4544 * check the current AMP status, and update the the power-status according
4545 * to the mute status.
4546 *
4547 * This function is supposed to be set or called from the check_power_status
4548 * patch ops.
28aedaf7 4549 */
cb53c626
TI		 4550int snd_hda_check_amp_list_power(struct hda_codec *codec,
4551 struct hda_loopback_check *check,
4552 hda_nid_t nid)
4553{
031024ee 4554 const struct hda_amp_list *p;
cb53c626
TI		 4555 int ch, v;
4556
4557 if (!check->amplist)
4558 return 0;
4559 for (p = check->amplist; p->nid; p++) {
4560 if (p->nid == nid)
4561 break;
4562 }
4563 if (!p->nid)
4564 return 0; /* nothing changed */
4565
4566 for (p = check->amplist; p->nid; p++) {
4567 for (ch = 0; ch < 2; ch++) {
4568 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4569 p->idx);
4570 if (!(v & HDA_AMP_MUTE) && v > 0) {
4571 if (!check->power_on) {
4572 check->power_on = 1;
4573 snd_hda_power_up(codec);
4574 }
4575 return 1;
4576 }
4577 }
4578 }
4579 if (check->power_on) {
4580 check->power_on = 0;
4581 snd_hda_power_down(codec);
4582 }
4583 return 0;
4584}
ff7a3267 4585EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
cb53c626 4586#endif
1da177e4 4587
c8b6bf9b 4588/*
d2a6d7dc
TI		 4589 * Channel mode helper
4590 */
d5191e50
TI		 4591
4592/**
4593 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4594 */
0ba21762
TI		 4595int snd_hda_ch_mode_info(struct hda_codec *codec,
4596 struct snd_ctl_elem_info *uinfo,
4597 const struct hda_channel_mode *chmode,
4598 int num_chmodes)
d2a6d7dc
TI		 4599{
4600 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4601 uinfo->count = 1;
4602 uinfo->value.enumerated.items = num_chmodes;
4603 if (uinfo->value.enumerated.item >= num_chmodes)
4604 uinfo->value.enumerated.item = num_chmodes - 1;
4605 sprintf(uinfo->value.enumerated.name, "%dch",
4606 chmode[uinfo->value.enumerated.item].channels);
4607 return 0;
4608}
ff7a3267 4609EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
d2a6d7dc 4610
d5191e50
TI		 4611/**
4612 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4613 */
0ba21762
TI		 4614int snd_hda_ch_mode_get(struct hda_codec *codec,
4615 struct snd_ctl_elem_value *ucontrol,
4616 const struct hda_channel_mode *chmode,
4617 int num_chmodes,
d2a6d7dc
TI		 4618 int max_channels)
4619{
4620 int i;
4621
4622 for (i = 0; i < num_chmodes; i++) {
4623 if (max_channels == chmode[i].channels) {
4624 ucontrol->value.enumerated.item[0] = i;
4625 break;
4626 }
4627 }
4628 return 0;
4629}
ff7a3267 4630EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
d2a6d7dc 4631
d5191e50
TI		 4632/**
4633 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4634 */
0ba21762
TI		 4635int snd_hda_ch_mode_put(struct hda_codec *codec,
4636 struct snd_ctl_elem_value *ucontrol,
4637 const struct hda_channel_mode *chmode,
4638 int num_chmodes,
d2a6d7dc
TI		 4639 int *max_channelsp)
4640{
4641 unsigned int mode;
4642
4643 mode = ucontrol->value.enumerated.item[0];
68ea7b2f
TI		 4644 if (mode >= num_chmodes)
4645 return -EINVAL;
82beb8fd 4646 if (*max_channelsp == chmode[mode].channels)
d2a6d7dc
TI		 4647 return 0;
4648 /* change the current channel setting */
4649 *max_channelsp = chmode[mode].channels;
4650 if (chmode[mode].sequence)
82beb8fd 4651 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
d2a6d7dc
TI		 4652 return 1;
4653}
ff7a3267 4654EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
d2a6d7dc 4655
1da177e4
LT		 4656/*
4657 * input MUX helper
4658 */
d5191e50
TI		 4659
4660/**
4661 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4662 */
0ba21762
TI		 4663int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4664 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 4665{
4666 unsigned int index;
4667
4668 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4669 uinfo->count = 1;
4670 uinfo->value.enumerated.items = imux->num_items;
5513b0c5
TI		 4671 if (!imux->num_items)
4672 return 0;
1da177e4
LT		 4673 index = uinfo->value.enumerated.item;
4674 if (index >= imux->num_items)
4675 index = imux->num_items - 1;
4676 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4677 return 0;
4678}
ff7a3267 4679EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
1da177e4 4680
d5191e50
TI		 4681/**
4682 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4683 */
0ba21762
TI		 4684int snd_hda_input_mux_put(struct hda_codec *codec,
4685 const struct hda_input_mux *imux,
4686 struct snd_ctl_elem_value *ucontrol,
4687 hda_nid_t nid,
1da177e4
LT		 4688 unsigned int *cur_val)
4689{
4690 unsigned int idx;
4691
5513b0c5
TI		 4692 if (!imux->num_items)
4693 return 0;
1da177e4
LT		 4694 idx = ucontrol->value.enumerated.item[0];
4695 if (idx >= imux->num_items)
4696 idx = imux->num_items - 1;
82beb8fd 4697 if (*cur_val == idx)
1da177e4 4698 return 0;
82beb8fd
TI		 4699 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4700 imux->items[idx].index);
1da177e4
LT		 4701 *cur_val = idx;
4702 return 1;
4703}
ff7a3267 4704EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
1da177e4
LT		 4705
4706
4707/*
4708 * Multi-channel / digital-out PCM helper functions
4709 */
4710
6b97eb45
TI		 4711/* setup SPDIF output stream */
4712static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4713 unsigned int stream_tag, unsigned int format)
4714{
7c935976
SW		 4715 struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4716
6b97eb45 4717 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
7c935976 4718 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
28aedaf7 4719 set_dig_out_convert(codec, nid,
7c935976 4720 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
2f72853c 4721 -1);
6b97eb45 4722 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2f72853c 4723 if (codec->slave_dig_outs) {
dda14410 4724 const hda_nid_t *d;
2f72853c
TI		 4725 for (d = codec->slave_dig_outs; *d; d++)
4726 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4727 format);
4728 }
6b97eb45 4729 /* turn on again (if needed) */
7c935976 4730 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
2f72853c 4731 set_dig_out_convert(codec, nid,
7c935976 4732 spdif->ctls & 0xff, -1);
2f72853c 4733}
de51ca12 4734
2f72853c
TI		 4735static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4736{
4737 snd_hda_codec_cleanup_stream(codec, nid);
4738 if (codec->slave_dig_outs) {
dda14410 4739 const hda_nid_t *d;
2f72853c
TI		 4740 for (d = codec->slave_dig_outs; *d; d++)
4741 snd_hda_codec_cleanup_stream(codec, *d);
de51ca12 4742 }
6b97eb45
TI		 4743}
4744
d5191e50
TI		 4745/**
4746 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4747 * @bus: HD-audio bus
4748 */
fb8d1a34
TI		 4749void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4750{
4751 struct hda_codec *codec;
4752
4753 if (!bus)
4754 return;
4755 list_for_each_entry(codec, &bus->codec_list, list) {
e581f3db
TI		 4756 if (hda_codec_is_power_on(codec) &&
4757 codec->patch_ops.reboot_notify)
fb8d1a34
TI		 4758 codec->patch_ops.reboot_notify(codec);
4759 }
4760}
8f217a22 4761EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
fb8d1a34 4762
d5191e50
TI		 4763/**
4764 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
1da177e4 4765 */
0ba21762
TI		 4766int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4767 struct hda_multi_out *mout)
1da177e4 4768{
62932df8 4769 mutex_lock(&codec->spdif_mutex);
5930ca41
TI		 4770 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4771 /* already opened as analog dup; reset it once */
2f72853c 4772 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4 4773 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
62932df8 4774 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4775 return 0;
4776}
ff7a3267 4777EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
1da177e4 4778
d5191e50
TI		 4779/**
4780 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4781 */
6b97eb45
TI		 4782int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4783 struct hda_multi_out *mout,
4784 unsigned int stream_tag,
4785 unsigned int format,
4786 struct snd_pcm_substream *substream)
4787{
4788 mutex_lock(&codec->spdif_mutex);
4789 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4790 mutex_unlock(&codec->spdif_mutex);
4791 return 0;
4792}
ff7a3267 4793EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
6b97eb45 4794
d5191e50
TI		 4795/**
4796 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4797 */
9411e21c
TI		 4798int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4799 struct hda_multi_out *mout)
4800{
4801 mutex_lock(&codec->spdif_mutex);
4802 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4803 mutex_unlock(&codec->spdif_mutex);
4804 return 0;
4805}
4806EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4807
d5191e50
TI		 4808/**
4809 * snd_hda_multi_out_dig_close - release the digital out stream
1da177e4 4810 */
0ba21762
TI		 4811int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4812 struct hda_multi_out *mout)
1da177e4 4813{
62932df8 4814 mutex_lock(&codec->spdif_mutex);
1da177e4 4815 mout->dig_out_used = 0;
62932df8 4816 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4817 return 0;
4818}
ff7a3267 4819EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
1da177e4 4820
d5191e50
TI		 4821/**
4822 * snd_hda_multi_out_analog_open - open analog outputs
4823 *
4824 * Open analog outputs and set up the hw-constraints.
4825 * If the digital outputs can be opened as slave, open the digital
4826 * outputs, too.
1da177e4 4827 */
0ba21762
TI		 4828int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4829 struct hda_multi_out *mout,
9a08160b
TI		 4830 struct snd_pcm_substream *substream,
4831 struct hda_pcm_stream *hinfo)
4832{
4833 struct snd_pcm_runtime *runtime = substream->runtime;
4834 runtime->hw.channels_max = mout->max_channels;
4835 if (mout->dig_out_nid) {
4836 if (!mout->analog_rates) {
4837 mout->analog_rates = hinfo->rates;
4838 mout->analog_formats = hinfo->formats;
4839 mout->analog_maxbps = hinfo->maxbps;
4840 } else {
4841 runtime->hw.rates = mout->analog_rates;
4842 runtime->hw.formats = mout->analog_formats;
4843 hinfo->maxbps = mout->analog_maxbps;
4844 }
4845 if (!mout->spdif_rates) {
4846 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4847 &mout->spdif_rates,
4848 &mout->spdif_formats,
4849 &mout->spdif_maxbps);
4850 }
4851 mutex_lock(&codec->spdif_mutex);
4852 if (mout->share_spdif) {
022b466f
TI		 4853 if ((runtime->hw.rates & mout->spdif_rates) &&
4854 (runtime->hw.formats & mout->spdif_formats)) {
4855 runtime->hw.rates &= mout->spdif_rates;
4856 runtime->hw.formats &= mout->spdif_formats;
4857 if (mout->spdif_maxbps < hinfo->maxbps)
4858 hinfo->maxbps = mout->spdif_maxbps;
4859 } else {
4860 mout->share_spdif = 0;
4861 /* FIXME: need notify? */
4862 }
9a08160b 4863 }
eaa9985b 4864 mutex_unlock(&codec->spdif_mutex);
9a08160b 4865 }
1da177e4
LT		 4866 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4867 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4868}
ff7a3267 4869EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
1da177e4 4870
d5191e50
TI		 4871/**
4872 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4873 *
4874 * Set up the i/o for analog out.
4875 * When the digital out is available, copy the front out to digital out, too.
1da177e4 4876 */
0ba21762
TI		 4877int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4878 struct hda_multi_out *mout,
1da177e4
LT		 4879 unsigned int stream_tag,
4880 unsigned int format,
c8b6bf9b 4881 struct snd_pcm_substream *substream)
1da177e4 4882{
dda14410 4883 const hda_nid_t *nids = mout->dac_nids;
1da177e4 4884 int chs = substream->runtime->channels;
e3245cdd 4885 struct hda_spdif_out *spdif;
1da177e4
LT		 4886 int i;
4887
62932df8 4888 mutex_lock(&codec->spdif_mutex);
e3245cdd 4889 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
9a08160b
TI		 4890 if (mout->dig_out_nid && mout->share_spdif &&
4891 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
1da177e4 4892 if (chs == 2 &&
0ba21762
TI		 4893 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4894 format) &&
7c935976 4895 !(spdif->status & IEC958_AES0_NONAUDIO)) {
1da177e4 4896 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
6b97eb45
TI		 4897 setup_dig_out_stream(codec, mout->dig_out_nid,
4898 stream_tag, format);
1da177e4
LT		 4899 } else {
4900 mout->dig_out_used = 0;
2f72853c 4901 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 4902 }
4903 }
62932df8 4904 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4905
4906 /* front */
0ba21762
TI		 4907 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4908 0, format);
d29240ce
TI		 4909 if (!mout->no_share_stream &&
4910 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
1da177e4 4911 /* headphone out will just decode front left/right (stereo) */
0ba21762
TI		 4912 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4913 0, format);
82bc955f 4914 /* extra outputs copied from front */
a06dbfc2
TI		 4915 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4916 if (!mout->no_share_stream && mout->hp_out_nid[i])
4917 snd_hda_codec_setup_stream(codec,
4918 mout->hp_out_nid[i],
4919 stream_tag, 0, format);
82bc955f 4920 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
d29240ce 4921 if (!mout->no_share_stream && mout->extra_out_nid[i])
82bc955f
TI		 4922 snd_hda_codec_setup_stream(codec,
4923 mout->extra_out_nid[i],
4924 stream_tag, 0, format);
4925
1da177e4
LT		 4926 /* surrounds */
4927 for (i = 1; i < mout->num_dacs; i++) {
4b3acaf5 4928 if (chs >= (i + 1) * 2) /* independent out */
0ba21762
TI		 4929 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4930 i * 2, format);
d29240ce 4931 else if (!mout->no_share_stream) /* copy front */
0ba21762
TI		 4932 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4933 0, format);
1da177e4
LT		 4934 }
4935 return 0;
4936}
ff7a3267 4937EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
1da177e4 4938
d5191e50
TI		 4939/**
4940 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
1da177e4 4941 */
0ba21762
TI		 4942int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4943 struct hda_multi_out *mout)
1da177e4 4944{
dda14410 4945 const hda_nid_t *nids = mout->dac_nids;
1da177e4
LT		 4946 int i;
4947
4948 for (i = 0; i < mout->num_dacs; i++)
888afa15 4949 snd_hda_codec_cleanup_stream(codec, nids[i]);
1da177e4 4950 if (mout->hp_nid)
888afa15 4951 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
a06dbfc2
TI		 4952 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4953 if (mout->hp_out_nid[i])
4954 snd_hda_codec_cleanup_stream(codec,
4955 mout->hp_out_nid[i]);
82bc955f
TI		 4956 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4957 if (mout->extra_out_nid[i])
888afa15
TI		 4958 snd_hda_codec_cleanup_stream(codec,
4959 mout->extra_out_nid[i]);
62932df8 4960 mutex_lock(&codec->spdif_mutex);
1da177e4 4961 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
2f72853c 4962 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 4963 mout->dig_out_used = 0;
4964 }
62932df8 4965 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4966 return 0;
4967}
ff7a3267 4968EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
1da177e4 4969
4740860b
TI		 4970/**
4971 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
4972 *
4973 * Guess the suitable VREF pin bits to be set as the pin-control value.
4974 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
4975 */
4976unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
4977{
4978 unsigned int pincap;
4979 unsigned int oldval;
4980 oldval = snd_hda_codec_read(codec, pin, 0,
4981 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4982 pincap = snd_hda_query_pin_caps(codec, pin);
4983 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
4984 /* Exception: if the default pin setup is vref50, we give it priority */
4985 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
4986 return AC_PINCTL_VREF_80;
4987 else if (pincap & AC_PINCAP_VREF_50)
4988 return AC_PINCTL_VREF_50;
4989 else if (pincap & AC_PINCAP_VREF_100)
4990 return AC_PINCTL_VREF_100;
4991 else if (pincap & AC_PINCAP_VREF_GRD)
4992 return AC_PINCTL_VREF_GRD;
4993 return AC_PINCTL_VREF_HIZ;
4994}
4995EXPORT_SYMBOL_HDA(snd_hda_get_default_vref);
4996
cdd03ced
TI		 4997int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
4998 unsigned int val, bool cached)
4999{
5000 if (val) {
5001 unsigned int cap = snd_hda_query_pin_caps(codec, pin);
6942c103 5002 if (cap && (val & AC_PINCTL_OUT_EN)) {
cdd03ced
TI		 5003 if (!(cap & AC_PINCAP_OUT))
5004 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5005 else if ((val & AC_PINCTL_HP_EN) &&
5006 !(cap & AC_PINCAP_HP_DRV))
5007 val &= ~AC_PINCTL_HP_EN;
5008 }
6942c103 5009 if (cap && (val & AC_PINCTL_IN_EN)) {
cdd03ced
TI		 5010 if (!(cap & AC_PINCAP_IN))
5011 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
5012 }
5013 }
5014 if (cached)
5015 return snd_hda_codec_update_cache(codec, pin, 0,
5016 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5017 else
5018 return snd_hda_codec_write(codec, pin, 0,
5019 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5020}
5021EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl);
5022
990061c2
TI		 5023/**
5024 * snd_hda_add_imux_item - Add an item to input_mux
5025 *
5026 * When the same label is used already in the existing items, the number
5027 * suffix is appended to the label. This label index number is stored
5028 * to type_idx when non-NULL pointer is given.
5029 */
10a20af7
TI		 5030int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5031 int index, int *type_idx)
5032{
5033 int i, label_idx = 0;
5034 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5035 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5036 return -EINVAL;
5037 }
5038 for (i = 0; i < imux->num_items; i++) {
5039 if (!strncmp(label, imux->items[i].label, strlen(label)))
5040 label_idx++;
d7b1ae9d 5041 }
10a20af7
TI		 5042 if (type_idx)
5043 *type_idx = label_idx;
5044 if (label_idx > 0)
5045 snprintf(imux->items[imux->num_items].label,
5046 sizeof(imux->items[imux->num_items].label),
5047 "%s %d", label, label_idx);
b5786e85 5048 else
10a20af7
TI		 5049 strlcpy(imux->items[imux->num_items].label, label,
5050 sizeof(imux->items[imux->num_items].label));
5051 imux->items[imux->num_items].index = index;
5052 imux->num_items++;
5053 return 0;
d7b1ae9d 5054}
10a20af7 5055EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
d7b1ae9d 5056
4a471b7d 5057
1da177e4
LT		 5058#ifdef CONFIG_PM
5059/*
5060 * power management
5061 */
5062
5063/**
5064 * snd_hda_suspend - suspend the codecs
5065 * @bus: the HDA bus
1da177e4
LT		 5066 *
5067 * Returns 0 if successful.
5068 */
8dd78330 5069int snd_hda_suspend(struct hda_bus *bus)
1da177e4 5070{
0ba21762 5071 struct hda_codec *codec;
1da177e4 5072
0ba21762 5073 list_for_each_entry(codec, &bus->codec_list, list) {
e581f3db
TI		 5074 if (hda_codec_is_power_on(codec))
5075 hda_call_codec_suspend(codec);
1da177e4
LT		 5076 }
5077 return 0;
5078}
ff7a3267 5079EXPORT_SYMBOL_HDA(snd_hda_suspend);
1da177e4
LT		 5080
5081/**
5082 * snd_hda_resume - resume the codecs
5083 * @bus: the HDA bus
1da177e4
LT		 5084 *
5085 * Returns 0 if successful.
cb53c626 5086 *
25985edc 5087 * This function is defined only when POWER_SAVE isn't set.
cb53c626 5088 * In the power-save mode, the codec is resumed dynamically.
1da177e4
LT		 5089 */
5090int snd_hda_resume(struct hda_bus *bus)
5091{
0ba21762 5092 struct hda_codec *codec;
1da177e4 5093
0ba21762 5094 list_for_each_entry(codec, &bus->codec_list, list) {
7f30830b 5095 hda_call_codec_resume(codec);
1da177e4 5096 }
1da177e4
LT		 5097 return 0;
5098}
ff7a3267 5099EXPORT_SYMBOL_HDA(snd_hda_resume);
1289e9e8 5100#endif /* CONFIG_PM */
b2e18597
TI		 5101
5102/*
5103 * generic arrays
5104 */
5105
d5191e50
TI		 5106/**
5107 * snd_array_new - get a new element from the given array
5108 * @array: the array object
28aedaf7 5109 *
d5191e50
TI		 5110 * Get a new element from the given array. If it exceeds the
5111 * pre-allocated array size, re-allocate the array.
5112 *
5113 * Returns NULL if allocation failed.
b2e18597
TI		 5114 */
5115void *snd_array_new(struct snd_array *array)
5116{
5117 if (array->used >= array->alloced) {
5118 int num = array->alloced + array->alloc_align;
3101ba03 5119 int size = (num + 1) * array->elem_size;
00ef9610 5120 int oldsize = array->alloced * array->elem_size;
b910d9ae
TI		 5121 void *nlist;
5122 if (snd_BUG_ON(num >= 4096))
5123 return NULL;
3101ba03 5124 nlist = krealloc(array->list, size, GFP_KERNEL);
b2e18597
TI		 5125 if (!nlist)
5126 return NULL;
00ef9610 5127 memset(nlist + oldsize, 0, size - oldsize);
b2e18597
TI		 5128 array->list = nlist;
5129 array->alloced = num;
5130 }
f43aa025 5131 return snd_array_elem(array, array->used++);
b2e18597 5132}
ff7a3267 5133EXPORT_SYMBOL_HDA(snd_array_new);
b2e18597 5134
d5191e50
TI		 5135/**
5136 * snd_array_free - free the given array elements
5137 * @array: the array object
5138 */
b2e18597
TI		 5139void snd_array_free(struct snd_array *array)
5140{
5141 kfree(array->list);
5142 array->used = 0;
5143 array->alloced = 0;
5144 array->list = NULL;
5145}
ff7a3267 5146EXPORT_SYMBOL_HDA(snd_array_free);
b2022266 5147
d5191e50
TI		 5148/**
5149 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5150 * @pcm: PCM caps bits
5151 * @buf: the string buffer to write
5152 * @buflen: the max buffer length
5153 *
5154 * used by hda_proc.c and hda_eld.c
5155 */
b2022266
TI		 5156void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5157{
5158 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5159 int i, j;
5160
5161 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5162 if (pcm & (AC_SUPPCM_BITS_8 << i))
5163 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5164
5165 buf[j] = '\0'; /* necessary when j == 0 */
5166}
ff7a3267 5167EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
1289e9e8
TI		 5168
5169MODULE_DESCRIPTION("HDA codec core");
5170MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 1.13867 seconds and 5 git commands to generate.