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