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