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