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