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