projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: hda - Add EAPD control to Conexnat auto-parser
[linux-2.6-block.git] / sound / pci / hda / hda_codec.c
CommitLineData
1da177e4
LT		 1/*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
5 *
6 *
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
18478e8b 22#include <linux/mm.h>
1da177e4
LT		 23#include <linux/init.h>
24#include <linux/delay.h>
25#include <linux/slab.h>
26#include <linux/pci.h>
62932df8 27#include <linux/mutex.h>
da155d5b 28#include <linux/module.h>
1da177e4
LT		 29#include <sound/core.h>
30#include "hda_codec.h"
31#include <sound/asoundef.h>
302e9c5a 32#include <sound/tlv.h>
1da177e4 33#include <sound/initval.h>
cd372fb3 34#include <sound/jack.h>
1da177e4 35#include "hda_local.h"
123c07ae 36#include "hda_beep.h"
1835a0f9 37#include "hda_jack.h"
2807314d 38#include <sound/hda_hwdep.h>
1da177e4 39
d66fee5d
TI		 40#define CREATE_TRACE_POINTS
41#include "hda_trace.h"
42
1da177e4
LT		 43/*
44 * vendor / preset table
45 */
46
47struct hda_vendor_id {
48 unsigned int id;
49 const char *name;
50};
51
52/* codec vendor labels */
53static struct hda_vendor_id hda_vendor_ids[] = {
c8cd1281 54 { 0x1002, "ATI" },
e5f14248 55 { 0x1013, "Cirrus Logic" },
a9226251 56 { 0x1057, "Motorola" },
c8cd1281 57 { 0x1095, "Silicon Image" },
31117b78 58 { 0x10de, "Nvidia" },
c8cd1281 59 { 0x10ec, "Realtek" },
4e01f54b 60 { 0x1102, "Creative" },
c577b8a1 61 { 0x1106, "VIA" },
7f16859a 62 { 0x111d, "IDT" },
c8cd1281 63 { 0x11c1, "LSI" },
54b903ec 64 { 0x11d4, "Analog Devices" },
1da177e4 65 { 0x13f6, "C-Media" },
a9226251 66 { 0x14f1, "Conexant" },
c8cd1281
TI		 67 { 0x17e8, "Chrontel" },
68 { 0x1854, "LG" },
8199de3b 69 { 0x1aec, "Wolfson Microelectronics" },
1da177e4 70 { 0x434d, "C-Media" },
74c61133 71 { 0x8086, "Intel" },
2f2f4251 72 { 0x8384, "SigmaTel" },
1da177e4
LT		 73 {} /* terminator */
74};
75
1289e9e8
TI		 76static DEFINE_MUTEX(preset_mutex);
77static LIST_HEAD(hda_preset_tables);
78
79int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
80{
81 mutex_lock(&preset_mutex);
82 list_add_tail(&preset->list, &hda_preset_tables);
83 mutex_unlock(&preset_mutex);
84 return 0;
85}
ff7a3267 86EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
1289e9e8
TI		 87
88int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
89{
90 mutex_lock(&preset_mutex);
91 list_del(&preset->list);
92 mutex_unlock(&preset_mutex);
93 return 0;
94}
ff7a3267 95EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
1da177e4 96
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
d5191e50
TI		 2453/**
2454 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2455 *
2456 * The control element is supposed to have the private_value field
2457 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2458 */
0ba21762
TI		 2459int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2460 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 2461{
2462 int chs = get_amp_channels(kcontrol);
2463
2464 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2465 uinfo->count = chs == 3 ? 2 : 1;
2466 uinfo->value.integer.min = 0;
2467 uinfo->value.integer.max = 1;
2468 return 0;
2469}
ff7a3267 2470EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1da177e4 2471
d5191e50
TI		 2472/**
2473 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2474 *
2475 * The control element is supposed to have the private_value field
2476 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2477 */
0ba21762
TI		 2478int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2479 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2480{
2481 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2482 hda_nid_t nid = get_amp_nid(kcontrol);
2483 int chs = get_amp_channels(kcontrol);
2484 int dir = get_amp_direction(kcontrol);
2485 int idx = get_amp_index(kcontrol);
2486 long *valp = ucontrol->value.integer.value;
2487
2488 if (chs & 1)
0ba21762 2489 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
47fd830a 2490 HDA_AMP_MUTE) ? 0 : 1;
1da177e4 2491 if (chs & 2)
0ba21762 2492 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
47fd830a 2493 HDA_AMP_MUTE) ? 0 : 1;
1da177e4
LT		 2494 return 0;
2495}
ff7a3267 2496EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1da177e4 2497
d5191e50
TI		 2498/**
2499 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2500 *
2501 * The control element is supposed to have the private_value field
2502 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2503 */
0ba21762
TI		 2504int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2505 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2506{
2507 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2508 hda_nid_t nid = get_amp_nid(kcontrol);
2509 int chs = get_amp_channels(kcontrol);
2510 int dir = get_amp_direction(kcontrol);
2511 int idx = get_amp_index(kcontrol);
1da177e4
LT		 2512 long *valp = ucontrol->value.integer.value;
2513 int change = 0;
2514
cb53c626 2515 snd_hda_power_up(codec);
b9f5a89c 2516 if (chs & 1) {
4a19faee 2517 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
47fd830a
TI		 2518 HDA_AMP_MUTE,
2519 *valp ? 0 : HDA_AMP_MUTE);
b9f5a89c
NG		 2520 valp++;
2521 }
4a19faee
TI		 2522 if (chs & 2)
2523 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
47fd830a
TI		 2524 HDA_AMP_MUTE,
2525 *valp ? 0 : HDA_AMP_MUTE);
9e5341b9 2526 hda_call_check_power_status(codec, nid);
cb53c626 2527 snd_hda_power_down(codec);
1da177e4
LT		 2528 return change;
2529}
ff7a3267 2530EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1da177e4 2531
67d634c0 2532#ifdef CONFIG_SND_HDA_INPUT_BEEP
d5191e50
TI		 2533/**
2534 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2535 *
2536 * This function calls snd_hda_enable_beep_device(), which behaves differently
2537 * depending on beep_mode option.
2538 */
123c07ae
JK		 2539int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2540 struct snd_ctl_elem_value *ucontrol)
2541{
2542 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2543 long *valp = ucontrol->value.integer.value;
2544
2545 snd_hda_enable_beep_device(codec, *valp);
2546 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2547}
2548EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
67d634c0 2549#endif /* CONFIG_SND_HDA_INPUT_BEEP */
123c07ae 2550
985be54b
TI		 2551/*
2552 * bound volume controls
2553 *
2554 * bind multiple volumes (# indices, from 0)
2555 */
2556
2557#define AMP_VAL_IDX_SHIFT 19
2558#define AMP_VAL_IDX_MASK (0x0f<<19)
2559
d5191e50
TI		 2560/**
2561 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2562 *
2563 * The control element is supposed to have the private_value field
2564 * set up via HDA_BIND_MUTE*() macros.
2565 */
0ba21762
TI		 2566int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2567 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 2568{
2569 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2570 unsigned long pval;
2571 int err;
2572
5a9e02e9 2573 mutex_lock(&codec->control_mutex);
985be54b
TI		 2574 pval = kcontrol->private_value;
2575 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2576 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2577 kcontrol->private_value = pval;
5a9e02e9 2578 mutex_unlock(&codec->control_mutex);
985be54b
TI		 2579 return err;
2580}
ff7a3267 2581EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
985be54b 2582
d5191e50
TI		 2583/**
2584 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2585 *
2586 * The control element is supposed to have the private_value field
2587 * set up via HDA_BIND_MUTE*() macros.
2588 */
0ba21762
TI		 2589int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2590 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 2591{
2592 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2593 unsigned long pval;
2594 int i, indices, err = 0, change = 0;
2595
5a9e02e9 2596 mutex_lock(&codec->control_mutex);
985be54b
TI		 2597 pval = kcontrol->private_value;
2598 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2599 for (i = 0; i < indices; i++) {
0ba21762
TI		 2600 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2601 (i << AMP_VAL_IDX_SHIFT);
985be54b
TI		 2602 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2603 if (err < 0)
2604 break;
2605 change |= err;
2606 }
2607 kcontrol->private_value = pval;
5a9e02e9 2608 mutex_unlock(&codec->control_mutex);
985be54b
TI		 2609 return err < 0 ? err : change;
2610}
ff7a3267 2611EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
985be54b 2612
d5191e50
TI		 2613/**
2614 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2615 *
2616 * The control element is supposed to have the private_value field
2617 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
532d5381
TI		 2618 */
2619int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2620 struct snd_ctl_elem_info *uinfo)
2621{
2622 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2623 struct hda_bind_ctls *c;
2624 int err;
2625
5a9e02e9 2626 mutex_lock(&codec->control_mutex);
14c65f98 2627 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2628 kcontrol->private_value = *c->values;
2629 err = c->ops->info(kcontrol, uinfo);
2630 kcontrol->private_value = (long)c;
5a9e02e9 2631 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2632 return err;
2633}
ff7a3267 2634EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
532d5381 2635
d5191e50
TI		 2636/**
2637 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2638 *
2639 * The control element is supposed to have the private_value field
2640 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2641 */
532d5381
TI		 2642int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2643 struct snd_ctl_elem_value *ucontrol)
2644{
2645 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2646 struct hda_bind_ctls *c;
2647 int err;
2648
5a9e02e9 2649 mutex_lock(&codec->control_mutex);
14c65f98 2650 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2651 kcontrol->private_value = *c->values;
2652 err = c->ops->get(kcontrol, ucontrol);
2653 kcontrol->private_value = (long)c;
5a9e02e9 2654 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2655 return err;
2656}
ff7a3267 2657EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
532d5381 2658
d5191e50
TI		 2659/**
2660 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2661 *
2662 * The control element is supposed to have the private_value field
2663 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2664 */
532d5381
TI		 2665int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2666 struct snd_ctl_elem_value *ucontrol)
2667{
2668 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2669 struct hda_bind_ctls *c;
2670 unsigned long *vals;
2671 int err = 0, change = 0;
2672
5a9e02e9 2673 mutex_lock(&codec->control_mutex);
14c65f98 2674 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2675 for (vals = c->values; *vals; vals++) {
2676 kcontrol->private_value = *vals;
2677 err = c->ops->put(kcontrol, ucontrol);
2678 if (err < 0)
2679 break;
2680 change |= err;
2681 }
2682 kcontrol->private_value = (long)c;
5a9e02e9 2683 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2684 return err < 0 ? err : change;
2685}
ff7a3267 2686EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
532d5381 2687
d5191e50
TI		 2688/**
2689 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2690 *
2691 * The control element is supposed to have the private_value field
2692 * set up via HDA_BIND_VOL() macro.
2693 */
532d5381
TI		 2694int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2695 unsigned int size, unsigned int __user *tlv)
2696{
2697 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2698 struct hda_bind_ctls *c;
2699 int err;
2700
5a9e02e9 2701 mutex_lock(&codec->control_mutex);
14c65f98 2702 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2703 kcontrol->private_value = *c->values;
2704 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2705 kcontrol->private_value = (long)c;
5a9e02e9 2706 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2707 return err;
2708}
ff7a3267 2709EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
532d5381
TI		 2710
2711struct hda_ctl_ops snd_hda_bind_vol = {
2712 .info = snd_hda_mixer_amp_volume_info,
2713 .get = snd_hda_mixer_amp_volume_get,
2714 .put = snd_hda_mixer_amp_volume_put,
2715 .tlv = snd_hda_mixer_amp_tlv
2716};
ff7a3267 2717EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
532d5381
TI		 2718
2719struct hda_ctl_ops snd_hda_bind_sw = {
2720 .info = snd_hda_mixer_amp_switch_info,
2721 .get = snd_hda_mixer_amp_switch_get,
2722 .put = snd_hda_mixer_amp_switch_put,
2723 .tlv = snd_hda_mixer_amp_tlv
2724};
ff7a3267 2725EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
532d5381 2726
1da177e4
LT		 2727/*
2728 * SPDIF out controls
2729 */
2730
0ba21762
TI		 2731static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2732 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 2733{
2734 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2735 uinfo->count = 1;
2736 return 0;
2737}
2738
0ba21762
TI		 2739static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2740 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2741{
2742 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2743 IEC958_AES0_NONAUDIO |
2744 IEC958_AES0_CON_EMPHASIS_5015 |
2745 IEC958_AES0_CON_NOT_COPYRIGHT;
2746 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2747 IEC958_AES1_CON_ORIGINAL;
2748 return 0;
2749}
2750
0ba21762
TI		 2751static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2752 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2753{
2754 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2755 IEC958_AES0_NONAUDIO |
2756 IEC958_AES0_PRO_EMPHASIS_5015;
2757 return 0;
2758}
2759
0ba21762
TI		 2760static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2761 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2762{
2763 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976
SW		 2764 int idx = kcontrol->private_value;
2765 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
1da177e4 2766
7c935976
SW		 2767 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2768 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2769 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2770 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
1da177e4
LT		 2771
2772 return 0;
2773}
2774
2775/* convert from SPDIF status bits to HDA SPDIF bits
2776 * bit 0 (DigEn) is always set zero (to be filled later)
2777 */
2778static unsigned short convert_from_spdif_status(unsigned int sbits)
2779{
2780 unsigned short val = 0;
2781
2782 if (sbits & IEC958_AES0_PROFESSIONAL)
0ba21762 2783 val |= AC_DIG1_PROFESSIONAL;
1da177e4 2784 if (sbits & IEC958_AES0_NONAUDIO)
0ba21762 2785 val |= AC_DIG1_NONAUDIO;
1da177e4 2786 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762
TI		 2787 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2788 IEC958_AES0_PRO_EMPHASIS_5015)
2789 val |= AC_DIG1_EMPHASIS;
1da177e4 2790 } else {
0ba21762
TI		 2791 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2792 IEC958_AES0_CON_EMPHASIS_5015)
2793 val |= AC_DIG1_EMPHASIS;
2794 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2795 val |= AC_DIG1_COPYRIGHT;
1da177e4 2796 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
0ba21762 2797 val |= AC_DIG1_LEVEL;
1da177e4
LT		 2798 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2799 }
2800 return val;
2801}
2802
2803/* convert to SPDIF status bits from HDA SPDIF bits
2804 */
2805static unsigned int convert_to_spdif_status(unsigned short val)
2806{
2807 unsigned int sbits = 0;
2808
0ba21762 2809 if (val & AC_DIG1_NONAUDIO)
1da177e4 2810 sbits |= IEC958_AES0_NONAUDIO;
0ba21762 2811 if (val & AC_DIG1_PROFESSIONAL)
1da177e4
LT		 2812 sbits |= IEC958_AES0_PROFESSIONAL;
2813 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762 2814 if (sbits & AC_DIG1_EMPHASIS)
1da177e4
LT		 2815 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2816 } else {
0ba21762 2817 if (val & AC_DIG1_EMPHASIS)
1da177e4 2818 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
0ba21762 2819 if (!(val & AC_DIG1_COPYRIGHT))
1da177e4 2820 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
0ba21762 2821 if (val & AC_DIG1_LEVEL)
1da177e4
LT		 2822 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2823 sbits |= val & (0x7f << 8);
2824 }
2825 return sbits;
2826}
2827
2f72853c
TI		 2828/* set digital convert verbs both for the given NID and its slaves */
2829static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2830 int verb, int val)
2831{
dda14410 2832 const hda_nid_t *d;
2f72853c 2833
9e976976 2834 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2f72853c
TI		 2835 d = codec->slave_dig_outs;
2836 if (!d)
2837 return;
2838 for (; *d; d++)
9e976976 2839 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2f72853c
TI		 2840}
2841
2842static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2843 int dig1, int dig2)
2844{
2845 if (dig1 != -1)
2846 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2847 if (dig2 != -1)
2848 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2849}
2850
0ba21762
TI		 2851static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2852 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2853{
2854 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976
SW		 2855 int idx = kcontrol->private_value;
2856 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2857 hda_nid_t nid = spdif->nid;
1da177e4
LT		 2858 unsigned short val;
2859 int change;
2860
62932df8 2861 mutex_lock(&codec->spdif_mutex);
7c935976 2862 spdif->status = ucontrol->value.iec958.status[0] |
1da177e4
LT		 2863 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2864 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2865 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
7c935976
SW		 2866 val = convert_from_spdif_status(spdif->status);
2867 val |= spdif->ctls & 1;
2868 change = spdif->ctls != val;
2869 spdif->ctls = val;
74b654c9 2870 if (change && nid != (u16)-1)
2f72853c 2871 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
62932df8 2872 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2873 return change;
2874}
2875
a5ce8890 2876#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1da177e4 2877
0ba21762
TI		 2878static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2879 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2880{
2881 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976
SW		 2882 int idx = kcontrol->private_value;
2883 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
1da177e4 2884
7c935976 2885 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
1da177e4
LT		 2886 return 0;
2887}
2888
74b654c9
SW		 2889static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2890 int dig1, int dig2)
2891{
2892 set_dig_out_convert(codec, nid, dig1, dig2);
2893 /* unmute amp switch (if any) */
2894 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2895 (dig1 & AC_DIG1_ENABLE))
2896 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2897 HDA_AMP_MUTE, 0);
2898}
2899
0ba21762
TI		 2900static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2901 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2902{
2903 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976
SW		 2904 int idx = kcontrol->private_value;
2905 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2906 hda_nid_t nid = spdif->nid;
1da177e4
LT		 2907 unsigned short val;
2908 int change;
2909
62932df8 2910 mutex_lock(&codec->spdif_mutex);
7c935976 2911 val = spdif->ctls & ~AC_DIG1_ENABLE;
1da177e4 2912 if (ucontrol->value.integer.value[0])
0ba21762 2913 val |= AC_DIG1_ENABLE;
7c935976 2914 change = spdif->ctls != val;
74b654c9
SW		 2915 spdif->ctls = val;
2916 if (change && nid != (u16)-1)
2917 set_spdif_ctls(codec, nid, val & 0xff, -1);
62932df8 2918 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2919 return change;
2920}
2921
c8b6bf9b 2922static struct snd_kcontrol_new dig_mixes[] = {
1da177e4
LT		 2923 {
2924 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2925 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 2926 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
1da177e4
LT		 2927 .info = snd_hda_spdif_mask_info,
2928 .get = snd_hda_spdif_cmask_get,
2929 },
2930 {
2931 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2932 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 2933 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
1da177e4
LT		 2934 .info = snd_hda_spdif_mask_info,
2935 .get = snd_hda_spdif_pmask_get,
2936 },
2937 {
2938 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 2939 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1da177e4
LT		 2940 .info = snd_hda_spdif_mask_info,
2941 .get = snd_hda_spdif_default_get,
2942 .put = snd_hda_spdif_default_put,
2943 },
2944 {
2945 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 2946 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1da177e4
LT		 2947 .info = snd_hda_spdif_out_switch_info,
2948 .get = snd_hda_spdif_out_switch_get,
2949 .put = snd_hda_spdif_out_switch_put,
2950 },
2951 { } /* end */
2952};
2953
2954/**
2955 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2956 * @codec: the HDA codec
2957 * @nid: audio out widget NID
2958 *
2959 * Creates controls related with the SPDIF output.
2960 * Called from each patch supporting the SPDIF out.
2961 *
2962 * Returns 0 if successful, or a negative error code.
2963 */
74b654c9
SW		 2964int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
2965 hda_nid_t associated_nid,
2966 hda_nid_t cvt_nid)
1da177e4
LT		 2967{
2968 int err;
c8b6bf9b
TI		 2969 struct snd_kcontrol *kctl;
2970 struct snd_kcontrol_new *dig_mix;
09f99701 2971 int idx;
7c935976 2972 struct hda_spdif_out *spdif;
1da177e4 2973
1afe206a
TI		 2974 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
2975 if (idx < 0) {
09f99701
TI		 2976 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2977 return -EBUSY;
2978 }
7c935976 2979 spdif = snd_array_new(&codec->spdif_out);
1da177e4
LT		 2980 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2981 kctl = snd_ctl_new1(dig_mix, codec);
b91f080f
TI		 2982 if (!kctl)
2983 return -ENOMEM;
09f99701 2984 kctl->id.index = idx;
7c935976 2985 kctl->private_value = codec->spdif_out.used - 1;
74b654c9 2986 err = snd_hda_ctl_add(codec, associated_nid, kctl);
0ba21762 2987 if (err < 0)
1da177e4
LT		 2988 return err;
2989 }
74b654c9
SW		 2990 spdif->nid = cvt_nid;
2991 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
7c935976
SW		 2992 AC_VERB_GET_DIGI_CONVERT_1, 0);
2993 spdif->status = convert_to_spdif_status(spdif->ctls);
1da177e4
LT		 2994 return 0;
2995}
ff7a3267 2996EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1da177e4 2997
7c935976
SW		 2998struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
2999 hda_nid_t nid)
3000{
3001 int i;
3002 for (i = 0; i < codec->spdif_out.used; i++) {
3003 struct hda_spdif_out *spdif =
3004 snd_array_elem(&codec->spdif_out, i);
3005 if (spdif->nid == nid)
3006 return spdif;
3007 }
3008 return NULL;
3009}
3010EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3011
74b654c9
SW		 3012void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3013{
3014 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
3015
3016 mutex_lock(&codec->spdif_mutex);
3017 spdif->nid = (u16)-1;
3018 mutex_unlock(&codec->spdif_mutex);
3019}
3020EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3021
3022void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3023{
3024 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
3025 unsigned short val;
3026
3027 mutex_lock(&codec->spdif_mutex);
3028 if (spdif->nid != nid) {
3029 spdif->nid = nid;
3030 val = spdif->ctls;
3031 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3032 }
3033 mutex_unlock(&codec->spdif_mutex);
3034}
3035EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3036
9a08160b
TI		 3037/*
3038 * SPDIF sharing with analog output
3039 */
3040static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3041 struct snd_ctl_elem_value *ucontrol)
3042{
3043 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3044 ucontrol->value.integer.value[0] = mout->share_spdif;
3045 return 0;
3046}
3047
3048static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3049 struct snd_ctl_elem_value *ucontrol)
3050{
3051 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3052 mout->share_spdif = !!ucontrol->value.integer.value[0];
3053 return 0;
3054}
3055
3056static struct snd_kcontrol_new spdif_share_sw = {
3057 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3058 .name = "IEC958 Default PCM Playback Switch",
3059 .info = snd_ctl_boolean_mono_info,
3060 .get = spdif_share_sw_get,
3061 .put = spdif_share_sw_put,
3062};
3063
d5191e50
TI		 3064/**
3065 * snd_hda_create_spdif_share_sw - create Default PCM switch
3066 * @codec: the HDA codec
3067 * @mout: multi-out instance
3068 */
9a08160b
TI		 3069int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3070 struct hda_multi_out *mout)
3071{
3072 if (!mout->dig_out_nid)
3073 return 0;
3074 /* ATTENTION: here mout is passed as private_data, instead of codec */
3911a4c1
JK		 3075 return snd_hda_ctl_add(codec, mout->dig_out_nid,
3076 snd_ctl_new1(&spdif_share_sw, mout));
9a08160b 3077}
ff7a3267 3078EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
9a08160b 3079
1da177e4
LT		 3080/*
3081 * SPDIF input
3082 */
3083
3084#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3085
0ba21762
TI		 3086static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3087 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3088{
3089 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3090
3091 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3092 return 0;
3093}
3094
0ba21762
TI		 3095static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3096 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3097{
3098 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3099 hda_nid_t nid = kcontrol->private_value;
3100 unsigned int val = !!ucontrol->value.integer.value[0];
3101 int change;
3102
62932df8 3103 mutex_lock(&codec->spdif_mutex);
1da177e4 3104 change = codec->spdif_in_enable != val;
82beb8fd 3105 if (change) {
1da177e4 3106 codec->spdif_in_enable = val;
82beb8fd
TI		 3107 snd_hda_codec_write_cache(codec, nid, 0,
3108 AC_VERB_SET_DIGI_CONVERT_1, val);
1da177e4 3109 }
62932df8 3110 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3111 return change;
3112}
3113
0ba21762
TI		 3114static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3115 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3116{
3117 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3118 hda_nid_t nid = kcontrol->private_value;
3119 unsigned short val;
3120 unsigned int sbits;
3121
3982d17e 3122 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1da177e4
LT		 3123 sbits = convert_to_spdif_status(val);
3124 ucontrol->value.iec958.status[0] = sbits;
3125 ucontrol->value.iec958.status[1] = sbits >> 8;
3126 ucontrol->value.iec958.status[2] = sbits >> 16;
3127 ucontrol->value.iec958.status[3] = sbits >> 24;
3128 return 0;
3129}
3130
c8b6bf9b 3131static struct snd_kcontrol_new dig_in_ctls[] = {
1da177e4
LT		 3132 {
3133 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3134 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
1da177e4
LT		 3135 .info = snd_hda_spdif_in_switch_info,
3136 .get = snd_hda_spdif_in_switch_get,
3137 .put = snd_hda_spdif_in_switch_put,
3138 },
3139 {
3140 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3141 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3142 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
1da177e4
LT		 3143 .info = snd_hda_spdif_mask_info,
3144 .get = snd_hda_spdif_in_status_get,
3145 },
3146 { } /* end */
3147};
3148
3149/**
3150 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3151 * @codec: the HDA codec
3152 * @nid: audio in widget NID
3153 *
3154 * Creates controls related with the SPDIF input.
3155 * Called from each patch supporting the SPDIF in.
3156 *
3157 * Returns 0 if successful, or a negative error code.
3158 */
12f288bf 3159int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1da177e4
LT		 3160{
3161 int err;
c8b6bf9b
TI		 3162 struct snd_kcontrol *kctl;
3163 struct snd_kcontrol_new *dig_mix;
09f99701 3164 int idx;
1da177e4 3165
1afe206a
TI		 3166 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3167 if (idx < 0) {
09f99701
TI		 3168 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3169 return -EBUSY;
3170 }
1da177e4
LT		 3171 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3172 kctl = snd_ctl_new1(dig_mix, codec);
c8dcdf82
TI		 3173 if (!kctl)
3174 return -ENOMEM;
1da177e4 3175 kctl->private_value = nid;
3911a4c1 3176 err = snd_hda_ctl_add(codec, nid, kctl);
0ba21762 3177 if (err < 0)
1da177e4
LT		 3178 return err;
3179 }
0ba21762 3180 codec->spdif_in_enable =
3982d17e
AP		 3181 snd_hda_codec_read(codec, nid, 0,
3182 AC_VERB_GET_DIGI_CONVERT_1, 0) &
0ba21762 3183 AC_DIG1_ENABLE;
1da177e4
LT		 3184 return 0;
3185}
ff7a3267 3186EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
1da177e4 3187
2a43952a 3188#ifdef CONFIG_PM
82beb8fd
TI		 3189/*
3190 * command cache
3191 */
1da177e4 3192
b3ac5636
TI		 3193/* build a 32bit cache key with the widget id and the command parameter */
3194#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3195#define get_cmd_cache_nid(key) ((key) & 0xff)
3196#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3197
3198/**
3199 * snd_hda_codec_write_cache - send a single command with caching
3200 * @codec: the HDA codec
3201 * @nid: NID to send the command
3202 * @direct: direct flag
3203 * @verb: the verb to send
3204 * @parm: the parameter for the verb
3205 *
3206 * Send a single command without waiting for response.
3207 *
3208 * Returns 0 if successful, or a negative error code.
3209 */
3210int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3211 int direct, unsigned int verb, unsigned int parm)
3212{
aa2936f5
TI		 3213 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3214 struct hda_cache_head *c;
3215 u32 key;
33fa35ed 3216
aa2936f5
TI		 3217 if (err < 0)
3218 return err;
3219 /* parm may contain the verb stuff for get/set amp */
3220 verb = verb | (parm >> 8);
3221 parm &= 0xff;
3222 key = build_cmd_cache_key(nid, verb);
3223 mutex_lock(&codec->bus->cmd_mutex);
3224 c = get_alloc_hash(&codec->cmd_cache, key);
3225 if (c)
3226 c->val = parm;
3227 mutex_unlock(&codec->bus->cmd_mutex);
3228 return 0;
b3ac5636 3229}
ff7a3267 3230EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
b3ac5636 3231
a68d5a54
TI		 3232/**
3233 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3234 * @codec: the HDA codec
3235 * @nid: NID to send the command
3236 * @direct: direct flag
3237 * @verb: the verb to send
3238 * @parm: the parameter for the verb
3239 *
3240 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3241 * command if the parameter is already identical with the cached value.
3242 * If not, it sends the command and refreshes the cache.
3243 *
3244 * Returns 0 if successful, or a negative error code.
3245 */
3246int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3247 int direct, unsigned int verb, unsigned int parm)
3248{
3249 struct hda_cache_head *c;
3250 u32 key;
3251
3252 /* parm may contain the verb stuff for get/set amp */
3253 verb = verb | (parm >> 8);
3254 parm &= 0xff;
3255 key = build_cmd_cache_key(nid, verb);
3256 mutex_lock(&codec->bus->cmd_mutex);
3257 c = get_hash(&codec->cmd_cache, key);
3258 if (c && c->val == parm) {
3259 mutex_unlock(&codec->bus->cmd_mutex);
3260 return 0;
3261 }
3262 mutex_unlock(&codec->bus->cmd_mutex);
3263 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3264}
3265EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3266
d5191e50
TI		 3267/**
3268 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3269 * @codec: HD-audio codec
3270 *
3271 * Execute all verbs recorded in the command caches to resume.
3272 */
b3ac5636
TI		 3273void snd_hda_codec_resume_cache(struct hda_codec *codec)
3274{
603c4019 3275 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
b3ac5636
TI		 3276 int i;
3277
603c4019 3278 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
b3ac5636
TI		 3279 u32 key = buffer->key;
3280 if (!key)
3281 continue;
3282 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3283 get_cmd_cache_cmd(key), buffer->val);
3284 }
3285}
ff7a3267 3286EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
b3ac5636
TI		 3287
3288/**
3289 * snd_hda_sequence_write_cache - sequence writes with caching
3290 * @codec: the HDA codec
3291 * @seq: VERB array to send
3292 *
3293 * Send the commands sequentially from the given array.
3294 * Thte commands are recorded on cache for power-save and resume.
3295 * The array must be terminated with NID=0.
3296 */
3297void snd_hda_sequence_write_cache(struct hda_codec *codec,
3298 const struct hda_verb *seq)
3299{
3300 for (; seq->nid; seq++)
3301 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3302 seq->param);
3303}
ff7a3267 3304EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2a43952a 3305#endif /* CONFIG_PM */
b3ac5636 3306
4d7fbdbc
TI		 3307void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3308 unsigned int power_state,
3309 bool eapd_workaround)
54d17403 3310{
4d7fbdbc 3311 hda_nid_t nid = codec->start_nid;
cb53c626 3312 int i;
54d17403 3313
cb53c626 3314 for (i = 0; i < codec->num_nodes; i++, nid++) {
7eba5c9d 3315 unsigned int wcaps = get_wcaps(codec, nid);
4d7fbdbc
TI		 3316 if (!(wcaps & AC_WCAP_POWER))
3317 continue;
3318 /* don't power down the widget if it controls eapd and
3319 * EAPD_BTLENABLE is set.
3320 */
3321 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3322 get_wcaps_type(wcaps) == AC_WID_PIN &&
3323 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3324 int eapd = snd_hda_codec_read(codec, nid, 0,
7eba5c9d 3325 AC_VERB_GET_EAPD_BTLENABLE, 0);
4d7fbdbc
TI		 3326 if (eapd & 0x02)
3327 continue;
1194b5b7 3328 }
4d7fbdbc
TI		 3329 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3330 power_state);
54d17403
TI		 3331 }
3332
cb53c626
TI		 3333 if (power_state == AC_PWRST_D0) {
3334 unsigned long end_time;
3335 int state;
cb53c626
TI		 3336 /* wait until the codec reachs to D0 */
3337 end_time = jiffies + msecs_to_jiffies(500);
3338 do {
3339 state = snd_hda_codec_read(codec, fg, 0,
3340 AC_VERB_GET_POWER_STATE, 0);
3341 if (state == power_state)
3342 break;
3343 msleep(1);
3344 } while (time_after_eq(end_time, jiffies));
3345 }
3346}
4d7fbdbc
TI		 3347EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3348
3349/*
3350 * set power state of the codec
3351 */
3352static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3353 unsigned int power_state)
3354{
3355 if (codec->patch_ops.set_power_state) {
3356 codec->patch_ops.set_power_state(codec, fg, power_state);
3357 return;
3358 }
3359
3360 /* this delay seems necessary to avoid click noise at power-down */
3361 if (power_state == AC_PWRST_D3)
3362 msleep(100);
3363 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3364 power_state);
3365 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3366}
cb53c626 3367
11aeff08
TI		 3368#ifdef CONFIG_SND_HDA_HWDEP
3369/* execute additional init verbs */
3370static void hda_exec_init_verbs(struct hda_codec *codec)
3371{
3372 if (codec->init_verbs.list)
3373 snd_hda_sequence_write(codec, codec->init_verbs.list);
3374}
3375#else
3376static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3377#endif
3378
2a43952a 3379#ifdef CONFIG_PM
cb53c626
TI		 3380/*
3381 * call suspend and power-down; used both from PM and power-save
3382 */
3383static void hda_call_codec_suspend(struct hda_codec *codec)
3384{
3385 if (codec->patch_ops.suspend)
3386 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
eb541337 3387 hda_cleanup_all_streams(codec);
cb53c626
TI		 3388 hda_set_power_state(codec,
3389 codec->afg ? codec->afg : codec->mfg,
3390 AC_PWRST_D3);
3391#ifdef CONFIG_SND_HDA_POWER_SAVE
a2f6309e 3392 snd_hda_update_power_acct(codec);
cb53c626 3393 cancel_delayed_work(&codec->power_work);
95e99fda 3394 codec->power_on = 0;
a221e287 3395 codec->power_transition = 0;
a2f6309e 3396 codec->power_jiffies = jiffies;
cb53c626 3397#endif
54d17403
TI		 3398}
3399
cb53c626
TI		 3400/*
3401 * kick up codec; used both from PM and power-save
3402 */
3403static void hda_call_codec_resume(struct hda_codec *codec)
3404{
3405 hda_set_power_state(codec,
3406 codec->afg ? codec->afg : codec->mfg,
3407 AC_PWRST_D0);
3be14149 3408 restore_pincfgs(codec); /* restore all current pin configs */
ac0547dc 3409 restore_shutup_pins(codec);
11aeff08 3410 hda_exec_init_verbs(codec);
1835a0f9 3411 snd_hda_jack_set_dirty_all(codec);
cb53c626
TI		 3412 if (codec->patch_ops.resume)
3413 codec->patch_ops.resume(codec);
3414 else {
9d99f312
TI		 3415 if (codec->patch_ops.init)
3416 codec->patch_ops.init(codec);
cb53c626
TI		 3417 snd_hda_codec_resume_amp(codec);
3418 snd_hda_codec_resume_cache(codec);
3419 }
3420}
2a43952a 3421#endif /* CONFIG_PM */
cb53c626 3422
54d17403 3423
1da177e4
LT		 3424/**
3425 * snd_hda_build_controls - build mixer controls
3426 * @bus: the BUS
3427 *
3428 * Creates mixer controls for each codec included in the bus.
3429 *
3430 * Returns 0 if successful, otherwise a negative error code.
3431 */
1289e9e8 3432int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
1da177e4 3433{
0ba21762 3434 struct hda_codec *codec;
1da177e4 3435
0ba21762 3436 list_for_each_entry(codec, &bus->codec_list, list) {
6c1f45ea 3437 int err = snd_hda_codec_build_controls(codec);
f93d461b 3438 if (err < 0) {
28d1a85e 3439 printk(KERN_ERR "hda_codec: cannot build controls "
28aedaf7 3440 "for #%d (error %d)\n", codec->addr, err);
f93d461b
TI		 3441 err = snd_hda_codec_reset(codec);
3442 if (err < 0) {
3443 printk(KERN_ERR
3444 "hda_codec: cannot revert codec\n");
3445 return err;
3446 }
3447 }
1da177e4 3448 }
6c1f45ea
TI		 3449 return 0;
3450}
ff7a3267 3451EXPORT_SYMBOL_HDA(snd_hda_build_controls);
cb53c626 3452
6c1f45ea
TI		 3453int snd_hda_codec_build_controls(struct hda_codec *codec)
3454{
3455 int err = 0;
11aeff08 3456 hda_exec_init_verbs(codec);
6c1f45ea
TI		 3457 /* continue to initialize... */
3458 if (codec->patch_ops.init)
3459 err = codec->patch_ops.init(codec);
3460 if (!err && codec->patch_ops.build_controls)
3461 err = codec->patch_ops.build_controls(codec);
6c1f45ea
TI		 3462 if (err < 0)
3463 return err;
1da177e4
LT		 3464 return 0;
3465}
3466
1da177e4
LT		 3467/*
3468 * stream formats
3469 */
befdf316
TI		 3470struct hda_rate_tbl {
3471 unsigned int hz;
3472 unsigned int alsa_bits;
3473 unsigned int hda_fmt;
3474};
3475
92f10b3f
TI		 3476/* rate = base * mult / div */
3477#define HDA_RATE(base, mult, div) \
3478 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3479 (((div) - 1) << AC_FMT_DIV_SHIFT))
3480
befdf316 3481static struct hda_rate_tbl rate_bits[] = {
1da177e4 3482 /* rate in Hz, ALSA rate bitmask, HDA format value */
9d8f53f2
NG		 3483
3484 /* autodetected value used in snd_hda_query_supported_pcm */
92f10b3f
TI		 3485 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3486 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3487 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3488 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3489 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3490 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3491 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3492 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3493 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3494 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3495 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
a961f9fe
TI		 3496#define AC_PAR_PCM_RATE_BITS 11
3497 /* up to bits 10, 384kHZ isn't supported properly */
3498
3499 /* not autodetected value */
92f10b3f 3500 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
9d8f53f2 3501
befdf316 3502 { 0 } /* terminator */
1da177e4
LT		 3503};
3504
3505/**
3506 * snd_hda_calc_stream_format - calculate format bitset
3507 * @rate: the sample rate
3508 * @channels: the number of channels
3509 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3510 * @maxbps: the max. bps
3511 *
3512 * Calculate the format bitset from the given rate, channels and th PCM format.
3513 *
3514 * Return zero if invalid.
3515 */
3516unsigned int snd_hda_calc_stream_format(unsigned int rate,
3517 unsigned int channels,
3518 unsigned int format,
32c168c8
AH		 3519 unsigned int maxbps,
3520 unsigned short spdif_ctls)
1da177e4
LT		 3521{
3522 int i;
3523 unsigned int val = 0;
3524
befdf316
TI		 3525 for (i = 0; rate_bits[i].hz; i++)
3526 if (rate_bits[i].hz == rate) {
3527 val = rate_bits[i].hda_fmt;
1da177e4
LT		 3528 break;
3529 }
0ba21762 3530 if (!rate_bits[i].hz) {
1da177e4
LT		 3531 snd_printdd("invalid rate %d\n", rate);
3532 return 0;
3533 }
3534
3535 if (channels == 0 || channels > 8) {
3536 snd_printdd("invalid channels %d\n", channels);
3537 return 0;
3538 }
3539 val |= channels - 1;
3540
3541 switch (snd_pcm_format_width(format)) {
28aedaf7 3542 case 8:
92f10b3f 3543 val |= AC_FMT_BITS_8;
28aedaf7
NL		 3544 break;
3545 case 16:
92f10b3f 3546 val |= AC_FMT_BITS_16;
28aedaf7 3547 break;
1da177e4
LT		 3548 case 20:
3549 case 24:
3550 case 32:
b0bb3aa6 3551 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
92f10b3f 3552 val |= AC_FMT_BITS_32;
1da177e4 3553 else if (maxbps >= 24)
92f10b3f 3554 val |= AC_FMT_BITS_24;
1da177e4 3555 else
92f10b3f 3556 val |= AC_FMT_BITS_20;
1da177e4
LT		 3557 break;
3558 default:
0ba21762
TI		 3559 snd_printdd("invalid format width %d\n",
3560 snd_pcm_format_width(format));
1da177e4
LT		 3561 return 0;
3562 }
3563
32c168c8 3564 if (spdif_ctls & AC_DIG1_NONAUDIO)
92f10b3f 3565 val |= AC_FMT_TYPE_NON_PCM;
32c168c8 3566
1da177e4
LT		 3567 return val;
3568}
ff7a3267 3569EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
1da177e4 3570
92c7c8a7
TI		 3571static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3572{
3573 unsigned int val = 0;
3574 if (nid != codec->afg &&
3575 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3576 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3577 if (!val || val == -1)
3578 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3579 if (!val || val == -1)
3580 return 0;
3581 return val;
3582}
3583
3584static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3585{
3586 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3587 get_pcm_param);
3588}
3589
3590static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3591{
3592 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3593 if (!streams || streams == -1)
3594 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3595 if (!streams || streams == -1)
3596 return 0;
3597 return streams;
3598}
3599
3600static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3601{
3602 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3603 get_stream_param);
3604}
3605
1da177e4
LT		 3606/**
3607 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3608 * @codec: the HDA codec
3609 * @nid: NID to query
3610 * @ratesp: the pointer to store the detected rate bitflags
3611 * @formatsp: the pointer to store the detected formats
3612 * @bpsp: the pointer to store the detected format widths
3613 *
3614 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3615 * or @bsps argument is ignored.
3616 *
3617 * Returns 0 if successful, otherwise a negative error code.
3618 */
384a48d7 3619int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
1da177e4
LT		 3620 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3621{
ee504710 3622 unsigned int i, val, wcaps;
1da177e4 3623
ee504710 3624 wcaps = get_wcaps(codec, nid);
92c7c8a7 3625 val = query_pcm_param(codec, nid);
1da177e4
LT		 3626
3627 if (ratesp) {
3628 u32 rates = 0;
a961f9fe 3629 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
1da177e4 3630 if (val & (1 << i))
befdf316 3631 rates |= rate_bits[i].alsa_bits;
1da177e4 3632 }
ee504710
JK		 3633 if (rates == 0) {
3634 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3635 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3636 nid, val,
3637 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3638 return -EIO;
3639 }
1da177e4
LT		 3640 *ratesp = rates;
3641 }
3642
3643 if (formatsp || bpsp) {
3644 u64 formats = 0;
ee504710 3645 unsigned int streams, bps;
1da177e4 3646
92c7c8a7
TI		 3647 streams = query_stream_param(codec, nid);
3648 if (!streams)
1da177e4 3649 return -EIO;
1da177e4
LT		 3650
3651 bps = 0;
3652 if (streams & AC_SUPFMT_PCM) {
3653 if (val & AC_SUPPCM_BITS_8) {
3654 formats |= SNDRV_PCM_FMTBIT_U8;
3655 bps = 8;
3656 }
3657 if (val & AC_SUPPCM_BITS_16) {
3658 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3659 bps = 16;
3660 }
3661 if (wcaps & AC_WCAP_DIGITAL) {
3662 if (val & AC_SUPPCM_BITS_32)
3663 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3664 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3665 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3666 if (val & AC_SUPPCM_BITS_24)
3667 bps = 24;
3668 else if (val & AC_SUPPCM_BITS_20)
3669 bps = 20;
0ba21762
TI		 3670 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3671 AC_SUPPCM_BITS_32)) {
1da177e4
LT		 3672 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3673 if (val & AC_SUPPCM_BITS_32)
3674 bps = 32;
1da177e4
LT		 3675 else if (val & AC_SUPPCM_BITS_24)
3676 bps = 24;
33ef7651
NG		 3677 else if (val & AC_SUPPCM_BITS_20)
3678 bps = 20;
1da177e4
LT		 3679 }
3680 }
b5025c50 3681 if (streams & AC_SUPFMT_FLOAT32) {
1da177e4 3682 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
b0bb3aa6
TI		 3683 if (!bps)
3684 bps = 32;
b5025c50
TI		 3685 }
3686 if (streams == AC_SUPFMT_AC3) {
0ba21762 3687 /* should be exclusive */
1da177e4
LT		 3688 /* temporary hack: we have still no proper support
3689 * for the direct AC3 stream...
3690 */
3691 formats |= SNDRV_PCM_FMTBIT_U8;
3692 bps = 8;
3693 }
ee504710
JK		 3694 if (formats == 0) {
3695 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3696 "(nid=0x%x, val=0x%x, ovrd=%i, "
3697 "streams=0x%x)\n",
3698 nid, val,
3699 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3700 streams);
3701 return -EIO;
3702 }
1da177e4
LT		 3703 if (formatsp)
3704 *formatsp = formats;
3705 if (bpsp)
3706 *bpsp = bps;
3707 }
3708
3709 return 0;
3710}
384a48d7 3711EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
1da177e4
LT		 3712
3713/**
d5191e50
TI		 3714 * snd_hda_is_supported_format - Check the validity of the format
3715 * @codec: HD-audio codec
3716 * @nid: NID to check
3717 * @format: the HD-audio format value to check
3718 *
3719 * Check whether the given node supports the format value.
1da177e4
LT		 3720 *
3721 * Returns 1 if supported, 0 if not.
3722 */
3723int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3724 unsigned int format)
3725{
3726 int i;
3727 unsigned int val = 0, rate, stream;
3728
92c7c8a7
TI		 3729 val = query_pcm_param(codec, nid);
3730 if (!val)
3731 return 0;
1da177e4
LT		 3732
3733 rate = format & 0xff00;
a961f9fe 3734 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
befdf316 3735 if (rate_bits[i].hda_fmt == rate) {
1da177e4
LT		 3736 if (val & (1 << i))
3737 break;
3738 return 0;
3739 }
a961f9fe 3740 if (i >= AC_PAR_PCM_RATE_BITS)
1da177e4
LT		 3741 return 0;
3742
92c7c8a7
TI		 3743 stream = query_stream_param(codec, nid);
3744 if (!stream)
1da177e4
LT		 3745 return 0;
3746
3747 if (stream & AC_SUPFMT_PCM) {
3748 switch (format & 0xf0) {
3749 case 0x00:
0ba21762 3750 if (!(val & AC_SUPPCM_BITS_8))
1da177e4
LT		 3751 return 0;
3752 break;
3753 case 0x10:
0ba21762 3754 if (!(val & AC_SUPPCM_BITS_16))
1da177e4
LT		 3755 return 0;
3756 break;
3757 case 0x20:
0ba21762 3758 if (!(val & AC_SUPPCM_BITS_20))
1da177e4
LT		 3759 return 0;
3760 break;
3761 case 0x30:
0ba21762 3762 if (!(val & AC_SUPPCM_BITS_24))
1da177e4
LT		 3763 return 0;
3764 break;
3765 case 0x40:
0ba21762 3766 if (!(val & AC_SUPPCM_BITS_32))
1da177e4
LT		 3767 return 0;
3768 break;
3769 default:
3770 return 0;
3771 }
3772 } else {
3773 /* FIXME: check for float32 and AC3? */
3774 }
3775
3776 return 1;
3777}
ff7a3267 3778EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
1da177e4
LT		 3779
3780/*
3781 * PCM stuff
3782 */
3783static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3784 struct hda_codec *codec,
c8b6bf9b 3785 struct snd_pcm_substream *substream)
1da177e4
LT		 3786{
3787 return 0;
3788}
3789
3790static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3791 struct hda_codec *codec,
3792 unsigned int stream_tag,
3793 unsigned int format,
c8b6bf9b 3794 struct snd_pcm_substream *substream)
1da177e4
LT		 3795{
3796 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3797 return 0;
3798}
3799
3800static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3801 struct hda_codec *codec,
c8b6bf9b 3802 struct snd_pcm_substream *substream)
1da177e4 3803{
888afa15 3804 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
1da177e4
LT		 3805 return 0;
3806}
3807
6c1f45ea
TI		 3808static int set_pcm_default_values(struct hda_codec *codec,
3809 struct hda_pcm_stream *info)
1da177e4 3810{
ee504710
JK		 3811 int err;
3812
0ba21762
TI		 3813 /* query support PCM information from the given NID */
3814 if (info->nid && (!info->rates || !info->formats)) {
ee504710 3815 err = snd_hda_query_supported_pcm(codec, info->nid,
0ba21762
TI		 3816 info->rates ? NULL : &info->rates,
3817 info->formats ? NULL : &info->formats,
3818 info->maxbps ? NULL : &info->maxbps);
ee504710
JK		 3819 if (err < 0)
3820 return err;
1da177e4
LT		 3821 }
3822 if (info->ops.open == NULL)
3823 info->ops.open = hda_pcm_default_open_close;
3824 if (info->ops.close == NULL)
3825 info->ops.close = hda_pcm_default_open_close;
3826 if (info->ops.prepare == NULL) {
da3cec35
TI		 3827 if (snd_BUG_ON(!info->nid))
3828 return -EINVAL;
1da177e4
LT		 3829 info->ops.prepare = hda_pcm_default_prepare;
3830 }
1da177e4 3831 if (info->ops.cleanup == NULL) {
da3cec35
TI		 3832 if (snd_BUG_ON(!info->nid))
3833 return -EINVAL;
1da177e4
LT		 3834 info->ops.cleanup = hda_pcm_default_cleanup;
3835 }
3836 return 0;
3837}
3838
eb541337
TI		 3839/*
3840 * codec prepare/cleanup entries
3841 */
3842int snd_hda_codec_prepare(struct hda_codec *codec,
3843 struct hda_pcm_stream *hinfo,
3844 unsigned int stream,
3845 unsigned int format,
3846 struct snd_pcm_substream *substream)
3847{
3848 int ret;
3f50ac6a 3849 mutex_lock(&codec->bus->prepare_mutex);
eb541337
TI		 3850 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
3851 if (ret >= 0)
3852 purify_inactive_streams(codec);
3f50ac6a 3853 mutex_unlock(&codec->bus->prepare_mutex);
eb541337
TI		 3854 return ret;
3855}
3856EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
3857
3858void snd_hda_codec_cleanup(struct hda_codec *codec,
3859 struct hda_pcm_stream *hinfo,
3860 struct snd_pcm_substream *substream)
3861{
3f50ac6a 3862 mutex_lock(&codec->bus->prepare_mutex);
eb541337 3863 hinfo->ops.cleanup(hinfo, codec, substream);
3f50ac6a 3864 mutex_unlock(&codec->bus->prepare_mutex);
eb541337
TI		 3865}
3866EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
3867
d5191e50 3868/* global */
e3303235
JK		 3869const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3870 "Audio", "SPDIF", "HDMI", "Modem"
3871};
3872
529bd6c4
TI		 3873/*
3874 * get the empty PCM device number to assign
c8936222
TI		 3875 *
3876 * note the max device number is limited by HDA_MAX_PCMS, currently 10
529bd6c4
TI		 3877 */
3878static int get_empty_pcm_device(struct hda_bus *bus, int type)
3879{
f5d6def5
WF		 3880 /* audio device indices; not linear to keep compatibility */
3881 static int audio_idx[HDA_PCM_NTYPES][5] = {
3882 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3883 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
92608bad 3884 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
f5d6def5 3885 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
529bd6c4 3886 };
f5d6def5
WF		 3887 int i;
3888
3889 if (type >= HDA_PCM_NTYPES) {
529bd6c4
TI		 3890 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3891 return -EINVAL;
3892 }
f5d6def5
WF		 3893
3894 for (i = 0; audio_idx[type][i] >= 0 ; i++)
3895 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3896 return audio_idx[type][i];
3897
01b65bfb
TI		 3898 /* non-fixed slots starting from 10 */
3899 for (i = 10; i < 32; i++) {
3900 if (!test_and_set_bit(i, bus->pcm_dev_bits))
3901 return i;
3902 }
3903
28aedaf7
NL		 3904 snd_printk(KERN_WARNING "Too many %s devices\n",
3905 snd_hda_pcm_type_name[type]);
f5d6def5 3906 return -EAGAIN;
529bd6c4
TI		 3907}
3908
176d5335
TI		 3909/*
3910 * attach a new PCM stream
3911 */
529bd6c4 3912static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
176d5335 3913{
33fa35ed 3914 struct hda_bus *bus = codec->bus;
176d5335
TI		 3915 struct hda_pcm_stream *info;
3916 int stream, err;
3917
b91f080f 3918 if (snd_BUG_ON(!pcm->name))
176d5335
TI		 3919 return -EINVAL;
3920 for (stream = 0; stream < 2; stream++) {
3921 info = &pcm->stream[stream];
3922 if (info->substreams) {
3923 err = set_pcm_default_values(codec, info);
3924 if (err < 0)
3925 return err;
3926 }
3927 }
33fa35ed 3928 return bus->ops.attach_pcm(bus, codec, pcm);
176d5335
TI		 3929}
3930
529bd6c4
TI		 3931/* assign all PCMs of the given codec */
3932int snd_hda_codec_build_pcms(struct hda_codec *codec)
3933{
3934 unsigned int pcm;
3935 int err;
3936
3937 if (!codec->num_pcms) {
3938 if (!codec->patch_ops.build_pcms)
3939 return 0;
3940 err = codec->patch_ops.build_pcms(codec);
6e655bf2
TI		 3941 if (err < 0) {
3942 printk(KERN_ERR "hda_codec: cannot build PCMs"
28aedaf7 3943 "for #%d (error %d)\n", codec->addr, err);
6e655bf2
TI		 3944 err = snd_hda_codec_reset(codec);
3945 if (err < 0) {
3946 printk(KERN_ERR
3947 "hda_codec: cannot revert codec\n");
3948 return err;
3949 }
3950 }
529bd6c4
TI		 3951 }
3952 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
3953 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
3954 int dev;
3955
3956 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
41b5b01a 3957 continue; /* no substreams assigned */
529bd6c4
TI		 3958
3959 if (!cpcm->pcm) {
3960 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
3961 if (dev < 0)
6e655bf2 3962 continue; /* no fatal error */
529bd6c4
TI		 3963 cpcm->device = dev;
3964 err = snd_hda_attach_pcm(codec, cpcm);
6e655bf2
TI		 3965 if (err < 0) {
3966 printk(KERN_ERR "hda_codec: cannot attach "
3967 "PCM stream %d for codec #%d\n",
3968 dev, codec->addr);
3969 continue; /* no fatal error */
3970 }
529bd6c4
TI		 3971 }
3972 }
3973 return 0;
3974}
3975
1da177e4
LT		 3976/**
3977 * snd_hda_build_pcms - build PCM information
3978 * @bus: the BUS
3979 *
3980 * Create PCM information for each codec included in the bus.
3981 *
3982 * The build_pcms codec patch is requested to set up codec->num_pcms and
3983 * codec->pcm_info properly. The array is referred by the top-level driver
3984 * to create its PCM instances.
3985 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3986 * callback.
3987 *
3988 * At least, substreams, channels_min and channels_max must be filled for
3989 * each stream. substreams = 0 indicates that the stream doesn't exist.
3990 * When rates and/or formats are zero, the supported values are queried
3991 * from the given nid. The nid is used also by the default ops.prepare
3992 * and ops.cleanup callbacks.
3993 *
3994 * The driver needs to call ops.open in its open callback. Similarly,
3995 * ops.close is supposed to be called in the close callback.
3996 * ops.prepare should be called in the prepare or hw_params callback
3997 * with the proper parameters for set up.
3998 * ops.cleanup should be called in hw_free for clean up of streams.
3999 *
25985edc 4000 * This function returns 0 if successful, or a negative error code.
1da177e4 4001 */
529bd6c4 4002int __devinit snd_hda_build_pcms(struct hda_bus *bus)
1da177e4 4003{
0ba21762 4004 struct hda_codec *codec;
1da177e4 4005
0ba21762 4006 list_for_each_entry(codec, &bus->codec_list, list) {
529bd6c4
TI		 4007 int err = snd_hda_codec_build_pcms(codec);
4008 if (err < 0)
4009 return err;
1da177e4
LT		 4010 }
4011 return 0;
4012}
ff7a3267 4013EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
1da177e4 4014
1da177e4
LT		 4015/**
4016 * snd_hda_check_board_config - compare the current codec with the config table
4017 * @codec: the HDA codec
f5fcc13c
TI		 4018 * @num_configs: number of config enums
4019 * @models: array of model name strings
1da177e4
LT		 4020 * @tbl: configuration table, terminated by null entries
4021 *
4022 * Compares the modelname or PCI subsystem id of the current codec with the
4023 * given configuration table. If a matching entry is found, returns its
4024 * config value (supposed to be 0 or positive).
4025 *
4026 * If no entries are matching, the function returns a negative value.
4027 */
12f288bf 4028int snd_hda_check_board_config(struct hda_codec *codec,
ea734963 4029 int num_configs, const char * const *models,
12f288bf 4030 const struct snd_pci_quirk *tbl)
1da177e4 4031{
f44ac837 4032 if (codec->modelname && models) {
f5fcc13c
TI		 4033 int i;
4034 for (i = 0; i < num_configs; i++) {
4035 if (models[i] &&
f44ac837 4036 !strcmp(codec->modelname, models[i])) {
f5fcc13c
TI		 4037 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4038 "selected\n", models[i]);
4039 return i;
1da177e4
LT		 4040 }
4041 }
4042 }
4043
f5fcc13c
TI		 4044 if (!codec->bus->pci || !tbl)
4045 return -1;
4046
4047 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4048 if (!tbl)
4049 return -1;
4050 if (tbl->value >= 0 && tbl->value < num_configs) {
62cf872a 4051#ifdef CONFIG_SND_DEBUG_VERBOSE
f5fcc13c
TI		 4052 char tmp[10];
4053 const char *model = NULL;
4054 if (models)
4055 model = models[tbl->value];
4056 if (!model) {
4057 sprintf(tmp, "#%d", tbl->value);
4058 model = tmp;
1da177e4 4059 }
f5fcc13c
TI		 4060 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4061 "for config %x:%x (%s)\n",
4062 model, tbl->subvendor, tbl->subdevice,
4063 (tbl->name ? tbl->name : "Unknown device"));
4064#endif
4065 return tbl->value;
1da177e4
LT		 4066 }
4067 return -1;
4068}
ff7a3267 4069EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
1da177e4 4070
2eda3445
MCC		 4071/**
4072 * snd_hda_check_board_codec_sid_config - compare the current codec
28aedaf7
NL		 4073 subsystem ID with the
4074 config table
2eda3445
MCC		 4075
4076 This is important for Gateway notebooks with SB450 HDA Audio
4077 where the vendor ID of the PCI device is:
4078 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4079 and the vendor/subvendor are found only at the codec.
4080
4081 * @codec: the HDA codec
4082 * @num_configs: number of config enums
4083 * @models: array of model name strings
4084 * @tbl: configuration table, terminated by null entries
4085 *
4086 * Compares the modelname or PCI subsystem id of the current codec with the
4087 * given configuration table. If a matching entry is found, returns its
4088 * config value (supposed to be 0 or positive).
4089 *
4090 * If no entries are matching, the function returns a negative value.
4091 */
4092int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
ea734963 4093 int num_configs, const char * const *models,
2eda3445
MCC		 4094 const struct snd_pci_quirk *tbl)
4095{
4096 const struct snd_pci_quirk *q;
4097
4098 /* Search for codec ID */
4099 for (q = tbl; q->subvendor; q++) {
e2301a4d
TI		 4100 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4101 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4102 if ((codec->subsystem_id & mask) == id)
2eda3445
MCC		 4103 break;
4104 }
4105
4106 if (!q->subvendor)
4107 return -1;
4108
4109 tbl = q;
4110
4111 if (tbl->value >= 0 && tbl->value < num_configs) {
d94ff6b7 4112#ifdef CONFIG_SND_DEBUG_VERBOSE
2eda3445
MCC		 4113 char tmp[10];
4114 const char *model = NULL;
4115 if (models)
4116 model = models[tbl->value];
4117 if (!model) {
4118 sprintf(tmp, "#%d", tbl->value);
4119 model = tmp;
4120 }
4121 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4122 "for config %x:%x (%s)\n",
4123 model, tbl->subvendor, tbl->subdevice,
4124 (tbl->name ? tbl->name : "Unknown device"));
4125#endif
4126 return tbl->value;
4127 }
4128 return -1;
4129}
4130EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4131
1da177e4
LT		 4132/**
4133 * snd_hda_add_new_ctls - create controls from the array
4134 * @codec: the HDA codec
c8b6bf9b 4135 * @knew: the array of struct snd_kcontrol_new
1da177e4
LT		 4136 *
4137 * This helper function creates and add new controls in the given array.
4138 * The array must be terminated with an empty entry as terminator.
4139 *
4140 * Returns 0 if successful, or a negative error code.
4141 */
031024ee
TI		 4142int snd_hda_add_new_ctls(struct hda_codec *codec,
4143 const struct snd_kcontrol_new *knew)
1da177e4 4144{
4d02d1b6 4145 int err;
1da177e4
LT		 4146
4147 for (; knew->name; knew++) {
54d17403 4148 struct snd_kcontrol *kctl;
1afe206a 4149 int addr = 0, idx = 0;
5b0cb1d8
JK		 4150 if (knew->iface == -1) /* skip this codec private value */
4151 continue;
1afe206a 4152 for (;;) {
54d17403 4153 kctl = snd_ctl_new1(knew, codec);
0ba21762 4154 if (!kctl)
54d17403 4155 return -ENOMEM;
1afe206a
TI		 4156 if (addr > 0)
4157 kctl->id.device = addr;
4158 if (idx > 0)
4159 kctl->id.index = idx;
3911a4c1 4160 err = snd_hda_ctl_add(codec, 0, kctl);
1afe206a
TI		 4161 if (!err)
4162 break;
4163 /* try first with another device index corresponding to
4164 * the codec addr; if it still fails (or it's the
4165 * primary codec), then try another control index
4166 */
4167 if (!addr && codec->addr)
4168 addr = codec->addr;
4169 else if (!idx && !knew->index) {
4170 idx = find_empty_mixer_ctl_idx(codec,
4171 knew->name);
4172 if (idx <= 0)
4173 return err;
4174 } else
54d17403
TI		 4175 return err;
4176 }
1da177e4
LT		 4177 }
4178 return 0;
4179}
ff7a3267 4180EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
1da177e4 4181
cb53c626 4182#ifdef CONFIG_SND_HDA_POWER_SAVE
cb53c626
TI		 4183static void hda_power_work(struct work_struct *work)
4184{
4185 struct hda_codec *codec =
4186 container_of(work, struct hda_codec, power_work.work);
33fa35ed 4187 struct hda_bus *bus = codec->bus;
cb53c626 4188
2e492462
ML		 4189 if (!codec->power_on || codec->power_count) {
4190 codec->power_transition = 0;
cb53c626 4191 return;
2e492462 4192 }
cb53c626 4193
d66fee5d 4194 trace_hda_power_down(codec);
cb53c626 4195 hda_call_codec_suspend(codec);
33fa35ed
TI		 4196 if (bus->ops.pm_notify)
4197 bus->ops.pm_notify(bus);
cb53c626
TI		 4198}
4199
4200static void hda_keep_power_on(struct hda_codec *codec)
4201{
4202 codec->power_count++;
4203 codec->power_on = 1;
a2f6309e
TI		 4204 codec->power_jiffies = jiffies;
4205}
4206
d5191e50 4207/* update the power on/off account with the current jiffies */
a2f6309e
TI		 4208void snd_hda_update_power_acct(struct hda_codec *codec)
4209{
4210 unsigned long delta = jiffies - codec->power_jiffies;
4211 if (codec->power_on)
4212 codec->power_on_acct += delta;
4213 else
4214 codec->power_off_acct += delta;
4215 codec->power_jiffies += delta;
cb53c626
TI		 4216}
4217
d5191e50
TI		 4218/**
4219 * snd_hda_power_up - Power-up the codec
4220 * @codec: HD-audio codec
4221 *
4222 * Increment the power-up counter and power up the hardware really when
4223 * not turned on yet.
28aedaf7 4224 */
cb53c626
TI		 4225void snd_hda_power_up(struct hda_codec *codec)
4226{
33fa35ed
TI		 4227 struct hda_bus *bus = codec->bus;
4228
cb53c626 4229 codec->power_count++;
a221e287 4230 if (codec->power_on || codec->power_transition)
cb53c626
TI		 4231 return;
4232
d66fee5d 4233 trace_hda_power_up(codec);
a2f6309e 4234 snd_hda_update_power_acct(codec);
cb53c626 4235 codec->power_on = 1;
a2f6309e 4236 codec->power_jiffies = jiffies;
33fa35ed
TI		 4237 if (bus->ops.pm_notify)
4238 bus->ops.pm_notify(bus);
cb53c626
TI		 4239 hda_call_codec_resume(codec);
4240 cancel_delayed_work(&codec->power_work);
a221e287 4241 codec->power_transition = 0;
cb53c626 4242}
ff7a3267 4243EXPORT_SYMBOL_HDA(snd_hda_power_up);
1289e9e8
TI		 4244
4245#define power_save(codec) \
4246 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
cb53c626 4247
d5191e50
TI		 4248/**
4249 * snd_hda_power_down - Power-down the codec
4250 * @codec: HD-audio codec
4251 *
4252 * Decrement the power-up counter and schedules the power-off work if
4253 * the counter rearches to zero.
28aedaf7 4254 */
cb53c626
TI		 4255void snd_hda_power_down(struct hda_codec *codec)
4256{
4257 --codec->power_count;
a221e287 4258 if (!codec->power_on || codec->power_count || codec->power_transition)
cb53c626 4259 return;
fee2fba3 4260 if (power_save(codec)) {
a221e287 4261 codec->power_transition = 1; /* avoid reentrance */
c107b41c 4262 queue_delayed_work(codec->bus->workq, &codec->power_work,
fee2fba3 4263 msecs_to_jiffies(power_save(codec) * 1000));
a221e287 4264 }
cb53c626 4265}
ff7a3267 4266EXPORT_SYMBOL_HDA(snd_hda_power_down);
cb53c626 4267
d5191e50
TI		 4268/**
4269 * snd_hda_check_amp_list_power - Check the amp list and update the power
4270 * @codec: HD-audio codec
4271 * @check: the object containing an AMP list and the status
4272 * @nid: NID to check / update
4273 *
4274 * Check whether the given NID is in the amp list. If it's in the list,
4275 * check the current AMP status, and update the the power-status according
4276 * to the mute status.
4277 *
4278 * This function is supposed to be set or called from the check_power_status
4279 * patch ops.
28aedaf7 4280 */
cb53c626
TI		 4281int snd_hda_check_amp_list_power(struct hda_codec *codec,
4282 struct hda_loopback_check *check,
4283 hda_nid_t nid)
4284{
031024ee 4285 const struct hda_amp_list *p;
cb53c626
TI		 4286 int ch, v;
4287
4288 if (!check->amplist)
4289 return 0;
4290 for (p = check->amplist; p->nid; p++) {
4291 if (p->nid == nid)
4292 break;
4293 }
4294 if (!p->nid)
4295 return 0; /* nothing changed */
4296
4297 for (p = check->amplist; p->nid; p++) {
4298 for (ch = 0; ch < 2; ch++) {
4299 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4300 p->idx);
4301 if (!(v & HDA_AMP_MUTE) && v > 0) {
4302 if (!check->power_on) {
4303 check->power_on = 1;
4304 snd_hda_power_up(codec);
4305 }
4306 return 1;
4307 }
4308 }
4309 }
4310 if (check->power_on) {
4311 check->power_on = 0;
4312 snd_hda_power_down(codec);
4313 }
4314 return 0;
4315}
ff7a3267 4316EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
cb53c626 4317#endif
1da177e4 4318
c8b6bf9b 4319/*
d2a6d7dc
TI		 4320 * Channel mode helper
4321 */
d5191e50
TI		 4322
4323/**
4324 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4325 */
0ba21762
TI		 4326int snd_hda_ch_mode_info(struct hda_codec *codec,
4327 struct snd_ctl_elem_info *uinfo,
4328 const struct hda_channel_mode *chmode,
4329 int num_chmodes)
d2a6d7dc
TI		 4330{
4331 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4332 uinfo->count = 1;
4333 uinfo->value.enumerated.items = num_chmodes;
4334 if (uinfo->value.enumerated.item >= num_chmodes)
4335 uinfo->value.enumerated.item = num_chmodes - 1;
4336 sprintf(uinfo->value.enumerated.name, "%dch",
4337 chmode[uinfo->value.enumerated.item].channels);
4338 return 0;
4339}
ff7a3267 4340EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
d2a6d7dc 4341
d5191e50
TI		 4342/**
4343 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4344 */
0ba21762
TI		 4345int snd_hda_ch_mode_get(struct hda_codec *codec,
4346 struct snd_ctl_elem_value *ucontrol,
4347 const struct hda_channel_mode *chmode,
4348 int num_chmodes,
d2a6d7dc
TI		 4349 int max_channels)
4350{
4351 int i;
4352
4353 for (i = 0; i < num_chmodes; i++) {
4354 if (max_channels == chmode[i].channels) {
4355 ucontrol->value.enumerated.item[0] = i;
4356 break;
4357 }
4358 }
4359 return 0;
4360}
ff7a3267 4361EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
d2a6d7dc 4362
d5191e50
TI		 4363/**
4364 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4365 */
0ba21762
TI		 4366int snd_hda_ch_mode_put(struct hda_codec *codec,
4367 struct snd_ctl_elem_value *ucontrol,
4368 const struct hda_channel_mode *chmode,
4369 int num_chmodes,
d2a6d7dc
TI		 4370 int *max_channelsp)
4371{
4372 unsigned int mode;
4373
4374 mode = ucontrol->value.enumerated.item[0];
68ea7b2f
TI		 4375 if (mode >= num_chmodes)
4376 return -EINVAL;
82beb8fd 4377 if (*max_channelsp == chmode[mode].channels)
d2a6d7dc
TI		 4378 return 0;
4379 /* change the current channel setting */
4380 *max_channelsp = chmode[mode].channels;
4381 if (chmode[mode].sequence)
82beb8fd 4382 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
d2a6d7dc
TI		 4383 return 1;
4384}
ff7a3267 4385EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
d2a6d7dc 4386
1da177e4
LT		 4387/*
4388 * input MUX helper
4389 */
d5191e50
TI		 4390
4391/**
4392 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4393 */
0ba21762
TI		 4394int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4395 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 4396{
4397 unsigned int index;
4398
4399 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4400 uinfo->count = 1;
4401 uinfo->value.enumerated.items = imux->num_items;
5513b0c5
TI		 4402 if (!imux->num_items)
4403 return 0;
1da177e4
LT		 4404 index = uinfo->value.enumerated.item;
4405 if (index >= imux->num_items)
4406 index = imux->num_items - 1;
4407 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4408 return 0;
4409}
ff7a3267 4410EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
1da177e4 4411
d5191e50
TI		 4412/**
4413 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4414 */
0ba21762
TI		 4415int snd_hda_input_mux_put(struct hda_codec *codec,
4416 const struct hda_input_mux *imux,
4417 struct snd_ctl_elem_value *ucontrol,
4418 hda_nid_t nid,
1da177e4
LT		 4419 unsigned int *cur_val)
4420{
4421 unsigned int idx;
4422
5513b0c5
TI		 4423 if (!imux->num_items)
4424 return 0;
1da177e4
LT		 4425 idx = ucontrol->value.enumerated.item[0];
4426 if (idx >= imux->num_items)
4427 idx = imux->num_items - 1;
82beb8fd 4428 if (*cur_val == idx)
1da177e4 4429 return 0;
82beb8fd
TI		 4430 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4431 imux->items[idx].index);
1da177e4
LT		 4432 *cur_val = idx;
4433 return 1;
4434}
ff7a3267 4435EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
1da177e4
LT		 4436
4437
4438/*
4439 * Multi-channel / digital-out PCM helper functions
4440 */
4441
6b97eb45
TI		 4442/* setup SPDIF output stream */
4443static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4444 unsigned int stream_tag, unsigned int format)
4445{
7c935976
SW		 4446 struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4447
6b97eb45 4448 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
7c935976 4449 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
28aedaf7 4450 set_dig_out_convert(codec, nid,
7c935976 4451 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
2f72853c 4452 -1);
6b97eb45 4453 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2f72853c 4454 if (codec->slave_dig_outs) {
dda14410 4455 const hda_nid_t *d;
2f72853c
TI		 4456 for (d = codec->slave_dig_outs; *d; d++)
4457 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4458 format);
4459 }
6b97eb45 4460 /* turn on again (if needed) */
7c935976 4461 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
2f72853c 4462 set_dig_out_convert(codec, nid,
7c935976 4463 spdif->ctls & 0xff, -1);
2f72853c 4464}
de51ca12 4465
2f72853c
TI		 4466static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4467{
4468 snd_hda_codec_cleanup_stream(codec, nid);
4469 if (codec->slave_dig_outs) {
dda14410 4470 const hda_nid_t *d;
2f72853c
TI		 4471 for (d = codec->slave_dig_outs; *d; d++)
4472 snd_hda_codec_cleanup_stream(codec, *d);
de51ca12 4473 }
6b97eb45
TI		 4474}
4475
d5191e50
TI		 4476/**
4477 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4478 * @bus: HD-audio bus
4479 */
fb8d1a34
TI		 4480void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4481{
4482 struct hda_codec *codec;
4483
4484 if (!bus)
4485 return;
4486 list_for_each_entry(codec, &bus->codec_list, list) {
e581f3db
TI		 4487 if (hda_codec_is_power_on(codec) &&
4488 codec->patch_ops.reboot_notify)
fb8d1a34
TI		 4489 codec->patch_ops.reboot_notify(codec);
4490 }
4491}
8f217a22 4492EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
fb8d1a34 4493
d5191e50
TI		 4494/**
4495 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
1da177e4 4496 */
0ba21762
TI		 4497int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4498 struct hda_multi_out *mout)
1da177e4 4499{
62932df8 4500 mutex_lock(&codec->spdif_mutex);
5930ca41
TI		 4501 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4502 /* already opened as analog dup; reset it once */
2f72853c 4503 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4 4504 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
62932df8 4505 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4506 return 0;
4507}
ff7a3267 4508EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
1da177e4 4509
d5191e50
TI		 4510/**
4511 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4512 */
6b97eb45
TI		 4513int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4514 struct hda_multi_out *mout,
4515 unsigned int stream_tag,
4516 unsigned int format,
4517 struct snd_pcm_substream *substream)
4518{
4519 mutex_lock(&codec->spdif_mutex);
4520 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4521 mutex_unlock(&codec->spdif_mutex);
4522 return 0;
4523}
ff7a3267 4524EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
6b97eb45 4525
d5191e50
TI		 4526/**
4527 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4528 */
9411e21c
TI		 4529int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4530 struct hda_multi_out *mout)
4531{
4532 mutex_lock(&codec->spdif_mutex);
4533 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4534 mutex_unlock(&codec->spdif_mutex);
4535 return 0;
4536}
4537EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4538
d5191e50
TI		 4539/**
4540 * snd_hda_multi_out_dig_close - release the digital out stream
1da177e4 4541 */
0ba21762
TI		 4542int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4543 struct hda_multi_out *mout)
1da177e4 4544{
62932df8 4545 mutex_lock(&codec->spdif_mutex);
1da177e4 4546 mout->dig_out_used = 0;
62932df8 4547 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4548 return 0;
4549}
ff7a3267 4550EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
1da177e4 4551
d5191e50
TI		 4552/**
4553 * snd_hda_multi_out_analog_open - open analog outputs
4554 *
4555 * Open analog outputs and set up the hw-constraints.
4556 * If the digital outputs can be opened as slave, open the digital
4557 * outputs, too.
1da177e4 4558 */
0ba21762
TI		 4559int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4560 struct hda_multi_out *mout,
9a08160b
TI		 4561 struct snd_pcm_substream *substream,
4562 struct hda_pcm_stream *hinfo)
4563{
4564 struct snd_pcm_runtime *runtime = substream->runtime;
4565 runtime->hw.channels_max = mout->max_channels;
4566 if (mout->dig_out_nid) {
4567 if (!mout->analog_rates) {
4568 mout->analog_rates = hinfo->rates;
4569 mout->analog_formats = hinfo->formats;
4570 mout->analog_maxbps = hinfo->maxbps;
4571 } else {
4572 runtime->hw.rates = mout->analog_rates;
4573 runtime->hw.formats = mout->analog_formats;
4574 hinfo->maxbps = mout->analog_maxbps;
4575 }
4576 if (!mout->spdif_rates) {
4577 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4578 &mout->spdif_rates,
4579 &mout->spdif_formats,
4580 &mout->spdif_maxbps);
4581 }
4582 mutex_lock(&codec->spdif_mutex);
4583 if (mout->share_spdif) {
022b466f
TI		 4584 if ((runtime->hw.rates & mout->spdif_rates) &&
4585 (runtime->hw.formats & mout->spdif_formats)) {
4586 runtime->hw.rates &= mout->spdif_rates;
4587 runtime->hw.formats &= mout->spdif_formats;
4588 if (mout->spdif_maxbps < hinfo->maxbps)
4589 hinfo->maxbps = mout->spdif_maxbps;
4590 } else {
4591 mout->share_spdif = 0;
4592 /* FIXME: need notify? */
4593 }
9a08160b 4594 }
eaa9985b 4595 mutex_unlock(&codec->spdif_mutex);
9a08160b 4596 }
1da177e4
LT		 4597 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4598 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4599}
ff7a3267 4600EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
1da177e4 4601
d5191e50
TI		 4602/**
4603 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4604 *
4605 * Set up the i/o for analog out.
4606 * When the digital out is available, copy the front out to digital out, too.
1da177e4 4607 */
0ba21762
TI		 4608int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4609 struct hda_multi_out *mout,
1da177e4
LT		 4610 unsigned int stream_tag,
4611 unsigned int format,
c8b6bf9b 4612 struct snd_pcm_substream *substream)
1da177e4 4613{
dda14410 4614 const hda_nid_t *nids = mout->dac_nids;
1da177e4 4615 int chs = substream->runtime->channels;
7c935976
SW		 4616 struct hda_spdif_out *spdif =
4617 snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
1da177e4
LT		 4618 int i;
4619
62932df8 4620 mutex_lock(&codec->spdif_mutex);
9a08160b
TI		 4621 if (mout->dig_out_nid && mout->share_spdif &&
4622 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
1da177e4 4623 if (chs == 2 &&
0ba21762
TI		 4624 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4625 format) &&
7c935976 4626 !(spdif->status & IEC958_AES0_NONAUDIO)) {
1da177e4 4627 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
6b97eb45
TI		 4628 setup_dig_out_stream(codec, mout->dig_out_nid,
4629 stream_tag, format);
1da177e4
LT		 4630 } else {
4631 mout->dig_out_used = 0;
2f72853c 4632 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 4633 }
4634 }
62932df8 4635 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4636
4637 /* front */
0ba21762
TI		 4638 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4639 0, format);
d29240ce
TI		 4640 if (!mout->no_share_stream &&
4641 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
1da177e4 4642 /* headphone out will just decode front left/right (stereo) */
0ba21762
TI		 4643 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4644 0, format);
82bc955f 4645 /* extra outputs copied from front */
a06dbfc2
TI		 4646 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4647 if (!mout->no_share_stream && mout->hp_out_nid[i])
4648 snd_hda_codec_setup_stream(codec,
4649 mout->hp_out_nid[i],
4650 stream_tag, 0, format);
82bc955f 4651 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
d29240ce 4652 if (!mout->no_share_stream && mout->extra_out_nid[i])
82bc955f
TI		 4653 snd_hda_codec_setup_stream(codec,
4654 mout->extra_out_nid[i],
4655 stream_tag, 0, format);
4656
1da177e4
LT		 4657 /* surrounds */
4658 for (i = 1; i < mout->num_dacs; i++) {
4b3acaf5 4659 if (chs >= (i + 1) * 2) /* independent out */
0ba21762
TI		 4660 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4661 i * 2, format);
d29240ce 4662 else if (!mout->no_share_stream) /* copy front */
0ba21762
TI		 4663 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4664 0, format);
1da177e4
LT		 4665 }
4666 return 0;
4667}
ff7a3267 4668EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
1da177e4 4669
d5191e50
TI		 4670/**
4671 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
1da177e4 4672 */
0ba21762
TI		 4673int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4674 struct hda_multi_out *mout)
1da177e4 4675{
dda14410 4676 const hda_nid_t *nids = mout->dac_nids;
1da177e4
LT		 4677 int i;
4678
4679 for (i = 0; i < mout->num_dacs; i++)
888afa15 4680 snd_hda_codec_cleanup_stream(codec, nids[i]);
1da177e4 4681 if (mout->hp_nid)
888afa15 4682 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
a06dbfc2
TI		 4683 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4684 if (mout->hp_out_nid[i])
4685 snd_hda_codec_cleanup_stream(codec,
4686 mout->hp_out_nid[i]);
82bc955f
TI		 4687 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4688 if (mout->extra_out_nid[i])
888afa15
TI		 4689 snd_hda_codec_cleanup_stream(codec,
4690 mout->extra_out_nid[i]);
62932df8 4691 mutex_lock(&codec->spdif_mutex);
1da177e4 4692 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
2f72853c 4693 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 4694 mout->dig_out_used = 0;
4695 }
62932df8 4696 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 4697 return 0;
4698}
ff7a3267 4699EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
1da177e4 4700
e9edcee0 4701/*
6b34500c 4702 * Helper for automatic pin configuration
e9edcee0 4703 */
df694daa 4704
dda14410 4705static int is_in_nid_list(hda_nid_t nid, const hda_nid_t *list)
df694daa
KY		 4706{
4707 for (; *list; list++)
4708 if (*list == nid)
4709 return 1;
4710 return 0;
4711}
4712
81937d3b
SL		 4713
4714/*
4715 * Sort an associated group of pins according to their sequence numbers.
4716 */
28aedaf7 4717static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences,
81937d3b
SL		 4718 int num_pins)
4719{
4720 int i, j;
4721 short seq;
4722 hda_nid_t nid;
28aedaf7 4723
81937d3b
SL		 4724 for (i = 0; i < num_pins; i++) {
4725 for (j = i + 1; j < num_pins; j++) {
4726 if (sequences[i] > sequences[j]) {
4727 seq = sequences[i];
4728 sequences[i] = sequences[j];
4729 sequences[j] = seq;
4730 nid = pins[i];
4731 pins[i] = pins[j];
4732 pins[j] = nid;
4733 }
4734 }
4735 }
4736}
4737
4738
75e0eb24
TI		 4739/* add the found input-pin to the cfg->inputs[] table */
4740static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid,
4741 int type)
4742{
4743 if (cfg->num_inputs < AUTO_CFG_MAX_INS) {
4744 cfg->inputs[cfg->num_inputs].pin = nid;
4745 cfg->inputs[cfg->num_inputs].type = type;
4746 cfg->num_inputs++;
4747 }
4748}
4749
4a4d4a69
TI		 4750/* sort inputs in the order of AUTO_PIN_* type */
4751static void sort_autocfg_input_pins(struct auto_pin_cfg *cfg)
4752{
4753 int i, j;
4754
4755 for (i = 0; i < cfg->num_inputs; i++) {
4756 for (j = i + 1; j < cfg->num_inputs; j++) {
4757 if (cfg->inputs[i].type > cfg->inputs[j].type) {
4758 struct auto_pin_cfg_item tmp;
4759 tmp = cfg->inputs[i];
4760 cfg->inputs[i] = cfg->inputs[j];
4761 cfg->inputs[j] = tmp;
4762 }
4763 }
4764 }
4765}
4766
8fa7ab48
TI		 4767/* Reorder the surround channels
4768 * ALSA sequence is front/surr/clfe/side
4769 * HDA sequence is:
4770 * 4-ch: front/surr => OK as it is
4771 * 6-ch: front/clfe/surr
4772 * 8-ch: front/clfe/rear/side|fc
4773 */
4774static void reorder_outputs(unsigned int nums, hda_nid_t *pins)
4775{
4776 hda_nid_t nid;
4777
4778 switch (nums) {
4779 case 3:
4780 case 4:
4781 nid = pins[1];
4782 pins[1] = pins[2];
4783 pins[2] = nid;
4784 break;
4785 }
4786}
4787
82bc955f
TI		 4788/*
4789 * Parse all pin widgets and store the useful pin nids to cfg
4790 *
4791 * The number of line-outs or any primary output is stored in line_outs,
4792 * and the corresponding output pins are assigned to line_out_pins[],
4793 * in the order of front, rear, CLFE, side, ...
4794 *
4795 * If more extra outputs (speaker and headphone) are found, the pins are
eb06ed8f 4796 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
82bc955f
TI		 4797 * is detected, one of speaker of HP pins is assigned as the primary
4798 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4799 * if any analog output exists.
28aedaf7 4800 *
86e2959a 4801 * The analog input pins are assigned to inputs array.
82bc955f
TI		 4802 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4803 * respectively.
4804 */
d025febc
TI		 4805int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
4806 struct auto_pin_cfg *cfg,
4807 const hda_nid_t *ignore_nids,
4808 unsigned int cond_flags)
e9edcee0 4809{
0ef6ce7b 4810 hda_nid_t nid, end_nid;
965f1b2e 4811 short seq, assoc_line_out;
81937d3b
SL		 4812 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4813 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
f889fa91 4814 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
75e0eb24 4815 int i;
e9edcee0
TI		 4816
4817 memset(cfg, 0, sizeof(*cfg));
4818
81937d3b
SL		 4819 memset(sequences_line_out, 0, sizeof(sequences_line_out));
4820 memset(sequences_speaker, 0, sizeof(sequences_speaker));
f889fa91 4821 memset(sequences_hp, 0, sizeof(sequences_hp));
965f1b2e 4822 assoc_line_out = 0;
e9edcee0 4823
2f451d2a 4824 codec->ignore_misc_bit = true;
0ef6ce7b
TI		 4825 end_nid = codec->start_nid + codec->num_nodes;
4826 for (nid = codec->start_nid; nid < end_nid; nid++) {
54d17403 4827 unsigned int wid_caps = get_wcaps(codec, nid);
a22d543a 4828 unsigned int wid_type = get_wcaps_type(wid_caps);
e9edcee0 4829 unsigned int def_conf;
1af7c5f0 4830 short assoc, loc, conn, dev;
e9edcee0
TI		 4831
4832 /* read all default configuration for pin complex */
4833 if (wid_type != AC_WID_PIN)
4834 continue;
df694daa
KY		 4835 /* ignore the given nids (e.g. pc-beep returns error) */
4836 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4837 continue;
4838
c17a1aba 4839 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2f451d2a
TI		 4840 if (!(get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
4841 AC_DEFCFG_MISC_NO_PRESENCE))
4842 codec->ignore_misc_bit = false;
1af7c5f0
TI		 4843 conn = get_defcfg_connect(def_conf);
4844 if (conn == AC_JACK_PORT_NONE)
e9edcee0
TI		 4845 continue;
4846 loc = get_defcfg_location(def_conf);
1af7c5f0
TI		 4847 dev = get_defcfg_device(def_conf);
4848
4849 /* workaround for buggy BIOS setups */
4850 if (dev == AC_JACK_LINE_OUT) {
4851 if (conn == AC_JACK_PORT_FIXED)
4852 dev = AC_JACK_SPEAKER;
4853 }
4854
4855 switch (dev) {
e9edcee0 4856 case AC_JACK_LINE_OUT:
e9edcee0
TI		 4857 seq = get_defcfg_sequence(def_conf);
4858 assoc = get_defcfg_association(def_conf);
90da78bf
MR		 4859
4860 if (!(wid_caps & AC_WCAP_STEREO))
4861 if (!cfg->mono_out_pin)
4862 cfg->mono_out_pin = nid;
0ba21762 4863 if (!assoc)
e9edcee0 4864 continue;
0ba21762 4865 if (!assoc_line_out)
e9edcee0
TI		 4866 assoc_line_out = assoc;
4867 else if (assoc_line_out != assoc)
4868 continue;
4869 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4870 continue;
4871 cfg->line_out_pins[cfg->line_outs] = nid;
81937d3b 4872 sequences_line_out[cfg->line_outs] = seq;
e9edcee0
TI		 4873 cfg->line_outs++;
4874 break;
8d88bc3d 4875 case AC_JACK_SPEAKER:
81937d3b
SL		 4876 seq = get_defcfg_sequence(def_conf);
4877 assoc = get_defcfg_association(def_conf);
82bc955f
TI		 4878 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4879 continue;
4880 cfg->speaker_pins[cfg->speaker_outs] = nid;
965f1b2e 4881 sequences_speaker[cfg->speaker_outs] = (assoc << 4) | seq;
82bc955f 4882 cfg->speaker_outs++;
8d88bc3d 4883 break;
e9edcee0 4884 case AC_JACK_HP_OUT:
f889fa91
TI		 4885 seq = get_defcfg_sequence(def_conf);
4886 assoc = get_defcfg_association(def_conf);
eb06ed8f
TI		 4887 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4888 continue;
4889 cfg->hp_pins[cfg->hp_outs] = nid;
f889fa91 4890 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
eb06ed8f 4891 cfg->hp_outs++;
e9edcee0 4892 break;
86e2959a
TI		 4893 case AC_JACK_MIC_IN:
4894 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_MIC);
e9edcee0 4895 break;
86e2959a
TI		 4896 case AC_JACK_LINE_IN:
4897 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_LINE_IN);
e9edcee0
TI		 4898 break;
4899 case AC_JACK_CD:
75e0eb24 4900 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD);
e9edcee0
TI		 4901 break;
4902 case AC_JACK_AUX:
75e0eb24 4903 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX);
e9edcee0
TI		 4904 break;
4905 case AC_JACK_SPDIF_OUT:
1b52ae70 4906 case AC_JACK_DIG_OTHER_OUT:
0852d7a6
TI		 4907 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
4908 continue;
4909 cfg->dig_out_pins[cfg->dig_outs] = nid;
4910 cfg->dig_out_type[cfg->dig_outs] =
4911 (loc == AC_JACK_LOC_HDMI) ?
4912 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
4913 cfg->dig_outs++;
e9edcee0
TI		 4914 break;
4915 case AC_JACK_SPDIF_IN:
1b52ae70 4916 case AC_JACK_DIG_OTHER_IN:
e9edcee0 4917 cfg->dig_in_pin = nid;
2297bd6e
TI		 4918 if (loc == AC_JACK_LOC_HDMI)
4919 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
4920 else
4921 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
e9edcee0
TI		 4922 break;
4923 }
4924 }
4925
5832fcf8
TI		 4926 /* FIX-UP:
4927 * If no line-out is defined but multiple HPs are found,
4928 * some of them might be the real line-outs.
4929 */
d025febc
TI		 4930 if (!cfg->line_outs && cfg->hp_outs > 1 &&
4931 !(cond_flags & HDA_PINCFG_NO_HP_FIXUP)) {
5832fcf8
TI		 4932 int i = 0;
4933 while (i < cfg->hp_outs) {
4934 /* The real HPs should have the sequence 0x0f */
4935 if ((sequences_hp[i] & 0x0f) == 0x0f) {
4936 i++;
4937 continue;
4938 }
4939 /* Move it to the line-out table */
4940 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
4941 sequences_line_out[cfg->line_outs] = sequences_hp[i];
4942 cfg->line_outs++;
4943 cfg->hp_outs--;
4944 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
4945 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
122661b6 4946 memmove(sequences_hp + i, sequences_hp + i + 1,
5832fcf8
TI		 4947 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
4948 }
03642c9a
TI		 4949 memset(cfg->hp_pins + cfg->hp_outs, 0,
4950 sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs));
b2d05760
TI		 4951 if (!cfg->hp_outs)
4952 cfg->line_out_type = AUTO_PIN_HP_OUT;
4953
5832fcf8
TI		 4954 }
4955
e9edcee0 4956 /* sort by sequence */
81937d3b
SL		 4957 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
4958 cfg->line_outs);
4959 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
4960 cfg->speaker_outs);
f889fa91
TI		 4961 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
4962 cfg->hp_outs);
28aedaf7 4963
81937d3b
SL		 4964 /*
4965 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4966 * as a primary output
4967 */
d025febc
TI		 4968 if (!cfg->line_outs &&
4969 !(cond_flags & HDA_PINCFG_NO_LO_FIXUP)) {
81937d3b
SL		 4970 if (cfg->speaker_outs) {
4971 cfg->line_outs = cfg->speaker_outs;
4972 memcpy(cfg->line_out_pins, cfg->speaker_pins,
4973 sizeof(cfg->speaker_pins));
4974 cfg->speaker_outs = 0;
4975 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
4976 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
4977 } else if (cfg->hp_outs) {
4978 cfg->line_outs = cfg->hp_outs;
4979 memcpy(cfg->line_out_pins, cfg->hp_pins,
4980 sizeof(cfg->hp_pins));
4981 cfg->hp_outs = 0;
4982 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4983 cfg->line_out_type = AUTO_PIN_HP_OUT;
4984 }
4985 }
e9edcee0 4986
8fa7ab48
TI		 4987 reorder_outputs(cfg->line_outs, cfg->line_out_pins);
4988 reorder_outputs(cfg->hp_outs, cfg->hp_pins);
4989 reorder_outputs(cfg->speaker_outs, cfg->speaker_pins);
e9edcee0 4990
4a4d4a69
TI		 4991 sort_autocfg_input_pins(cfg);
4992
82bc955f
TI		 4993 /*
4994 * debug prints of the parsed results
4995 */
c2de187e 4996 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
82bc955f
TI		 4997 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
4998 cfg->line_out_pins[2], cfg->line_out_pins[3],
c2de187e
TI		 4999 cfg->line_out_pins[4],
5000 cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
5001 (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT ?
5002 "speaker" : "line"));
82bc955f
TI		 5003 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
5004 cfg->speaker_outs, cfg->speaker_pins[0],
5005 cfg->speaker_pins[1], cfg->speaker_pins[2],
5006 cfg->speaker_pins[3], cfg->speaker_pins[4]);
eb06ed8f
TI		 5007 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
5008 cfg->hp_outs, cfg->hp_pins[0],
5009 cfg->hp_pins[1], cfg->hp_pins[2],
5010 cfg->hp_pins[3], cfg->hp_pins[4]);
90da78bf 5011 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
0852d7a6
TI		 5012 if (cfg->dig_outs)
5013 snd_printd(" dig-out=0x%x/0x%x\n",
5014 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
75e0eb24
TI		 5015 snd_printd(" inputs:");
5016 for (i = 0; i < cfg->num_inputs; i++) {
0b626737 5017 snd_printd(" %s=0x%x",
10a20af7 5018 hda_get_autocfg_input_label(codec, cfg, i),
75e0eb24
TI		 5019 cfg->inputs[i].pin);
5020 }
5021 snd_printd("\n");
32d2c7fa 5022 if (cfg->dig_in_pin)
89ce9e87 5023 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
82bc955f 5024
e9edcee0
TI		 5025 return 0;
5026}
d025febc 5027EXPORT_SYMBOL_HDA(snd_hda_parse_pin_defcfg);
e9edcee0 5028
99ae28be 5029int snd_hda_get_input_pin_attr(unsigned int def_conf)
a1c98515
TI		 5030{
5031 unsigned int loc = get_defcfg_location(def_conf);
41c89ef3 5032 unsigned int conn = get_defcfg_connect(def_conf);
99ae28be
TI		 5033 if (conn == AC_JACK_PORT_NONE)
5034 return INPUT_PIN_ATTR_UNUSED;
41c89ef3
TI		 5035 /* Windows may claim the internal mic to be BOTH, too */
5036 if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH)
99ae28be 5037 return INPUT_PIN_ATTR_INT;
41c89ef3 5038 if ((loc & 0x30) == AC_JACK_LOC_INTERNAL)
99ae28be 5039 return INPUT_PIN_ATTR_INT;
a1c98515 5040 if ((loc & 0x30) == AC_JACK_LOC_SEPARATE)
99ae28be 5041 return INPUT_PIN_ATTR_DOCK;
a1c98515 5042 if (loc == AC_JACK_LOC_REAR)
99ae28be 5043 return INPUT_PIN_ATTR_REAR;
a1c98515 5044 if (loc == AC_JACK_LOC_FRONT)
99ae28be
TI		 5045 return INPUT_PIN_ATTR_FRONT;
5046 return INPUT_PIN_ATTR_NORMAL;
a1c98515 5047}
99ae28be 5048EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
a1c98515 5049
990061c2
TI		 5050/**
5051 * hda_get_input_pin_label - Give a label for the given input pin
5052 *
5053 * When check_location is true, the function checks the pin location
5054 * for mic and line-in pins, and set an appropriate prefix like "Front",
5055 * "Rear", "Internal".
5056 */
5057
04f5ade6
TI		 5058static const char *hda_get_input_pin_label(struct hda_codec *codec,
5059 hda_nid_t pin, bool check_location)
10a20af7 5060{
a1c98515 5061 unsigned int def_conf;
ea734963 5062 static const char * const mic_names[] = {
a1c98515
TI		 5063 "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic",
5064 };
99ae28be 5065 int attr;
10a20af7
TI		 5066
5067 def_conf = snd_hda_codec_get_pincfg(codec, pin);
10a20af7
TI		 5068
5069 switch (get_defcfg_device(def_conf)) {
5070 case AC_JACK_MIC_IN:
5071 if (!check_location)
5072 return "Mic";
99ae28be
TI		 5073 attr = snd_hda_get_input_pin_attr(def_conf);
5074 if (!attr)
5075 return "None";
5076 return mic_names[attr - 1];
10a20af7
TI		 5077 case AC_JACK_LINE_IN:
5078 if (!check_location)
5079 return "Line";
99ae28be
TI		 5080 attr = snd_hda_get_input_pin_attr(def_conf);
5081 if (!attr)
5082 return "None";
5083 if (attr == INPUT_PIN_ATTR_DOCK)
5084 return "Dock Line";
5085 return "Line";
10a20af7
TI		 5086 case AC_JACK_AUX:
5087 return "Aux";
5088 case AC_JACK_CD:
5089 return "CD";
5090 case AC_JACK_SPDIF_IN:
5091 return "SPDIF In";
5092 case AC_JACK_DIG_OTHER_IN:
5093 return "Digital In";
5094 default:
5095 return "Misc";
5096 }
5097}
4a471b7d 5098
a1c98515
TI		 5099/* Check whether the location prefix needs to be added to the label.
5100 * If all mic-jacks are in the same location (e.g. rear panel), we don't
5101 * have to put "Front" prefix to each label. In such a case, returns false.
5102 */
5103static int check_mic_location_need(struct hda_codec *codec,
5104 const struct auto_pin_cfg *cfg,
5105 int input)
5106{
5107 unsigned int defc;
5108 int i, attr, attr2;
5109
5110 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin);
99ae28be 5111 attr = snd_hda_get_input_pin_attr(defc);
a1c98515 5112 /* for internal or docking mics, we need locations */
99ae28be 5113 if (attr <= INPUT_PIN_ATTR_NORMAL)
a1c98515
TI		 5114 return 1;
5115
5116 attr = 0;
5117 for (i = 0; i < cfg->num_inputs; i++) {
5118 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin);
99ae28be
TI		 5119 attr2 = snd_hda_get_input_pin_attr(defc);
5120 if (attr2 >= INPUT_PIN_ATTR_NORMAL) {
a1c98515
TI		 5121 if (attr && attr != attr2)
5122 return 1; /* different locations found */
5123 attr = attr2;
5124 }
5125 }
5126 return 0;
5127}
5128
990061c2
TI		 5129/**
5130 * hda_get_autocfg_input_label - Get a label for the given input
5131 *
5132 * Get a label for the given input pin defined by the autocfg item.
5133 * Unlike hda_get_input_pin_label(), this function checks all inputs
5134 * defined in autocfg and avoids the redundant mic/line prefix as much as
5135 * possible.
5136 */
10a20af7
TI		 5137const char *hda_get_autocfg_input_label(struct hda_codec *codec,
5138 const struct auto_pin_cfg *cfg,
5139 int input)
d7b1ae9d
TI		 5140{
5141 int type = cfg->inputs[input].type;
10a20af7 5142 int has_multiple_pins = 0;
d7b1ae9d 5143
10a20af7
TI		 5144 if ((input > 0 && cfg->inputs[input - 1].type == type) ||
5145 (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type))
5146 has_multiple_pins = 1;
a1c98515
TI		 5147 if (has_multiple_pins && type == AUTO_PIN_MIC)
5148 has_multiple_pins &= check_mic_location_need(codec, cfg, input);
10a20af7
TI		 5149 return hda_get_input_pin_label(codec, cfg->inputs[input].pin,
5150 has_multiple_pins);
5151}
5152EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
5153
358b6e62
TI		 5154/* return the position of NID in the list, or -1 if not found */
5155static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
5156{
5157 int i;
5158 for (i = 0; i < nums; i++)
5159 if (list[i] == nid)
5160 return i;
5161 return -1;
5162}
5163
201e06ff
TI		 5164/* get a unique suffix or an index number */
5165static const char *check_output_sfx(hda_nid_t nid, const hda_nid_t *pins,
5166 int num_pins, int *indexp)
5167{
5168 static const char * const channel_sfx[] = {
d6018bb5 5169 " Front", " Surround", " CLFE", " Side"
201e06ff
TI		 5170 };
5171 int i;
5172
358b6e62
TI		 5173 i = find_idx_in_nid_list(nid, pins, num_pins);
5174 if (i < 0)
5175 return NULL;
5176 if (num_pins == 1)
5177 return "";
5178 if (num_pins > ARRAY_SIZE(channel_sfx)) {
5179 if (indexp)
5180 *indexp = i;
5181 return "";
201e06ff 5182 }
358b6e62 5183 return channel_sfx[i];
201e06ff
TI		 5184}
5185
5186static int fill_audio_out_name(struct hda_codec *codec, hda_nid_t nid,
5187 const struct auto_pin_cfg *cfg,
5188 const char *name, char *label, int maxlen,
5189 int *indexp)
5190{
5191 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5192 int attr = snd_hda_get_input_pin_attr(def_conf);
5193 const char *pfx = "", *sfx = "";
5194
5195 /* handle as a speaker if it's a fixed line-out */
e49a3434 5196 if (!strcmp(name, "Line Out") && attr == INPUT_PIN_ATTR_INT)
201e06ff
TI		 5197 name = "Speaker";
5198 /* check the location */
5199 switch (attr) {
5200 case INPUT_PIN_ATTR_DOCK:
5201 pfx = "Dock ";
5202 break;
5203 case INPUT_PIN_ATTR_FRONT:
5204 pfx = "Front ";
5205 break;
5206 }
5207 if (cfg) {
5208 /* try to give a unique suffix if needed */
5209 sfx = check_output_sfx(nid, cfg->line_out_pins, cfg->line_outs,
5210 indexp);
201e06ff
TI		 5211 if (!sfx)
5212 sfx = check_output_sfx(nid, cfg->speaker_pins, cfg->speaker_outs,
5213 indexp);
358b6e62
TI		 5214 if (!sfx) {
5215 /* don't add channel suffix for Headphone controls */
5216 int idx = find_idx_in_nid_list(nid, cfg->hp_pins,
5217 cfg->hp_outs);
5218 if (idx >= 0)
5219 *indexp = idx;
201e06ff 5220 sfx = "";
358b6e62 5221 }
201e06ff
TI		 5222 }
5223 snprintf(label, maxlen, "%s%s%s", pfx, name, sfx);
5224 return 1;
5225}
5226
04f5ade6
TI		 5227/**
5228 * snd_hda_get_pin_label - Get a label for the given I/O pin
5229 *
5230 * Get a label for the given pin. This function works for both input and
5231 * output pins. When @cfg is given as non-NULL, the function tries to get
5232 * an optimized label using hda_get_autocfg_input_label().
201e06ff
TI		 5233 *
5234 * This function tries to give a unique label string for the pin as much as
5235 * possible. For example, when the multiple line-outs are present, it adds
5236 * the channel suffix like "Front", "Surround", etc (only when @cfg is given).
5237 * If no unique name with a suffix is available and @indexp is non-NULL, the
5238 * index number is stored in the pointer.
04f5ade6 5239 */
201e06ff
TI		 5240int snd_hda_get_pin_label(struct hda_codec *codec, hda_nid_t nid,
5241 const struct auto_pin_cfg *cfg,
5242 char *label, int maxlen, int *indexp)
04f5ade6
TI		 5243{
5244 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
201e06ff 5245 const char *name = NULL;
04f5ade6
TI		 5246 int i;
5247
201e06ff
TI		 5248 if (indexp)
5249 *indexp = 0;
04f5ade6 5250 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
201e06ff 5251 return 0;
04f5ade6 5252
04f5ade6
TI		 5253 switch (get_defcfg_device(def_conf)) {
5254 case AC_JACK_LINE_OUT:
e49a3434 5255 return fill_audio_out_name(codec, nid, cfg, "Line Out",
201e06ff 5256 label, maxlen, indexp);
04f5ade6 5257 case AC_JACK_SPEAKER:
201e06ff
TI		 5258 return fill_audio_out_name(codec, nid, cfg, "Speaker",
5259 label, maxlen, indexp);
04f5ade6 5260 case AC_JACK_HP_OUT:
201e06ff
TI		 5261 return fill_audio_out_name(codec, nid, cfg, "Headphone",
5262 label, maxlen, indexp);
04f5ade6
TI		 5263 case AC_JACK_SPDIF_OUT:
5264 case AC_JACK_DIG_OTHER_OUT:
5265 if (get_defcfg_location(def_conf) == AC_JACK_LOC_HDMI)
201e06ff 5266 name = "HDMI";
04f5ade6 5267 else
201e06ff
TI		 5268 name = "SPDIF";
5269 if (cfg && indexp) {
358b6e62
TI		 5270 i = find_idx_in_nid_list(nid, cfg->dig_out_pins,
5271 cfg->dig_outs);
5272 if (i >= 0)
5273 *indexp = i;
201e06ff
TI		 5274 }
5275 break;
5276 default:
5277 if (cfg) {
5278 for (i = 0; i < cfg->num_inputs; i++) {
5279 if (cfg->inputs[i].pin != nid)
5280 continue;
5281 name = hda_get_autocfg_input_label(codec, cfg, i);
5282 if (name)
5283 break;
5284 }
5285 }
5286 if (!name)
5287 name = hda_get_input_pin_label(codec, nid, true);
5288 break;
04f5ade6 5289 }
201e06ff
TI		 5290 if (!name)
5291 return 0;
5292 strlcpy(label, name, maxlen);
5293 return 1;
04f5ade6
TI		 5294}
5295EXPORT_SYMBOL_HDA(snd_hda_get_pin_label);
5296
990061c2
TI		 5297/**
5298 * snd_hda_add_imux_item - Add an item to input_mux
5299 *
5300 * When the same label is used already in the existing items, the number
5301 * suffix is appended to the label. This label index number is stored
5302 * to type_idx when non-NULL pointer is given.
5303 */
10a20af7
TI		 5304int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5305 int index, int *type_idx)
5306{
5307 int i, label_idx = 0;
5308 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5309 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5310 return -EINVAL;
5311 }
5312 for (i = 0; i < imux->num_items; i++) {
5313 if (!strncmp(label, imux->items[i].label, strlen(label)))
5314 label_idx++;
d7b1ae9d 5315 }
10a20af7
TI		 5316 if (type_idx)
5317 *type_idx = label_idx;
5318 if (label_idx > 0)
5319 snprintf(imux->items[imux->num_items].label,
5320 sizeof(imux->items[imux->num_items].label),
5321 "%s %d", label, label_idx);
b5786e85 5322 else
10a20af7
TI		 5323 strlcpy(imux->items[imux->num_items].label, label,
5324 sizeof(imux->items[imux->num_items].label));
5325 imux->items[imux->num_items].index = index;
5326 imux->num_items++;
5327 return 0;
d7b1ae9d 5328}
10a20af7 5329EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
d7b1ae9d 5330
4a471b7d 5331
1da177e4
LT		 5332#ifdef CONFIG_PM
5333/*
5334 * power management
5335 */
5336
5337/**
5338 * snd_hda_suspend - suspend the codecs
5339 * @bus: the HDA bus
1da177e4
LT		 5340 *
5341 * Returns 0 if successful.
5342 */
8dd78330 5343int snd_hda_suspend(struct hda_bus *bus)
1da177e4 5344{
0ba21762 5345 struct hda_codec *codec;
1da177e4 5346
0ba21762 5347 list_for_each_entry(codec, &bus->codec_list, list) {
e581f3db
TI		 5348 if (hda_codec_is_power_on(codec))
5349 hda_call_codec_suspend(codec);
785f857d
TI		 5350 else /* forcibly change the power to D3 even if not used */
5351 hda_set_power_state(codec,
5352 codec->afg ? codec->afg : codec->mfg,
5353 AC_PWRST_D3);
e581f3db
TI		 5354 if (codec->patch_ops.post_suspend)
5355 codec->patch_ops.post_suspend(codec);
1da177e4
LT		 5356 }
5357 return 0;
5358}
ff7a3267 5359EXPORT_SYMBOL_HDA(snd_hda_suspend);
1da177e4
LT		 5360
5361/**
5362 * snd_hda_resume - resume the codecs
5363 * @bus: the HDA bus
1da177e4
LT		 5364 *
5365 * Returns 0 if successful.
cb53c626 5366 *
25985edc 5367 * This function is defined only when POWER_SAVE isn't set.
cb53c626 5368 * In the power-save mode, the codec is resumed dynamically.
1da177e4
LT		 5369 */
5370int snd_hda_resume(struct hda_bus *bus)
5371{
0ba21762 5372 struct hda_codec *codec;
1da177e4 5373
0ba21762 5374 list_for_each_entry(codec, &bus->codec_list, list) {
d02667e6
VK		 5375 if (codec->patch_ops.pre_resume)
5376 codec->patch_ops.pre_resume(codec);
d804ad92
ML		 5377 if (snd_hda_codec_needs_resume(codec))
5378 hda_call_codec_resume(codec);
1da177e4 5379 }
1da177e4
LT		 5380 return 0;
5381}
ff7a3267 5382EXPORT_SYMBOL_HDA(snd_hda_resume);
1289e9e8 5383#endif /* CONFIG_PM */
b2e18597
TI		 5384
5385/*
5386 * generic arrays
5387 */
5388
d5191e50
TI		 5389/**
5390 * snd_array_new - get a new element from the given array
5391 * @array: the array object
28aedaf7 5392 *
d5191e50
TI		 5393 * Get a new element from the given array. If it exceeds the
5394 * pre-allocated array size, re-allocate the array.
5395 *
5396 * Returns NULL if allocation failed.
b2e18597
TI		 5397 */
5398void *snd_array_new(struct snd_array *array)
5399{
5400 if (array->used >= array->alloced) {
5401 int num = array->alloced + array->alloc_align;
3101ba03 5402 int size = (num + 1) * array->elem_size;
00ef9610 5403 int oldsize = array->alloced * array->elem_size;
b910d9ae
TI		 5404 void *nlist;
5405 if (snd_BUG_ON(num >= 4096))
5406 return NULL;
3101ba03 5407 nlist = krealloc(array->list, size, GFP_KERNEL);
b2e18597
TI		 5408 if (!nlist)
5409 return NULL;
00ef9610 5410 memset(nlist + oldsize, 0, size - oldsize);
b2e18597
TI		 5411 array->list = nlist;
5412 array->alloced = num;
5413 }
f43aa025 5414 return snd_array_elem(array, array->used++);
b2e18597 5415}
ff7a3267 5416EXPORT_SYMBOL_HDA(snd_array_new);
b2e18597 5417
d5191e50
TI		 5418/**
5419 * snd_array_free - free the given array elements
5420 * @array: the array object
5421 */
b2e18597
TI		 5422void snd_array_free(struct snd_array *array)
5423{
5424 kfree(array->list);
5425 array->used = 0;
5426 array->alloced = 0;
5427 array->list = NULL;
5428}
ff7a3267 5429EXPORT_SYMBOL_HDA(snd_array_free);
b2022266 5430
d5191e50
TI		 5431/**
5432 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5433 * @pcm: PCM caps bits
5434 * @buf: the string buffer to write
5435 * @buflen: the max buffer length
5436 *
5437 * used by hda_proc.c and hda_eld.c
5438 */
b2022266
TI		 5439void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5440{
5441 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5442 int i, j;
5443
5444 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5445 if (pcm & (AC_SUPPCM_BITS_8 << i))
5446 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5447
5448 buf[j] = '\0'; /* necessary when j == 0 */
5449}
ff7a3267 5450EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
1289e9e8
TI		 5451
5452MODULE_DESCRIPTION("HDA codec core");
5453MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)