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