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