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