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