ALSA: hda - Add expose_enum_ctl flag to snd_hda_add_vmaster_hook()
[linux-2.6.git] / sound / pci / hda / hda_codec.c
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
22 #include <linux/mm.h>
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/slab.h>
26 #include <linux/pci.h>
27 #include <linux/mutex.h>
28 #include <linux/module.h>
29 #include <sound/core.h>
30 #include "hda_codec.h"
31 #include <sound/asoundef.h>
32 #include <sound/tlv.h>
33 #include <sound/initval.h>
34 #include <sound/jack.h>
35 #include "hda_local.h"
36 #include "hda_beep.h"
37 #include "hda_jack.h"
38 #include <sound/hda_hwdep.h>
39
40 #define CREATE_TRACE_POINTS
41 #include "hda_trace.h"
42
43 /*
44  * vendor / preset table
45  */
46
47 struct hda_vendor_id {
48         unsigned int id;
49         const char *name;
50 };
51
52 /* codec vendor labels */
53 static struct hda_vendor_id hda_vendor_ids[] = {
54         { 0x1002, "ATI" },
55         { 0x1013, "Cirrus Logic" },
56         { 0x1057, "Motorola" },
57         { 0x1095, "Silicon Image" },
58         { 0x10de, "Nvidia" },
59         { 0x10ec, "Realtek" },
60         { 0x1102, "Creative" },
61         { 0x1106, "VIA" },
62         { 0x111d, "IDT" },
63         { 0x11c1, "LSI" },
64         { 0x11d4, "Analog Devices" },
65         { 0x13f6, "C-Media" },
66         { 0x14f1, "Conexant" },
67         { 0x17e8, "Chrontel" },
68         { 0x1854, "LG" },
69         { 0x1aec, "Wolfson Microelectronics" },
70         { 0x434d, "C-Media" },
71         { 0x8086, "Intel" },
72         { 0x8384, "SigmaTel" },
73         {} /* terminator */
74 };
75
76 static DEFINE_MUTEX(preset_mutex);
77 static LIST_HEAD(hda_preset_tables);
78
79 int 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 }
86 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
87
88 int 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 }
95 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
96
97 #ifdef CONFIG_SND_HDA_POWER_SAVE
98 static void hda_power_work(struct work_struct *work);
99 static void hda_keep_power_on(struct hda_codec *codec);
100 #define hda_codec_is_power_on(codec)    ((codec)->power_on)
101 #else
102 static inline void hda_keep_power_on(struct hda_codec *codec) {}
103 #define hda_codec_is_power_on(codec)    1
104 #endif
105
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  */
113 const 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 }
138 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
139
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  */
147 const 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 }
153 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
154
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  */
162 const 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 }
174 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
175
176 /*
177  * Compose a 32bit command word to be sent to the HD-audio controller
178  */
179 static inline unsigned int
180 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
181                unsigned int verb, unsigned int parm)
182 {
183         u32 val;
184
185         if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
186             (verb & ~0xfff) || (parm & ~0xffff)) {
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;
193         val |= (u32)direct << 27;
194         val |= (u32)nid << 20;
195         val |= verb << 8;
196         val |= parm;
197         return val;
198 }
199
200 /*
201  * Send and receive a verb
202  */
203 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
204                            unsigned int *res)
205 {
206         struct hda_bus *bus = codec->bus;
207         int err;
208
209         if (cmd == ~0)
210                 return -1;
211
212         if (res)
213                 *res = -1;
214  again:
215         snd_hda_power_up(codec);
216         mutex_lock(&bus->cmd_mutex);
217         trace_hda_send_cmd(codec, cmd);
218         err = bus->ops.command(bus, cmd);
219         if (!err && res) {
220                 *res = bus->ops.get_response(bus, codec->addr);
221                 trace_hda_get_response(codec, *res);
222         }
223         mutex_unlock(&bus->cmd_mutex);
224         snd_hda_power_down(codec);
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");
229                         trace_hda_bus_reset(bus);
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;
237         return err;
238 }
239
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  */
252 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
253                                 int direct,
254                                 unsigned int verb, unsigned int parm)
255 {
256         unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
257         unsigned int res;
258         if (codec_exec_verb(codec, cmd, &res))
259                 return -1;
260         return res;
261 }
262 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
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  */
276 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
277                          unsigned int verb, unsigned int parm)
278 {
279         unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
280         unsigned int res;
281         return codec_exec_verb(codec, cmd,
282                                codec->bus->sync_write ? &res : NULL);
283 }
284 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
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  */
294 void 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 }
299 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
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  */
310 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
311                           hda_nid_t *start_id)
312 {
313         unsigned int parm;
314
315         parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
316         if (parm == -1)
317                 return 0;
318         *start_id = (parm >> 16) & 0x7fff;
319         return (int)(parm & 0x7fff);
320 }
321 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
322
323 /* look up the cached results */
324 static 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 }
336
337 /**
338  * snd_hda_get_conn_list - get connection list
339  * @codec: the HDA codec
340  * @nid: NID to parse
341  * @listp: the pointer to store NID list
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  */
348 int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
349                           const hda_nid_t **listp)
350 {
351         struct snd_array *array = &codec->conn_lists;
352         int len, err;
353         hda_nid_t list[HDA_MAX_CONNECTIONS];
354         hda_nid_t *p;
355         bool added = false;
356
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];
364         }
365         if (snd_BUG_ON(added))
366                 return -EINVAL;
367
368         /* read the connection and add to the cache */
369         len = snd_hda_get_raw_connections(codec, nid, list, HDA_MAX_CONNECTIONS);
370         if (len < 0)
371                 return len;
372         err = snd_hda_override_conn_list(codec, nid, len, list);
373         if (err < 0)
374                 return err;
375         added = true;
376         goto again;
377 }
378 EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
379
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  */
392 int 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);
397
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;
408 }
409 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
410
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  */
422 int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
423                                 hda_nid_t *conn_list, int max_conns)
424 {
425         unsigned int parm;
426         int i, conn_len, conns;
427         unsigned int shift, num_elems, mask;
428         unsigned int wcaps;
429         hda_nid_t prev_nid;
430
431         if (snd_BUG_ON(!conn_list || max_conns <= 0))
432                 return -EINVAL;
433
434         wcaps = get_wcaps(codec, nid);
435         if (!(wcaps & AC_WCAP_CONN_LIST) &&
436             get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
437                 return 0;
438
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;
450         mask = (1 << (shift-1)) - 1;
451
452         if (!conn_len)
453                 return 0; /* no connection */
454
455         if (conn_len == 1) {
456                 /* single connection */
457                 parm = snd_hda_codec_read(codec, nid, 0,
458                                           AC_VERB_GET_CONNECT_LIST, 0);
459                 if (parm == -1 && codec->bus->rirb_error)
460                         return -EIO;
461                 conn_list[0] = parm & mask;
462                 return 1;
463         }
464
465         /* multi connection */
466         conns = 0;
467         prev_nid = 0;
468         for (i = 0; i < conn_len; i++) {
469                 int range_val;
470                 hda_nid_t val, n;
471
472                 if (i % num_elems == 0) {
473                         parm = snd_hda_codec_read(codec, nid, 0,
474                                                   AC_VERB_GET_CONNECT_LIST, i);
475                         if (parm == -1 && codec->bus->rirb_error)
476                                 return -EIO;
477                 }
478                 range_val = !!(parm & (1 << (shift-1))); /* ranges */
479                 val = parm & mask;
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                 }
486                 parm >>= shift;
487                 if (range_val) {
488                         /* ranges between the previous and this one */
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);
493                                 continue;
494                         }
495                         for (n = prev_nid + 1; n <= val; n++) {
496                                 if (conns >= max_conns) {
497                                         snd_printk(KERN_ERR "hda_codec: "
498                                                    "Too many connections %d for NID 0x%x\n",
499                                                    conns, nid);
500                                         return -EINVAL;
501                                 }
502                                 conn_list[conns++] = n;
503                         }
504                 } else {
505                         if (conns >= max_conns) {
506                                 snd_printk(KERN_ERR "hda_codec: "
507                                            "Too many connections %d for NID 0x%x\n",
508                                            conns, nid);
509                                 return -EINVAL;
510                         }
511                         conn_list[conns++] = val;
512                 }
513                 prev_nid = val;
514         }
515         return conns;
516 }
517
518 static 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
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  */
539 int 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 }
562 EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
563
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  */
575 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
576                            hda_nid_t nid, int recursive)
577 {
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;
590         }
591         recursive++;
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;
596                 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
597                         return i;
598         }
599         return -1;
600 }
601 EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
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  */
615 int 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
620         trace_hda_unsol_event(bus, res, res_ex);
621         unsol = bus->unsol;
622         if (!unsol)
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
632         queue_work(bus->workq, &unsol->work);
633
634         return 0;
635 }
636 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
637
638 /*
639  * process queued unsolicited events
640  */
641 static void process_unsol_events(struct work_struct *work)
642 {
643         struct hda_bus_unsolicited *unsol =
644                 container_of(work, struct hda_bus_unsolicited, work);
645         struct hda_bus *bus = unsol->bus;
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];
655                 if (!(caddr & (1 << 4))) /* no unsolicited event? */
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  */
666 static int init_unsol_queue(struct hda_bus *bus)
667 {
668         struct hda_bus_unsolicited *unsol;
669
670         if (bus->unsol) /* already initialized */
671                 return 0;
672
673         unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
674         if (!unsol) {
675                 snd_printk(KERN_ERR "hda_codec: "
676                            "can't allocate unsolicited queue\n");
677                 return -ENOMEM;
678         }
679         INIT_WORK(&unsol->work, process_unsol_events);
680         unsol->bus = bus;
681         bus->unsol = unsol;
682         return 0;
683 }
684
685 /*
686  * destructor
687  */
688 static void snd_hda_codec_free(struct hda_codec *codec);
689
690 static int snd_hda_bus_free(struct hda_bus *bus)
691 {
692         struct hda_codec *codec, *n;
693
694         if (!bus)
695                 return 0;
696         if (bus->workq)
697                 flush_workqueue(bus->workq);
698         if (bus->unsol)
699                 kfree(bus->unsol);
700         list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
701                 snd_hda_codec_free(codec);
702         }
703         if (bus->ops.private_free)
704                 bus->ops.private_free(bus);
705         if (bus->workq)
706                 destroy_workqueue(bus->workq);
707         kfree(bus);
708         return 0;
709 }
710
711 static int snd_hda_bus_dev_free(struct snd_device *device)
712 {
713         struct hda_bus *bus = device->device_data;
714         bus->shutdown = 1;
715         return snd_hda_bus_free(bus);
716 }
717
718 #ifdef CONFIG_SND_HDA_HWDEP
719 static 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);
725                 snd_hda_hwdep_add_power_sysfs(codec);
726         }
727         return 0;
728 }
729 #else
730 #define snd_hda_bus_dev_register        NULL
731 #endif
732
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  */
741 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
742                               const struct hda_bus_template *temp,
743                               struct hda_bus **busp)
744 {
745         struct hda_bus *bus;
746         int err;
747         static struct snd_device_ops dev_ops = {
748                 .dev_register = snd_hda_bus_dev_register,
749                 .dev_free = snd_hda_bus_dev_free,
750         };
751
752         if (snd_BUG_ON(!temp))
753                 return -EINVAL;
754         if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
755                 return -EINVAL;
756
757         if (busp)
758                 *busp = NULL;
759
760         bus = kzalloc(sizeof(*bus), GFP_KERNEL);
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;
770         bus->power_save = temp->power_save;
771         bus->ops = temp->ops;
772
773         mutex_init(&bus->cmd_mutex);
774         mutex_init(&bus->prepare_mutex);
775         INIT_LIST_HEAD(&bus->codec_list);
776
777         snprintf(bus->workq_name, sizeof(bus->workq_name),
778                  "hd-audio%d", card->number);
779         bus->workq = create_singlethread_workqueue(bus->workq_name);
780         if (!bus->workq) {
781                 snd_printk(KERN_ERR "cannot create workqueue %s\n",
782                            bus->workq_name);
783                 kfree(bus);
784                 return -ENOMEM;
785         }
786
787         err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
788         if (err < 0) {
789                 snd_hda_bus_free(bus);
790                 return err;
791         }
792         if (busp)
793                 *busp = bus;
794         return 0;
795 }
796 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
797
798 #ifdef CONFIG_SND_HDA_GENERIC
799 #define is_generic_config(codec) \
800         (codec->modelname && !strcmp(codec->modelname, "generic"))
801 #else
802 #define is_generic_config(codec)        0
803 #endif
804
805 #ifdef MODULE
806 #define HDA_MODREQ_MAX_COUNT    2       /* two request_modules()'s */
807 #else
808 #define HDA_MODREQ_MAX_COUNT    0       /* all presets are statically linked */
809 #endif
810
811 /*
812  * find a matching codec preset
813  */
814 static const struct hda_codec_preset *
815 find_codec_preset(struct hda_codec *codec)
816 {
817         struct hda_codec_preset_list *tbl;
818         const struct hda_codec_preset *preset;
819         int mod_requested = 0;
820
821         if (is_generic_config(codec))
822                 return NULL; /* use the generic parser */
823
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++) {
832                         u32 mask = preset->mask;
833                         if (preset->afg && preset->afg != codec->afg)
834                                 continue;
835                         if (preset->mfg && preset->mfg != codec->mfg)
836                                 continue;
837                         if (!mask)
838                                 mask = ~0;
839                         if (preset->id == (codec->vendor_id & mask) &&
840                             (!preset->rev ||
841                              preset->rev == codec->revision_id)) {
842                                 mutex_unlock(&preset_mutex);
843                                 codec->owner = tbl->owner;
844                                 return preset;
845                         }
846                 }
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;
862         }
863         return NULL;
864 }
865
866 /*
867  * get_codec_name - store the codec name
868  */
869 static int get_codec_name(struct hda_codec *codec)
870 {
871         const struct hda_vendor_id *c;
872         const char *vendor = NULL;
873         u16 vendor_id = codec->vendor_id >> 16;
874         char tmp[16];
875
876         if (codec->vendor_name)
877                 goto get_chip_name;
878
879         for (c = hda_vendor_ids; c->id; c++) {
880                 if (c->id == vendor_id) {
881                         vendor = c->name;
882                         break;
883                 }
884         }
885         if (!vendor) {
886                 sprintf(tmp, "Generic %04x", vendor_id);
887                 vendor = tmp;
888         }
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
897         if (codec->preset && codec->preset->name)
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)
904                 return -ENOMEM;
905         return 0;
906 }
907
908 /*
909  * look for an AFG and MFG nodes
910  */
911 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
912 {
913         int i, total_nodes, function_id;
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++) {
918                 function_id = snd_hda_param_read(codec, nid,
919                                                 AC_PAR_FUNCTION_TYPE);
920                 switch (function_id & 0xff) {
921                 case AC_GRP_AUDIO_FUNCTION:
922                         codec->afg = nid;
923                         codec->afg_function_id = function_id & 0xff;
924                         codec->afg_unsol = (function_id >> 8) & 1;
925                         break;
926                 case AC_GRP_MODEM_FUNCTION:
927                         codec->mfg = nid;
928                         codec->mfg_function_id = function_id & 0xff;
929                         codec->mfg_unsol = (function_id >> 8) & 1;
930                         break;
931                 default:
932                         break;
933                 }
934         }
935 }
936
937 /*
938  * read widget caps for each widget and store in cache
939  */
940 static 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);
948         if (!codec->wcaps)
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
957 /* read all pin default configurations and save codec->init_pins */
958 static 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);
966                 unsigned int wid_type = get_wcaps_type(wcaps);
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);
975                 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
976                                                AC_VERB_GET_PIN_WIDGET_CONTROL,
977                                                0);
978         }
979         return 0;
980 }
981
982 /* look up the given pin config list and return the item matching with NID */
983 static 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 */
997 static 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  */
1012 int 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;
1016         unsigned int oldcfg;
1017
1018         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1019                 return -EINVAL;
1020
1021         oldcfg = snd_hda_codec_get_pincfg(codec, nid);
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;
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);
1037         return 0;
1038 }
1039
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  */
1050 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1051                              hda_nid_t nid, unsigned int cfg)
1052 {
1053         return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
1054 }
1055 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
1056
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  */
1066 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1067 {
1068         struct hda_pincfg *pin;
1069
1070 #ifdef CONFIG_SND_HDA_HWDEP
1071         pin = look_up_pincfg(codec, &codec->user_pins, nid);
1072         if (pin)
1073                 return pin->cfg;
1074 #endif
1075         pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1076         if (pin)
1077                 return pin->cfg;
1078         pin = look_up_pincfg(codec, &codec->init_pins, nid);
1079         if (pin)
1080                 return pin->cfg;
1081         return 0;
1082 }
1083 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
1084
1085 /* restore all current pin configs */
1086 static 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 }
1095
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  */
1103 void snd_hda_shutup_pins(struct hda_codec *codec)
1104 {
1105         int i;
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;
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         }
1117         codec->pins_shutup = 1;
1118 }
1119 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
1120
1121 #ifdef CONFIG_PM
1122 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1123 static 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 }
1138 #endif
1139
1140 static void init_hda_cache(struct hda_cache_rec *cache,
1141                            unsigned int record_size);
1142 static void free_hda_cache(struct hda_cache_rec *cache);
1143
1144 /* restore the initial pin cfgs and release all pincfg lists */
1145 static void restore_init_pincfgs(struct hda_codec *codec)
1146 {
1147         /* first free driver_pins and user_pins, then call restore_pincfg
1148          * so that only the values in init_pins are restored
1149          */
1150         snd_array_free(&codec->driver_pins);
1151 #ifdef CONFIG_SND_HDA_HWDEP
1152         snd_array_free(&codec->user_pins);
1153 #endif
1154         restore_pincfgs(codec);
1155         snd_array_free(&codec->init_pins);
1156 }
1157
1158 /*
1159  * audio-converter setup caches
1160  */
1161 struct 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 */
1171 static struct hda_cvt_setup *
1172 get_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
1188 /*
1189  * codec destructor
1190  */
1191 static void snd_hda_codec_free(struct hda_codec *codec)
1192 {
1193         if (!codec)
1194                 return;
1195         restore_init_pincfgs(codec);
1196 #ifdef CONFIG_SND_HDA_POWER_SAVE
1197         cancel_delayed_work(&codec->power_work);
1198         flush_workqueue(codec->bus->workq);
1199 #endif
1200         list_del(&codec->list);
1201         snd_array_free(&codec->mixers);
1202         snd_array_free(&codec->nids);
1203         snd_array_free(&codec->conn_lists);
1204         snd_array_free(&codec->spdif_out);
1205         codec->bus->caddr_tbl[codec->addr] = NULL;
1206         if (codec->patch_ops.free)
1207                 codec->patch_ops.free(codec);
1208         module_put(codec->owner);
1209         free_hda_cache(&codec->amp_cache);
1210         free_hda_cache(&codec->cmd_cache);
1211         kfree(codec->vendor_name);
1212         kfree(codec->chip_name);
1213         kfree(codec->modelname);
1214         kfree(codec->wcaps);
1215         kfree(codec);
1216 }
1217
1218 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1219                                 unsigned int power_state);
1220
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  */
1229 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
1230                                 unsigned int codec_addr,
1231                                 struct hda_codec **codecp)
1232 {
1233         struct hda_codec *codec;
1234         char component[31];
1235         int err;
1236
1237         if (snd_BUG_ON(!bus))
1238                 return -EINVAL;
1239         if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1240                 return -EINVAL;
1241
1242         if (bus->caddr_tbl[codec_addr]) {
1243                 snd_printk(KERN_ERR "hda_codec: "
1244                            "address 0x%x is already occupied\n", codec_addr);
1245                 return -EBUSY;
1246         }
1247
1248         codec = kzalloc(sizeof(*codec), GFP_KERNEL);
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;
1256         mutex_init(&codec->spdif_mutex);
1257         mutex_init(&codec->control_mutex);
1258         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1259         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1260         snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1261         snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1262         snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1263         snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1264         snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1265         snd_array_init(&codec->conn_lists, sizeof(hda_nid_t), 64);
1266         snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
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         }
1274
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
1284         list_add_tail(&codec->list, &bus->codec_list);
1285         bus->caddr_tbl[codec_addr] = codec;
1286
1287         codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1288                                               AC_PAR_VENDOR_ID);
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);
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);
1299
1300         setup_fg_nodes(codec);
1301         if (!codec->afg && !codec->mfg) {
1302                 snd_printdd("hda_codec: no AFG or MFG node found\n");
1303                 err = -ENODEV;
1304                 goto error;
1305         }
1306
1307         err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1308         if (err < 0) {
1309                 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1310                 goto error;
1311         }
1312         err = read_pin_defaults(codec);
1313         if (err < 0)
1314                 goto error;
1315
1316         if (!codec->subsystem_id) {
1317                 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
1318                 codec->subsystem_id =
1319                         snd_hda_codec_read(codec, nid, 0,
1320                                            AC_VERB_GET_SUBSYSTEM_ID, 0);
1321         }
1322
1323         /* power-up all before initialization */
1324         hda_set_power_state(codec,
1325                             codec->afg ? codec->afg : codec->mfg,
1326                             AC_PWRST_D0);
1327
1328         snd_hda_codec_proc_new(codec);
1329
1330         snd_hda_create_hwdep(codec);
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;
1339
1340  error:
1341         snd_hda_codec_free(codec);
1342         return err;
1343 }
1344 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1345
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  */
1355 int snd_hda_codec_configure(struct hda_codec *codec)
1356 {
1357         int err;
1358
1359         codec->preset = find_codec_preset(codec);
1360         if (!codec->vendor_name || !codec->chip_name) {
1361                 err = get_codec_name(codec);
1362                 if (err < 0)
1363                         return err;
1364         }
1365
1366         if (is_generic_config(codec)) {
1367                 err = snd_hda_parse_generic_codec(codec);
1368                 goto patched;
1369         }
1370         if (codec->preset && codec->preset->patch) {
1371                 err = codec->preset->patch(codec);
1372                 goto patched;
1373         }
1374
1375         /* call the default parser */
1376         err = snd_hda_parse_generic_codec(codec);
1377         if (err < 0)
1378                 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1379
1380  patched:
1381         if (!err && codec->patch_ops.unsol_event)
1382                 err = init_unsol_queue(codec->bus);
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);
1388         return err;
1389 }
1390 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
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  */
1400 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1401                                 u32 stream_tag,
1402                                 int channel_id, int format)
1403 {
1404         struct hda_codec *c;
1405         struct hda_cvt_setup *p;
1406         unsigned int oldval, newval;
1407         int type;
1408         int i;
1409
1410         if (!nid)
1411                 return;
1412
1413         snd_printdd("hda_codec_setup_stream: "
1414                     "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1415                     nid, stream_tag, channel_id, format);
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 */
1446         type = get_wcaps_type(get_wcaps(codec, nid));
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);
1450                         if (!p->active && p->stream_tag == stream_tag &&
1451                             get_wcaps_type(get_wcaps(c, p->nid)) == type)
1452                                 p->dirty = 1;
1453                 }
1454         }
1455 }
1456 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1457
1458 static void really_cleanup_stream(struct hda_codec *codec,
1459                                   struct hda_cvt_setup *q);
1460
1461 /**
1462  * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1463  * @codec: the CODEC to clean up
1464  * @nid: the NID to clean up
1465  * @do_now: really clean up the stream instead of clearing the active flag
1466  */
1467 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1468                                     int do_now)
1469 {
1470         struct hda_cvt_setup *p;
1471
1472         if (!nid)
1473                 return;
1474
1475         if (codec->no_sticky_stream)
1476                 do_now = 1;
1477
1478         snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1479         p = get_hda_cvt_setup(codec, nid);
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         }
1490 }
1491 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1492
1493 static void really_cleanup_stream(struct hda_codec *codec,
1494                                   struct hda_cvt_setup *q)
1495 {
1496         hda_nid_t nid = q->nid;
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 );
1502         memset(q, 0, sizeof(*q));
1503         q->nid = nid;
1504 }
1505
1506 /* clean up the all conflicting obsolete streams */
1507 static void purify_inactive_streams(struct hda_codec *codec)
1508 {
1509         struct hda_codec *c;
1510         int i;
1511
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                 }
1519         }
1520 }
1521
1522 #ifdef CONFIG_PM
1523 /* clean up all streams; called from suspend */
1524 static 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         }
1533 }
1534 #endif
1535
1536 /*
1537  * amp access functions
1538  */
1539
1540 /* FIXME: more better hash key? */
1541 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1542 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1543 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1544 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1545 #define INFO_AMP_CAPS   (1<<0)
1546 #define INFO_AMP_VOL(ch)        (1 << (1 + (ch)))
1547
1548 /* initialize the hash table */
1549 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1550                                      unsigned int record_size)
1551 {
1552         memset(cache, 0, sizeof(*cache));
1553         memset(cache->hash, 0xff, sizeof(cache->hash));
1554         snd_array_init(&cache->buf, record_size, 64);
1555 }
1556
1557 static void free_hda_cache(struct hda_cache_rec *cache)
1558 {
1559         snd_array_free(&cache->buf);
1560 }
1561
1562 /* query the hash.  allocate an entry if not found. */
1563 static struct hda_cache_head  *get_hash(struct hda_cache_rec *cache, u32 key)
1564 {
1565         u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1566         u16 cur = cache->hash[idx];
1567         struct hda_cache_head *info;
1568
1569         while (cur != 0xffff) {
1570                 info = snd_array_elem(&cache->buf, cur);
1571                 if (info->key == key)
1572                         return info;
1573                 cur = info->next;
1574         }
1575         return NULL;
1576 }
1577
1578 /* query the hash.  allocate an entry if not found. */
1579 static 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         }
1596         return info;
1597 }
1598
1599 /* query and allocate an amp hash entry */
1600 static inline struct hda_amp_info *
1601 get_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
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.
1617  */
1618 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1619 {
1620         struct hda_amp_info *info;
1621
1622         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1623         if (!info)
1624                 return 0;
1625         if (!(info->head.val & INFO_AMP_CAPS)) {
1626                 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1627                         nid = codec->afg;
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);
1632                 if (info->amp_caps)
1633                         info->head.val |= INFO_AMP_CAPS;
1634         }
1635         return info->amp_caps;
1636 }
1637 EXPORT_SYMBOL_HDA(query_amp_caps);
1638
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  */
1652 int 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;
1661         info->head.val |= INFO_AMP_CAPS;
1662         return 0;
1663 }
1664 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1665
1666 static unsigned int
1667 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1668                 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1669 {
1670         struct hda_amp_info *info;
1671
1672         info = get_alloc_amp_hash(codec, key);
1673         if (!info)
1674                 return 0;
1675         if (!info->head.val) {
1676                 info->head.val |= INFO_AMP_CAPS;
1677                 info->amp_caps = func(codec, nid);
1678         }
1679         return info->amp_caps;
1680 }
1681
1682 static 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
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  */
1698 u32 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 }
1703 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1704
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  */
1715 int 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 }
1726 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1727
1728 /*
1729  * read the current volume to info
1730  * if the cache exists, read the cache value.
1731  */
1732 static 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)
1735 {
1736         u32 val, parm;
1737
1738         if (info->head.val & INFO_AMP_VOL(ch))
1739                 return info->vol[ch];
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;
1744         val = snd_hda_codec_read(codec, nid, 0,
1745                                  AC_VERB_GET_AMP_GAIN_MUTE, parm);
1746         info->vol[ch] = val & 0xff;
1747         info->head.val |= INFO_AMP_VOL(ch);
1748         return info->vol[ch];
1749 }
1750
1751 /*
1752  * write the current volume in info to the h/w and update the cache
1753  */
1754 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1755                          hda_nid_t nid, int ch, int direction, int index,
1756                          int val)
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;
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;
1768         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1769         info->vol[ch] = val;
1770 }
1771
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.
1781  */
1782 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1783                            int direction, int index)
1784 {
1785         struct hda_amp_info *info;
1786         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1787         if (!info)
1788                 return 0;
1789         return get_vol_mute(codec, info, nid, ch, direction, index);
1790 }
1791 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1792
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.
1805  */
1806 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1807                              int direction, int idx, int mask, int val)
1808 {
1809         struct hda_amp_info *info;
1810
1811         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1812         if (!info)
1813                 return 0;
1814         if (snd_BUG_ON(mask & ~0xff))
1815                 mask &= 0xff;
1816         val &= mask;
1817         val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1818         if (info->vol[ch] == val)
1819                 return 0;
1820         put_vol_mute(codec, info, nid, ch, direction, idx, val);
1821         return 1;
1822 }
1823 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1824
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.
1836  */
1837 int 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;
1841
1842         if (snd_BUG_ON(mask & ~0xff))
1843                 mask &= 0xff;
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 }
1849 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1850
1851 #ifdef CONFIG_PM
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  */
1858 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1859 {
1860         struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1861         int i;
1862
1863         for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
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 }
1880 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1881 #endif /* CONFIG_PM */
1882
1883 static 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
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  */
1900 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1901                                   struct snd_ctl_elem_info *uinfo)
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);
1907         unsigned int ofs = get_amp_offset(kcontrol);
1908
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) {
1914                 printk(KERN_WARNING "hda_codec: "
1915                        "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1916                        kcontrol->id.name);
1917                 return -EINVAL;
1918         }
1919         return 0;
1920 }
1921 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1922
1923
1924 static inline unsigned int
1925 read_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
1938 static inline int
1939 update_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 {
1943         unsigned int maxval;
1944
1945         if (val > 0)
1946                 val += ofs;
1947         /* ofs = 0: raw max value */
1948         maxval = get_amp_max_value(codec, nid, dir, 0);
1949         if (val > maxval)
1950                 val = maxval;
1951         return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1952                                         HDA_AMP_VOLMASK, val);
1953 }
1954
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  */
1961 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1962                                  struct snd_ctl_elem_value *ucontrol)
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);
1969         unsigned int ofs = get_amp_offset(kcontrol);
1970         long *valp = ucontrol->value.integer.value;
1971
1972         if (chs & 1)
1973                 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1974         if (chs & 2)
1975                 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1976         return 0;
1977 }
1978 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1979
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  */
1986 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1987                                  struct snd_ctl_elem_value *ucontrol)
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);
1994         unsigned int ofs = get_amp_offset(kcontrol);
1995         long *valp = ucontrol->value.integer.value;
1996         int change = 0;
1997
1998         snd_hda_power_up(codec);
1999         if (chs & 1) {
2000                 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2001                 valp++;
2002         }
2003         if (chs & 2)
2004                 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2005         snd_hda_power_down(codec);
2006         return change;
2007 }
2008 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
2009
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  */
2016 int 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);
2022         unsigned int ofs = get_amp_offset(kcontrol);
2023         bool min_mute = get_amp_min_mute(kcontrol);
2024         u32 caps, val1, val2;
2025
2026         if (size < 4 * sizeof(unsigned int))
2027                 return -ENOMEM;
2028         caps = query_amp_caps(codec, nid, dir);
2029         val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2030         val2 = (val2 + 1) * 25;
2031         val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2032         val1 += ofs;
2033         val1 = ((int)val1) * ((int)val2);
2034         if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
2035                 val2 |= TLV_DB_SCALE_MUTE;
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 }
2046 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
2047
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.
2058  */
2059 void 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 }
2074 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2075
2076 /* find a mixer control element with the given name */
2077 static struct snd_kcontrol *
2078 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
2079                         const char *name, int idx)
2080 {
2081         struct snd_ctl_elem_id id;
2082         memset(&id, 0, sizeof(id));
2083         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2084         id.index = idx;
2085         if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2086                 return NULL;
2087         strcpy(id.name, name);
2088         return snd_ctl_find_id(codec->bus->card, &id);
2089 }
2090
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  */
2098 struct 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 }
2103 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
2104
2105 static 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
2115 /**
2116  * snd_hda_ctl_add - Add a control element and assign to the codec
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
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.
2133  */
2134 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2135                     struct snd_kcontrol *kctl)
2136 {
2137         int err;
2138         unsigned short flags = 0;
2139         struct hda_nid_item *item;
2140
2141         if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2142                 flags |= HDA_NID_ITEM_AMP;
2143                 if (nid == 0)
2144                         nid = get_amp_nid_(kctl->private_value);
2145         }
2146         if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2147                 nid = kctl->id.subdevice & 0xffff;
2148         if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2149                 kctl->id.subdevice = 0;
2150         err = snd_ctl_add(codec->bus->card, kctl);
2151         if (err < 0)
2152                 return err;
2153         item = snd_array_new(&codec->mixers);
2154         if (!item)
2155                 return -ENOMEM;
2156         item->kctl = kctl;
2157         item->nid = nid;
2158         item->flags = flags;
2159         return 0;
2160 }
2161 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
2162
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  */
2174 int 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         }
2188         printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2189                kctl->id.name, kctl->id.index, index);
2190         return -EINVAL;
2191 }
2192 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2193
2194 /**
2195  * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2196  * @codec: HD-audio codec
2197  */
2198 void snd_hda_ctls_clear(struct hda_codec *codec)
2199 {
2200         int i;
2201         struct hda_nid_item *items = codec->mixers.list;
2202         for (i = 0; i < codec->mixers.used; i++)
2203                 snd_ctl_remove(codec->bus->card, items[i].kctl);
2204         snd_array_free(&codec->mixers);
2205         snd_array_free(&codec->nids);
2206 }
2207
2208 /* pseudo device locking
2209  * toggle card->shutdown to allow/disallow the device access (as a hack)
2210  */
2211 static int hda_lock_devices(struct snd_card *card)
2212 {
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
2223 static 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
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  */
2240 int 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 */
2264
2265 #ifdef CONFIG_SND_HDA_POWER_SAVE
2266         cancel_delayed_work(&codec->power_work);
2267         flush_workqueue(codec->bus->workq);
2268 #endif
2269         snd_hda_ctls_clear(codec);
2270         /* relase PCMs */
2271         for (i = 0; i < codec->num_pcms; i++) {
2272                 if (codec->pcm_info[i].pcm) {
2273                         snd_device_free(card, codec->pcm_info[i].pcm);
2274                         clear_bit(codec->pcm_info[i].device,
2275                                   codec->bus->pcm_dev_bits);
2276                 }
2277         }
2278         if (codec->patch_ops.free)
2279                 codec->patch_ops.free(codec);
2280         snd_hda_jack_tbl_clear(codec);
2281         codec->proc_widget_hook = NULL;
2282         codec->spec = NULL;
2283         free_hda_cache(&codec->amp_cache);
2284         free_hda_cache(&codec->cmd_cache);
2285         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2286         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2287         /* free only driver_pins so that init_pins + user_pins are restored */
2288         snd_array_free(&codec->driver_pins);
2289         restore_pincfgs(codec);
2290         codec->num_pcms = 0;
2291         codec->pcm_info = NULL;
2292         codec->preset = NULL;
2293         memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2294         codec->slave_dig_outs = NULL;
2295         codec->spdif_status_reset = 0;
2296         module_put(codec->owner);
2297         codec->owner = NULL;
2298
2299         /* allow device access again */
2300         hda_unlock_devices(card);
2301         return 0;
2302 }
2303
2304 typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2305
2306 /* apply the function to all matching slave ctls in the mixer list */
2307 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2308                       const char *suffix, map_slave_func_t func, void *data) 
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++) {
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                         }
2328                         if (!strcmp(sctl->id.name, name)) {
2329                                 err = func(data, sctl);
2330                                 if (err)
2331                                         return err;
2332                                 break;
2333                         }
2334                 }
2335         }
2336         return 0;
2337 }
2338
2339 static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2340 {
2341         return 1;
2342 }
2343
2344 /* guess the value corresponding to 0dB */
2345 static 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) */
2366 static 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 */
2380 static 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 */
2389 static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2390 {
2391         return put_kctl_with_value(slave, 1);
2392 }
2393
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)
2400  * @suffix: suffix string to each slave name (optional)
2401  * @init_slave_vol: initialize slaves to unmute/0dB
2402  * @ctl_ret: store the vmaster kcontrol in return
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  */
2413 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2414                         unsigned int *tlv, const char * const *slaves,
2415                           const char *suffix, bool init_slave_vol,
2416                           struct snd_kcontrol **ctl_ret)
2417 {
2418         struct snd_kcontrol *kctl;
2419         int err;
2420
2421         if (ctl_ret)
2422                 *ctl_ret = NULL;
2423
2424         err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2425         if (err != 1) {
2426                 snd_printdd("No slave found for %s\n", name);
2427                 return 0;
2428         }
2429         kctl = snd_ctl_make_virtual_master(name, tlv);
2430         if (!kctl)
2431                 return -ENOMEM;
2432         err = snd_hda_ctl_add(codec, 0, kctl);
2433         if (err < 0)
2434                 return err;
2435
2436         err = map_slaves(codec, slaves, suffix,
2437                          (map_slave_func_t)snd_ctl_add_slave, kctl);
2438         if (err < 0)
2439                 return err;
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
2447         if (ctl_ret)
2448                 *ctl_ret = kctl;
2449         return 0;
2450 }
2451 EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
2452
2453 /*
2454  * mute-LED control using vmaster
2455  */
2456 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2457                                   struct snd_ctl_elem_info *uinfo)
2458 {
2459         static const char * const texts[] = {
2460                 "Off", "On", "Follow Master"
2461         };
2462         unsigned int index;
2463
2464         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2465         uinfo->count = 1;
2466         uinfo->value.enumerated.items = 3;
2467         index = uinfo->value.enumerated.item;
2468         if (index >= 3)
2469                 index = 2;
2470         strcpy(uinfo->value.enumerated.name, texts[index]);
2471         return 0;
2472 }
2473
2474 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2475                                  struct snd_ctl_elem_value *ucontrol)
2476 {
2477         struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2478         ucontrol->value.enumerated.item[0] = hook->mute_mode;
2479         return 0;
2480 }
2481
2482 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2483                                  struct snd_ctl_elem_value *ucontrol)
2484 {
2485         struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2486         unsigned int old_mode = hook->mute_mode;
2487
2488         hook->mute_mode = ucontrol->value.enumerated.item[0];
2489         if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2490                 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2491         if (old_mode == hook->mute_mode)
2492                 return 0;
2493         snd_hda_sync_vmaster_hook(hook);
2494         return 1;
2495 }
2496
2497 static struct snd_kcontrol_new vmaster_mute_mode = {
2498         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2499         .name = "Mute-LED Mode",
2500         .info = vmaster_mute_mode_info,
2501         .get = vmaster_mute_mode_get,
2502         .put = vmaster_mute_mode_put,
2503 };
2504
2505 /*
2506  * Add a mute-LED hook with the given vmaster switch kctl
2507  * "Mute-LED Mode" control is automatically created and associated with
2508  * the given hook.
2509  */
2510 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2511                              struct hda_vmaster_mute_hook *hook,
2512                              bool expose_enum_ctl)
2513 {
2514         struct snd_kcontrol *kctl;
2515
2516         if (!hook->hook || !hook->sw_kctl)
2517                 return 0;
2518         snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2519         hook->codec = codec;
2520         hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2521         if (!expose_enum_ctl)
2522                 return 0;
2523         kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2524         if (!kctl)
2525                 return -ENOMEM;
2526         return snd_hda_ctl_add(codec, 0, kctl);
2527 }
2528 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
2529
2530 /*
2531  * Call the hook with the current value for synchronization
2532  * Should be called in init callback
2533  */
2534 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2535 {
2536         if (!hook->hook || !hook->codec)
2537                 return;
2538         switch (hook->mute_mode) {
2539         case HDA_VMUTE_FOLLOW_MASTER:
2540                 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2541                 break;
2542         default:
2543                 hook->hook(hook->codec, hook->mute_mode);
2544                 break;
2545         }
2546 }
2547 EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
2548
2549
2550 /**
2551  * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2552  *
2553  * The control element is supposed to have the private_value field
2554  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2555  */
2556 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2557                                   struct snd_ctl_elem_info *uinfo)
2558 {
2559         int chs = get_amp_channels(kcontrol);
2560
2561         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2562         uinfo->count = chs == 3 ? 2 : 1;
2563         uinfo->value.integer.min = 0;
2564         uinfo->value.integer.max = 1;
2565         return 0;
2566 }
2567 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2568
2569 /**
2570  * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2571  *
2572  * The control element is supposed to have the private_value field
2573  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2574  */
2575 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2576                                  struct snd_ctl_elem_value *ucontrol)
2577 {
2578         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2579         hda_nid_t nid = get_amp_nid(kcontrol);
2580         int chs = get_amp_channels(kcontrol);
2581         int dir = get_amp_direction(kcontrol);
2582         int idx = get_amp_index(kcontrol);
2583         long *valp = ucontrol->value.integer.value;
2584
2585         if (chs & 1)
2586                 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2587                            HDA_AMP_MUTE) ? 0 : 1;
2588         if (chs & 2)
2589                 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2590                          HDA_AMP_MUTE) ? 0 : 1;
2591         return 0;
2592 }
2593 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2594
2595 /**
2596  * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2597  *
2598  * The control element is supposed to have the private_value field
2599  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2600  */
2601 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2602                                  struct snd_ctl_elem_value *ucontrol)
2603 {
2604         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2605         hda_nid_t nid = get_amp_nid(kcontrol);
2606         int chs = get_amp_channels(kcontrol);
2607         int dir = get_amp_direction(kcontrol);
2608         int idx = get_amp_index(kcontrol);
2609         long *valp = ucontrol->value.integer.value;
2610         int change = 0;
2611
2612         snd_hda_power_up(codec);
2613         if (chs & 1) {
2614                 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2615                                                   HDA_AMP_MUTE,
2616                                                   *valp ? 0 : HDA_AMP_MUTE);
2617                 valp++;
2618         }
2619         if (chs & 2)
2620                 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2621                                                    HDA_AMP_MUTE,
2622                                                    *valp ? 0 : HDA_AMP_MUTE);
2623         hda_call_check_power_status(codec, nid);
2624         snd_hda_power_down(codec);
2625         return change;
2626 }
2627 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2628
2629 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2630 /**
2631  * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2632  *
2633  * This function calls snd_hda_enable_beep_device(), which behaves differently
2634  * depending on beep_mode option.
2635  */
2636 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2637                                       struct snd_ctl_elem_value *ucontrol)
2638 {
2639         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2640         long *valp = ucontrol->value.integer.value;
2641
2642         snd_hda_enable_beep_device(codec, *valp);
2643         return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2644 }
2645 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
2646 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2647
2648 /*
2649  * bound volume controls
2650  *
2651  * bind multiple volumes (# indices, from 0)
2652  */
2653
2654 #define AMP_VAL_IDX_SHIFT       19
2655 #define AMP_VAL_IDX_MASK        (0x0f<<19)
2656
2657 /**
2658  * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2659  *
2660  * The control element is supposed to have the private_value field
2661  * set up via HDA_BIND_MUTE*() macros.
2662  */
2663 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2664                                   struct snd_ctl_elem_value *ucontrol)
2665 {
2666         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2667         unsigned long pval;
2668         int err;
2669
2670         mutex_lock(&codec->control_mutex);
2671         pval = kcontrol->private_value;
2672         kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2673         err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2674         kcontrol->private_value = pval;
2675         mutex_unlock(&codec->control_mutex);
2676         return err;
2677 }
2678 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2679
2680 /**
2681  * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2682  *
2683  * The control element is supposed to have the private_value field
2684  * set up via HDA_BIND_MUTE*() macros.
2685  */
2686 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2687                                   struct snd_ctl_elem_value *ucontrol)
2688 {
2689         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2690         unsigned long pval;
2691         int i, indices, err = 0, change = 0;
2692
2693         mutex_lock(&codec->control_mutex);
2694         pval = kcontrol->private_value;
2695         indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2696         for (i = 0; i < indices; i++) {
2697                 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2698                         (i << AMP_VAL_IDX_SHIFT);
2699                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2700                 if (err < 0)
2701                         break;
2702                 change |= err;
2703         }
2704         kcontrol->private_value = pval;
2705         mutex_unlock(&codec->control_mutex);
2706         return err < 0 ? err : change;
2707 }
2708 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2709
2710 /**
2711  * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2712  *
2713  * The control element is supposed to have the private_value field
2714  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2715  */
2716 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2717                                  struct snd_ctl_elem_info *uinfo)
2718 {
2719         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2720         struct hda_bind_ctls *c;
2721         int err;
2722
2723         mutex_lock(&codec->control_mutex);
2724         c = (struct hda_bind_ctls *)kcontrol->private_value;
2725         kcontrol->private_value = *c->values;
2726         err = c->ops->info(kcontrol, uinfo);
2727         kcontrol->private_value = (long)c;
2728         mutex_unlock(&codec->control_mutex);
2729         return err;
2730 }
2731 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2732
2733 /**
2734  * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2735  *
2736  * The control element is supposed to have the private_value field
2737  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2738  */
2739 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2740                                 struct snd_ctl_elem_value *ucontrol)
2741 {
2742         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2743         struct hda_bind_ctls *c;
2744         int err;
2745
2746         mutex_lock(&codec->control_mutex);
2747         c = (struct hda_bind_ctls *)kcontrol->private_value;
2748         kcontrol->private_value = *c->values;
2749         err = c->ops->get(kcontrol, ucontrol);
2750         kcontrol->private_value = (long)c;
2751         mutex_unlock(&codec->control_mutex);
2752         return err;
2753 }
2754 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2755
2756 /**
2757  * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2758  *
2759  * The control element is supposed to have the private_value field
2760  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2761  */
2762 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2763                                 struct snd_ctl_elem_value *ucontrol)
2764 {
2765         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2766         struct hda_bind_ctls *c;
2767         unsigned long *vals;
2768         int err = 0, change = 0;
2769
2770         mutex_lock(&codec->control_mutex);
2771         c = (struct hda_bind_ctls *)kcontrol->private_value;
2772         for (vals = c->values; *vals; vals++) {
2773                 kcontrol->private_value = *vals;
2774                 err = c->ops->put(kcontrol, ucontrol);
2775                 if (err < 0)
2776                         break;
2777                 change |= err;
2778         }
2779         kcontrol->private_value = (long)c;
2780         mutex_unlock(&codec->control_mutex);
2781         return err < 0 ? err : change;
2782 }
2783 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2784
2785 /**
2786  * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2787  *
2788  * The control element is supposed to have the private_value field
2789  * set up via HDA_BIND_VOL() macro.
2790  */
2791 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2792                            unsigned int size, unsigned int __user *tlv)
2793 {
2794         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2795         struct hda_bind_ctls *c;
2796         int err;
2797
2798         mutex_lock(&codec->control_mutex);
2799         c = (struct hda_bind_ctls *)kcontrol->private_value;
2800         kcontrol->private_value = *c->values;
2801         err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2802         kcontrol->private_value = (long)c;
2803         mutex_unlock(&codec->control_mutex);
2804         return err;
2805 }
2806 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2807
2808 struct hda_ctl_ops snd_hda_bind_vol = {
2809         .info = snd_hda_mixer_amp_volume_info,
2810         .get = snd_hda_mixer_amp_volume_get,
2811         .put = snd_hda_mixer_amp_volume_put,
2812         .tlv = snd_hda_mixer_amp_tlv
2813 };
2814 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2815
2816 struct hda_ctl_ops snd_hda_bind_sw = {
2817         .info = snd_hda_mixer_amp_switch_info,
2818         .get = snd_hda_mixer_amp_switch_get,
2819         .put = snd_hda_mixer_amp_switch_put,
2820         .tlv = snd_hda_mixer_amp_tlv
2821 };
2822 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2823
2824 /*
2825  * SPDIF out controls
2826  */
2827
2828 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2829                                    struct snd_ctl_elem_info *uinfo)
2830 {
2831         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2832         uinfo->count = 1;
2833         return 0;
2834 }
2835
2836 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2837                                    struct snd_ctl_elem_value *ucontrol)
2838 {
2839         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2840                                            IEC958_AES0_NONAUDIO |
2841                                            IEC958_AES0_CON_EMPHASIS_5015 |
2842                                            IEC958_AES0_CON_NOT_COPYRIGHT;
2843         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2844                                            IEC958_AES1_CON_ORIGINAL;
2845         return 0;
2846 }
2847
2848 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2849                                    struct snd_ctl_elem_value *ucontrol)
2850 {
2851         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2852                                            IEC958_AES0_NONAUDIO |
2853                                            IEC958_AES0_PRO_EMPHASIS_5015;
2854         return 0;
2855 }
2856
2857 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2858                                      struct snd_ctl_elem_value *ucontrol)
2859 {
2860         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2861         int idx = kcontrol->private_value;
2862         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2863
2864         ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2865         ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2866         ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2867         ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2868
2869         return 0;
2870 }
2871
2872 /* convert from SPDIF status bits to HDA SPDIF bits
2873  * bit 0 (DigEn) is always set zero (to be filled later)
2874  */
2875 static unsigned short convert_from_spdif_status(unsigned int sbits)
2876 {
2877         unsigned short val = 0;
2878
2879         if (sbits & IEC958_AES0_PROFESSIONAL)
2880                 val |= AC_DIG1_PROFESSIONAL;
2881         if (sbits & IEC958_AES0_NONAUDIO)
2882                 val |= AC_DIG1_NONAUDIO;
2883         if (sbits & IEC958_AES0_PROFESSIONAL) {
2884                 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2885                     IEC958_AES0_PRO_EMPHASIS_5015)
2886                         val |= AC_DIG1_EMPHASIS;
2887         } else {
2888                 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2889                     IEC958_AES0_CON_EMPHASIS_5015)
2890                         val |= AC_DIG1_EMPHASIS;
2891                 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2892                         val |= AC_DIG1_COPYRIGHT;
2893                 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2894                         val |= AC_DIG1_LEVEL;
2895                 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2896         }
2897         return val;
2898 }
2899
2900 /* convert to SPDIF status bits from HDA SPDIF bits
2901  */
2902 static unsigned int convert_to_spdif_status(unsigned short val)
2903 {
2904         unsigned int sbits = 0;
2905
2906         if (val & AC_DIG1_NONAUDIO)
2907                 sbits |= IEC958_AES0_NONAUDIO;
2908         if (val & AC_DIG1_PROFESSIONAL)
2909                 sbits |= IEC958_AES0_PROFESSIONAL;
2910         if (sbits & IEC958_AES0_PROFESSIONAL) {
2911                 if (sbits & AC_DIG1_EMPHASIS)
2912                         sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2913         } else {
2914                 if (val & AC_DIG1_EMPHASIS)
2915                         sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2916                 if (!(val & AC_DIG1_COPYRIGHT))
2917                         sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2918                 if (val & AC_DIG1_LEVEL)
2919                         sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2920                 sbits |= val & (0x7f << 8);
2921         }
2922         return sbits;
2923 }
2924
2925 /* set digital convert verbs both for the given NID and its slaves */
2926 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2927                         int verb, int val)
2928 {
2929         const hda_nid_t *d;
2930
2931         snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2932         d = codec->slave_dig_outs;
2933         if (!d)
2934                 return;
2935         for (; *d; d++)
2936                 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2937 }
2938
2939 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2940                                        int dig1, int dig2)
2941 {
2942         if (dig1 != -1)
2943                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2944         if (dig2 != -1)
2945                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2946 }
2947
2948 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2949                                      struct snd_ctl_elem_value *ucontrol)
2950 {
2951         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2952         int idx = kcontrol->private_value;
2953         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2954         hda_nid_t nid = spdif->nid;
2955         unsigned short val;
2956         int change;
2957
2958         mutex_lock(&codec->spdif_mutex);
2959         spdif->status = ucontrol->value.iec958.status[0] |
2960                 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2961                 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2962                 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2963         val = convert_from_spdif_status(spdif->status);
2964         val |= spdif->ctls & 1;
2965         change = spdif->ctls != val;
2966         spdif->ctls = val;
2967         if (change && nid != (u16)-1)
2968                 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2969         mutex_unlock(&codec->spdif_mutex);
2970         return change;
2971 }
2972
2973 #define snd_hda_spdif_out_switch_info   snd_ctl_boolean_mono_info
2974
2975 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2976                                         struct snd_ctl_elem_value *ucontrol)
2977 {
2978         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2979         int idx = kcontrol->private_value;
2980         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2981
2982         ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
2983         return 0;
2984 }
2985
2986 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2987                                   int dig1, int dig2)
2988 {
2989         set_dig_out_convert(codec, nid, dig1, dig2);
2990         /* unmute amp switch (if any) */
2991         if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2992             (dig1 & AC_DIG1_ENABLE))
2993                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2994                                             HDA_AMP_MUTE, 0);
2995 }
2996
2997 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2998                                         struct snd_ctl_elem_value *ucontrol)
2999 {
3000         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3001         int idx = kcontrol->private_value;
3002         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
3003         hda_nid_t nid = spdif->nid;
3004         unsigned short val;
3005         int change;
3006
3007         mutex_lock(&codec->spdif_mutex);
3008         val = spdif->ctls & ~AC_DIG1_ENABLE;
3009         if (ucontrol->value.integer.value[0])
3010                 val |= AC_DIG1_ENABLE;
3011         change = spdif->ctls != val;
3012         spdif->ctls = val;
3013         if (change && nid != (u16)-1)
3014                 set_spdif_ctls(codec, nid, val & 0xff, -1);
3015         mutex_unlock(&codec->spdif_mutex);
3016         return change;
3017 }
3018
3019 static struct snd_kcontrol_new dig_mixes[] = {
3020         {
3021                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3022                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3023                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3024                 .info = snd_hda_spdif_mask_info,
3025                 .get = snd_hda_spdif_cmask_get,
3026         },
3027         {
3028                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3029                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3030                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3031                 .info = snd_hda_spdif_mask_info,
3032                 .get = snd_hda_spdif_pmask_get,
3033         },
3034         {
3035                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3036                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3037                 .info = snd_hda_spdif_mask_info,
3038                 .get = snd_hda_spdif_default_get,
3039                 .put = snd_hda_spdif_default_put,
3040         },
3041         {
3042                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3043                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3044                 .info = snd_hda_spdif_out_switch_info,
3045                 .get = snd_hda_spdif_out_switch_get,
3046                 .put = snd_hda_spdif_out_switch_put,
3047         },
3048         { } /* end */
3049 };
3050
3051 /**
3052  * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
3053  * @codec: the HDA codec
3054  * @nid: audio out widget NID
3055  *
3056  * Creates controls related with the SPDIF output.
3057  * Called from each patch supporting the SPDIF out.
3058  *
3059  * Returns 0 if successful, or a negative error code.
3060  */
3061 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
3062                                   hda_nid_t associated_nid,
3063                                   hda_nid_t cvt_nid)
3064 {
3065         int err;
3066         struct snd_kcontrol *kctl;
3067         struct snd_kcontrol_new *dig_mix;
3068         int idx;
3069         struct hda_spdif_out *spdif;
3070
3071         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
3072         if (idx < 0) {
3073                 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3074                 return -EBUSY;
3075         }
3076         spdif = snd_array_new(&codec->spdif_out);
3077         for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3078                 kctl = snd_ctl_new1(dig_mix, codec);
3079                 if (!kctl)
3080                         return -ENOMEM;
3081                 kctl->id.index = idx;
3082                 kctl->private_value = codec->spdif_out.used - 1;
3083                 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3084                 if (err < 0)
3085                         return err;
3086         }
3087         spdif->nid = cvt_nid;
3088         spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3089                                          AC_VERB_GET_DIGI_CONVERT_1, 0);
3090         spdif->status = convert_to_spdif_status(spdif->ctls);
3091         return 0;
3092 }
3093 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
3094
3095 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3096                                                hda_nid_t nid)
3097 {
3098         int i;
3099         for (i = 0; i < codec->spdif_out.used; i++) {
3100                 struct hda_spdif_out *spdif =
3101                                 snd_array_elem(&codec->spdif_out, i);
3102                 if (spdif->nid == nid)
3103                         return spdif;
3104         }
3105         return NULL;
3106 }
3107 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3108
3109 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3110 {
3111         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
3112
3113         mutex_lock(&codec->spdif_mutex);
3114         spdif->nid = (u16)-1;
3115         mutex_unlock(&codec->spdif_mutex);
3116 }
3117 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3118
3119 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3120 {
3121         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
3122         unsigned short val;
3123
3124         mutex_lock(&codec->spdif_mutex);
3125         if (spdif->nid != nid) {
3126                 spdif->nid = nid;
3127                 val = spdif->ctls;
3128                 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3129         }
3130         mutex_unlock(&codec->spdif_mutex);
3131 }
3132 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3133
3134 /*
3135  * SPDIF sharing with analog output
3136  */
3137 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3138                               struct snd_ctl_elem_value *ucontrol)
3139 {
3140         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3141         ucontrol->value.integer.value[0] = mout->share_spdif;
3142         return 0;
3143 }
3144
3145 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3146                               struct snd_ctl_elem_value *ucontrol)
3147 {
3148         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3149         mout->share_spdif = !!ucontrol->value.integer.value[0];
3150         return 0;
3151 }
3152
3153 static struct snd_kcontrol_new spdif_share_sw = {
3154         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3155         .name = "IEC958 Default PCM Playback Switch",
3156         .info = snd_ctl_boolean_mono_info,
3157         .get = spdif_share_sw_get,
3158         .put = spdif_share_sw_put,
3159 };
3160
3161 /**
3162  * snd_hda_create_spdif_share_sw - create Default PCM switch
3163  * @codec: the HDA codec
3164  * @mout: multi-out instance
3165  */
3166 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3167                                   struct hda_multi_out *mout)
3168 {
3169         if (!mout->dig_out_nid)
3170                 return 0;
3171         /* ATTENTION: here mout is passed as private_data, instead of codec */
3172         return snd_hda_ctl_add(codec, mout->dig_out_nid,
3173                               snd_ctl_new1(&spdif_share_sw, mout));
3174 }
3175 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3176
3177 /*
3178  * SPDIF input
3179  */
3180
3181 #define snd_hda_spdif_in_switch_info    snd_hda_spdif_out_switch_info
3182
3183 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3184                                        struct snd_ctl_elem_value *ucontrol)
3185 {
3186         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3187
3188         ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3189         return 0;
3190 }
3191
3192 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3193                                        struct snd_ctl_elem_value *ucontrol)
3194 {
3195         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3196         hda_nid_t nid = kcontrol->private_value;
3197         unsigned int val = !!ucontrol->value.integer.value[0];
3198         int change;
3199
3200         mutex_lock(&codec->spdif_mutex);
3201         change = codec->spdif_in_enable != val;
3202         if (change) {
3203                 codec->spdif_in_enable = val;
3204                 snd_hda_codec_write_cache(codec, nid, 0,
3205                                           AC_VERB_SET_DIGI_CONVERT_1, val);
3206         }
3207         mutex_unlock(&codec->spdif_mutex);
3208         return change;
3209 }
3210
3211 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3212                                        struct snd_ctl_elem_value *ucontrol)
3213 {
3214         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3215         hda_nid_t nid = kcontrol->private_value;
3216         unsigned short val;
3217         unsigned int sbits;
3218
3219         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3220         sbits = convert_to_spdif_status(val);
3221         ucontrol->value.iec958.status[0] = sbits;
3222         ucontrol->value.iec958.status[1] = sbits >> 8;
3223         ucontrol->value.iec958.status[2] = sbits >> 16;
3224         ucontrol->value.iec958.status[3] = sbits >> 24;
3225         return 0;
3226 }
3227
3228 static struct snd_kcontrol_new dig_in_ctls[] = {
3229         {
3230                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3231                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3232                 .info = snd_hda_spdif_in_switch_info,
3233                 .get = snd_hda_spdif_in_switch_get,
3234                 .put = snd_hda_spdif_in_switch_put,
3235         },
3236         {
3237                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3238                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3239                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3240                 .info = snd_hda_spdif_mask_info,
3241                 .get = snd_hda_spdif_in_status_get,
3242         },
3243         { } /* end */
3244 };
3245
3246 /**
3247  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3248  * @codec: the HDA codec
3249  * @nid: audio in widget NID
3250  *
3251  * Creates controls related with the SPDIF input.
3252  * Called from each patch supporting the SPDIF in.
3253  *
3254  * Returns 0 if successful, or a negative error code.
3255  */
3256 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3257 {
3258         int err;
3259         struct snd_kcontrol *kctl;
3260         struct snd_kcontrol_new *dig_mix;
3261         int idx;
3262
3263         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3264         if (idx < 0) {
3265                 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3266                 return -EBUSY;
3267         }
3268         for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3269                 kctl = snd_ctl_new1(dig_mix, codec);
3270                 if (!kctl)
3271                         return -ENOMEM;
3272                 kctl->private_value = nid;
3273                 err = snd_hda_ctl_add(codec, nid, kctl);
3274                 if (err < 0)
3275                         return err;
3276         }
3277         codec->spdif_in_enable =
3278                 snd_hda_codec_read(codec, nid, 0,
3279                                    AC_VERB_GET_DIGI_CONVERT_1, 0) &
3280                 AC_DIG1_ENABLE;
3281         return 0;
3282 }
3283 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3284
3285 #ifdef CONFIG_PM
3286 /*
3287  * command cache
3288  */
3289
3290 /* build a 32bit cache key with the widget id and the command parameter */
3291 #define build_cmd_cache_key(nid, verb)  ((verb << 8) | nid)
3292 #define get_cmd_cache_nid(key)          ((key) & 0xff)
3293 #define get_cmd_cache_cmd(key)          (((key) >> 8) & 0xffff)
3294
3295 /**
3296  * snd_hda_codec_write_cache - send a single command with caching
3297  * @codec: the HDA codec
3298  * @nid: NID to send the command
3299  * @direct: direct flag
3300  * @verb: the verb to send
3301  * @parm: the parameter for the verb
3302  *
3303  * Send a single command without waiting for response.
3304  *
3305  * Returns 0 if successful, or a negative error code.
3306  */
3307 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3308                               int direct, unsigned int verb, unsigned int parm)
3309 {
3310         int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3311         struct hda_cache_head *c;
3312         u32 key;
3313
3314         if (err < 0)
3315                 return err;
3316         /* parm may contain the verb stuff for get/set amp */
3317         verb = verb | (parm >> 8);
3318         parm &= 0xff;
3319         key = build_cmd_cache_key(nid, verb);
3320         mutex_lock(&codec->bus->cmd_mutex);
3321         c = get_alloc_hash(&codec->cmd_cache, key);
3322         if (c)
3323                 c->val = parm;
3324         mutex_unlock(&codec->bus->cmd_mutex);
3325         return 0;
3326 }
3327 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3328
3329 /**
3330  * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3331  * @codec: the HDA codec
3332  * @nid: NID to send the command
3333  * @direct: direct flag
3334  * @verb: the verb to send
3335  * @parm: the parameter for the verb
3336  *
3337  * This function works like snd_hda_codec_write_cache(), but it doesn't send
3338  * command if the parameter is already identical with the cached value.
3339  * If not, it sends the command and refreshes the cache.
3340  *
3341  * Returns 0 if successful, or a negative error code.
3342  */
3343 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3344                                int direct, unsigned int verb, unsigned int parm)
3345 {
3346         struct hda_cache_head *c;
3347         u32 key;
3348
3349         /* parm may contain the verb stuff for get/set amp */
3350         verb = verb | (parm >> 8);
3351         parm &= 0xff;
3352         key = build_cmd_cache_key(nid, verb);
3353         mutex_lock(&codec->bus->cmd_mutex);
3354         c = get_hash(&codec->cmd_cache, key);
3355         if (c && c->val == parm) {
3356                 mutex_unlock(&codec->bus->cmd_mutex);
3357                 return 0;
3358         }
3359         mutex_unlock(&codec->bus->cmd_mutex);
3360         return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3361 }
3362 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3363
3364 /**
3365  * snd_hda_codec_resume_cache - Resume the all commands from the cache
3366  * @codec: HD-audio codec
3367  *
3368  * Execute all verbs recorded in the command caches to resume.
3369  */
3370 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3371 {
3372         struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
3373         int i;
3374
3375         for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
3376                 u32 key = buffer->key;
3377                 if (!key)
3378                         continue;
3379                 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3380                                     get_cmd_cache_cmd(key), buffer->val);
3381         }
3382 }
3383 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3384
3385 /**
3386  * snd_hda_sequence_write_cache - sequence writes with caching
3387  * @codec: the HDA codec
3388  * @seq: VERB array to send
3389  *
3390  * Send the commands sequentially from the given array.
3391  * Thte commands are recorded on cache for power-save and resume.
3392  * The array must be terminated with NID=0.
3393  */
3394 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3395                                   const struct hda_verb *seq)
3396 {
3397         for (; seq->nid; seq++)
3398                 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3399                                           seq->param);
3400 }
3401 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3402 #endif /* CONFIG_PM */
3403
3404 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3405                                     unsigned int power_state,
3406                                     bool eapd_workaround)
3407 {
3408         hda_nid_t nid = codec->start_nid;
3409         int i;
3410
3411         for (i = 0; i < codec->num_nodes; i++, nid++) {
3412                 unsigned int wcaps = get_wcaps(codec, nid);
3413                 if (!(wcaps & AC_WCAP_POWER))
3414                         continue;
3415                 /* don't power down the widget if it controls eapd and
3416                  * EAPD_BTLENABLE is set.
3417                  */
3418                 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3419                     get_wcaps_type(wcaps) == AC_WID_PIN &&
3420                     (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3421                         int eapd = snd_hda_codec_read(codec, nid, 0,
3422                                                 AC_VERB_GET_EAPD_BTLENABLE, 0);
3423                         if (eapd & 0x02)
3424                                 continue;
3425                 }
3426                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3427                                     power_state);
3428         }
3429
3430         if (power_state == AC_PWRST_D0) {
3431                 unsigned long end_time;
3432                 int state;
3433                 /* wait until the codec reachs to D0 */
3434                 end_time = jiffies + msecs_to_jiffies(500);
3435                 do {
3436                         state = snd_hda_codec_read(codec, fg, 0,
3437                                                    AC_VERB_GET_POWER_STATE, 0);
3438                         if (state == power_state)
3439                                 break;
3440                         msleep(1);
3441                 } while (time_after_eq(end_time, jiffies));
3442         }
3443 }
3444 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3445
3446 /*
3447  * set power state of the codec
3448  */
3449 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3450                                 unsigned int power_state)
3451 {
3452         if (codec->patch_ops.set_power_state) {
3453                 codec->patch_ops.set_power_state(codec, fg, power_state);
3454                 return;
3455         }
3456
3457         /* this delay seems necessary to avoid click noise at power-down */
3458         if (power_state == AC_PWRST_D3)
3459                 msleep(100);
3460         snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3461                             power_state);
3462         snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3463 }
3464
3465 #ifdef CONFIG_SND_HDA_HWDEP
3466 /* execute additional init verbs */
3467 static void hda_exec_init_verbs(struct hda_codec *codec)
3468 {
3469         if (codec->init_verbs.list)
3470                 snd_hda_sequence_write(codec, codec->init_verbs.list);
3471 }
3472 #else
3473 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3474 #endif
3475
3476 #ifdef CONFIG_PM
3477 /*
3478  * call suspend and power-down; used both from PM and power-save
3479  */
3480 static void hda_call_codec_suspend(struct hda_codec *codec)
3481 {
3482         if (codec->patch_ops.suspend)
3483                 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
3484         hda_cleanup_all_streams(codec);
3485         hda_set_power_state(codec,
3486                             codec->afg ? codec->afg : codec->mfg,
3487                             AC_PWRST_D3);
3488 #ifdef CONFIG_SND_HDA_POWER_SAVE
3489         snd_hda_update_power_acct(codec);
3490         cancel_delayed_work(&codec->power_work);
3491         codec->power_on = 0;
3492         codec->power_transition = 0;
3493         codec->power_jiffies = jiffies;
3494 #endif
3495 }
3496
3497 /*
3498  * kick up codec; used both from PM and power-save
3499  */
3500 static void hda_call_codec_resume(struct hda_codec *codec)
3501 {
3502         hda_set_power_state(codec,
3503                             codec->afg ? codec->afg : codec->mfg,
3504                             AC_PWRST_D0);
3505         restore_pincfgs(codec); /* restore all current pin configs */
3506         restore_shutup_pins(codec);
3507         hda_exec_init_verbs(codec);
3508         snd_hda_jack_set_dirty_all(codec);
3509         if (codec->patch_ops.resume)
3510                 codec->patch_ops.resume(codec);
3511         else {
3512                 if (codec->patch_ops.init)
3513                         codec->patch_ops.init(codec);
3514                 snd_hda_codec_resume_amp(codec);
3515                 snd_hda_codec_resume_cache(codec);
3516         }
3517 }
3518 #endif /* CONFIG_PM */
3519
3520
3521 /**
3522  * snd_hda_build_controls - build mixer controls
3523  * @bus: the BUS
3524  *
3525  * Creates mixer controls for each codec included in the bus.
3526  *
3527  * Returns 0 if successful, otherwise a negative error code.
3528  */
3529 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
3530 {
3531         struct hda_codec *codec;
3532
3533         list_for_each_entry(codec, &bus->codec_list, list) {
3534                 int err = snd_hda_codec_build_controls(codec);
3535                 if (err < 0) {
3536                         printk(KERN_ERR "hda_codec: cannot build controls "
3537                                "for #%d (error %d)\n", codec->addr, err);
3538                         err = snd_hda_codec_reset(codec);
3539                         if (err < 0) {
3540                                 printk(KERN_ERR
3541                                        "hda_codec: cannot revert codec\n");
3542                                 return err;
3543                         }
3544                 }
3545         }
3546         return 0;
3547 }
3548 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3549
3550 int snd_hda_codec_build_controls(struct hda_codec *codec)
3551 {
3552         int err = 0;
3553         hda_exec_init_verbs(codec);
3554         /* continue to initialize... */
3555         if (codec->patch_ops.init)
3556                 err = codec->patch_ops.init(codec);
3557         if (!err && codec->patch_ops.build_controls)
3558                 err = codec->patch_ops.build_controls(codec);
3559         if (err < 0)
3560                 return err;
3561         return 0;
3562 }
3563
3564 /*
3565  * stream formats
3566  */
3567 struct hda_rate_tbl {
3568         unsigned int hz;
3569         unsigned int alsa_bits;
3570         unsigned int hda_fmt;
3571 };
3572
3573 /* rate = base * mult / div */
3574 #define HDA_RATE(base, mult, div) \
3575         (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3576          (((div) - 1) << AC_FMT_DIV_SHIFT))
3577
3578 static struct hda_rate_tbl rate_bits[] = {
3579         /* rate in Hz, ALSA rate bitmask, HDA format value */
3580
3581         /* autodetected value used in snd_hda_query_supported_pcm */
3582         { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3583         { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3584         { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3585         { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3586         { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3587         { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3588         { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3589         { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3590         { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3591         { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3592         { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3593 #define AC_PAR_PCM_RATE_BITS    11
3594         /* up to bits 10, 384kHZ isn't supported properly */
3595
3596         /* not autodetected value */
3597         { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3598
3599         { 0 } /* terminator */
3600 };
3601
3602 /**
3603  * snd_hda_calc_stream_format - calculate format bitset
3604  * @rate: the sample rate
3605  * @channels: the number of channels
3606  * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3607  * @maxbps: the max. bps
3608  *
3609  * Calculate the format bitset from the given rate, channels and th PCM format.
3610  *
3611  * Return zero if invalid.
3612  */
3613 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3614                                         unsigned int channels,
3615                                         unsigned int format,
3616                                         unsigned int maxbps,
3617                                         unsigned short spdif_ctls)
3618 {
3619         int i;
3620         unsigned int val = 0;
3621
3622         for (i = 0; rate_bits[i].hz; i++)
3623                 if (rate_bits[i].hz == rate) {
3624                         val = rate_bits[i].hda_fmt;
3625                         break;
3626                 }
3627         if (!rate_bits[i].hz) {
3628                 snd_printdd("invalid rate %d\n", rate);
3629                 return 0;
3630         }
3631
3632         if (channels == 0 || channels > 8) {
3633                 snd_printdd("invalid channels %d\n", channels);
3634                 return 0;
3635         }
3636         val |= channels - 1;
3637
3638         switch (snd_pcm_format_width(format)) {
3639         case 8:
3640                 val |= AC_FMT_BITS_8;
3641                 break;
3642         case 16:
3643                 val |= AC_FMT_BITS_16;
3644                 break;
3645         case 20:
3646         case 24:
3647         case 32:
3648                 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3649                         val |= AC_FMT_BITS_32;
3650                 else if (maxbps >= 24)
3651                         val |= AC_FMT_BITS_24;
3652                 else
3653                         val |= AC_FMT_BITS_20;
3654                 break;
3655         default:
3656                 snd_printdd("invalid format width %d\n",
3657                             snd_pcm_format_width(format));
3658                 return 0;
3659         }
3660
3661         if (spdif_ctls & AC_DIG1_NONAUDIO)
3662                 val |= AC_FMT_TYPE_NON_PCM;
3663
3664         return val;
3665 }
3666 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3667
3668 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3669 {
3670         unsigned int val = 0;
3671         if (nid != codec->afg &&
3672             (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3673                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3674         if (!val || val == -1)
3675                 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3676         if (!val || val == -1)
3677                 return 0;
3678         return val;
3679 }
3680
3681 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3682 {
3683         return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3684                                get_pcm_param);
3685 }
3686
3687 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3688 {
3689         unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3690         if (!streams || streams == -1)
3691                 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3692         if (!streams || streams == -1)
3693                 return 0;
3694         return streams;
3695 }
3696
3697 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3698 {
3699         return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3700                                get_stream_param);
3701 }
3702
3703 /**
3704  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3705  * @codec: the HDA codec
3706  * @nid: NID to query
3707  * @ratesp: the pointer to store the detected rate bitflags
3708  * @formatsp: the pointer to store the detected formats
3709  * @bpsp: the pointer to store the detected format widths
3710  *
3711  * Queries the supported PCM rates and formats.  The NULL @ratesp, @formatsp
3712  * or @bsps argument is ignored.
3713  *
3714  * Returns 0 if successful, otherwise a negative error code.
3715  */
3716 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3717                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3718 {
3719         unsigned int i, val, wcaps;
3720
3721         wcaps = get_wcaps(codec, nid);
3722         val = query_pcm_param(codec, nid);
3723
3724         if (ratesp) {
3725                 u32 rates = 0;
3726                 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3727                         if (val & (1 << i))
3728                                 rates |= rate_bits[i].alsa_bits;
3729                 }
3730                 if (rates == 0) {
3731                         snd_printk(KERN_ERR "hda_codec: rates == 0 "
3732                                    "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3733                                         nid, val,
3734                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3735                         return -EIO;
3736                 }
3737                 *ratesp = rates;
3738         }
3739
3740         if (formatsp || bpsp) {
3741                 u64 formats = 0;
3742                 unsigned int streams, bps;
3743
3744                 streams = query_stream_param(codec, nid);
3745                 if (!streams)
3746                         return -EIO;
3747
3748                 bps = 0;
3749                 if (streams & AC_SUPFMT_PCM) {
3750                         if (val & AC_SUPPCM_BITS_8) {
3751                                 formats |= SNDRV_PCM_FMTBIT_U8;
3752                                 bps = 8;
3753                         }
3754                         if (val & AC_SUPPCM_BITS_16) {
3755                                 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3756                                 bps = 16;
3757                         }
3758                         if (wcaps & AC_WCAP_DIGITAL) {
3759                                 if (val & AC_SUPPCM_BITS_32)
3760                                         formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3761                                 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3762                                         formats |= SNDRV_PCM_FMTBIT_S32_LE;
3763                                 if (val & AC_SUPPCM_BITS_24)
3764                                         bps = 24;
3765                                 else if (val & AC_SUPPCM_BITS_20)
3766                                         bps = 20;
3767                         } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3768                                           AC_SUPPCM_BITS_32)) {
3769                                 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3770                                 if (val & AC_SUPPCM_BITS_32)
3771                                         bps = 32;
3772                                 else if (val & AC_SUPPCM_BITS_24)
3773                                         bps = 24;
3774                                 else if (val & AC_SUPPCM_BITS_20)
3775                                         bps = 20;
3776                         }
3777                 }
3778                 if (streams & AC_SUPFMT_FLOAT32) {
3779                         formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3780                         if (!bps)
3781                                 bps = 32;
3782                 }
3783                 if (streams == AC_SUPFMT_AC3) {
3784                         /* should be exclusive */
3785                         /* temporary hack: we have still no proper support
3786                          * for the direct AC3 stream...
3787                          */
3788                         formats |= SNDRV_PCM_FMTBIT_U8;
3789                         bps = 8;
3790                 }
3791                 if (formats == 0) {
3792                         snd_printk(KERN_ERR "hda_codec: formats == 0 "
3793                                    "(nid=0x%x, val=0x%x, ovrd=%i, "
3794                                    "streams=0x%x)\n",
3795                                         nid, val,
3796                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3797                                         streams);
3798                         return -EIO;
3799                 }
3800                 if (formatsp)
3801                         *formatsp = formats;
3802                 if (bpsp)
3803                         *bpsp = bps;
3804         }
3805
3806         return 0;
3807 }
3808 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
3809
3810 /**
3811  * snd_hda_is_supported_format - Check the validity of the format
3812  * @codec: HD-audio codec
3813  * @nid: NID to check
3814  * @format: the HD-audio format value to check
3815  *
3816  * Check whether the given node supports the format value.
3817  *
3818  * Returns 1 if supported, 0 if not.
3819  */
3820 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3821                                 unsigned int format)
3822 {
3823         int i;
3824         unsigned int val = 0, rate, stream;
3825
3826         val = query_pcm_param(codec, nid);
3827         if (!val)
3828                 return 0;
3829
3830         rate = format & 0xff00;
3831         for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3832                 if (rate_bits[i].hda_fmt == rate) {
3833                         if (val & (1 << i))
3834                                 break;
3835                         return 0;
3836                 }
3837         if (i >= AC_PAR_PCM_RATE_BITS)
3838                 return 0;
3839
3840         stream = query_stream_param(codec, nid);
3841         if (!stream)
3842                 return 0;
3843
3844         if (stream & AC_SUPFMT_PCM) {
3845                 switch (format & 0xf0) {
3846                 case 0x00:
3847                         if (!(val & AC_SUPPCM_BITS_8))
3848                                 return 0;
3849                         break;
3850                 case 0x10:
3851                         if (!(val & AC_SUPPCM_BITS_16))
3852                                 return 0;
3853                         break;
3854                 case 0x20:
3855                         if (!(val & AC_SUPPCM_BITS_20))
3856                                 return 0;
3857                         break;
3858                 case 0x30:
3859                         if (!(val & AC_SUPPCM_BITS_24))
3860                                 return 0;
3861                         break;
3862                 case 0x40:
3863                         if (!(val & AC_SUPPCM_BITS_32))
3864                                 return 0;
3865                         break;
3866                 default:
3867                         return 0;
3868                 }
3869         } else {
3870                 /* FIXME: check for float32 and AC3? */
3871         }
3872
3873         return 1;
3874 }
3875 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3876
3877 /*
3878  * PCM stuff
3879  */
3880 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3881                                       struct hda_codec *codec,
3882                                       struct snd_pcm_substream *substream)
3883 {
3884         return 0;
3885 }
3886
3887 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3888                                    struct hda_codec *codec,
3889                                    unsigned int stream_tag,
3890                                    unsigned int format,
3891                                    struct snd_pcm_substream *substream)
3892 {
3893         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3894         return 0;
3895 }
3896
3897 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3898                                    struct hda_codec *codec,
3899                                    struct snd_pcm_substream *substream)
3900 {
3901         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3902         return 0;
3903 }
3904
3905 static int set_pcm_default_values(struct hda_codec *codec,
3906                                   struct hda_pcm_stream *info)
3907 {
3908         int err;
3909
3910         /* query support PCM information from the given NID */
3911         if (info->nid && (!info->rates || !info->formats)) {
3912                 err = snd_hda_query_supported_pcm(codec, info->nid,
3913                                 info->rates ? NULL : &info->rates,
3914                                 info->formats ? NULL : &info->formats,
3915                                 info->maxbps ? NULL : &info->maxbps);
3916                 if (err < 0)
3917                         return err;
3918         }
3919         if (info->ops.open == NULL)
3920                 info->ops.open = hda_pcm_default_open_close;
3921         if (info->ops.close == NULL)
3922                 info->ops.close = hda_pcm_default_open_close;
3923         if (info->ops.prepare == NULL) {
3924                 if (snd_BUG_ON(!info->nid))
3925                         return -EINVAL;
3926                 info->ops.prepare = hda_pcm_default_prepare;
3927         }
3928         if (info->ops.cleanup == NULL) {
3929                 if (snd_BUG_ON(!info->nid))
3930                         return -EINVAL;
3931                 info->ops.cleanup = hda_pcm_default_cleanup;
3932         }
3933         return 0;
3934 }
3935
3936 /*
3937  * codec prepare/cleanup entries
3938  */
3939 int snd_hda_codec_prepare(struct hda_codec *codec,
3940                           struct hda_pcm_stream *hinfo,
3941                           unsigned int stream,
3942                           unsigned int format,
3943                           struct snd_pcm_substream *substream)
3944 {
3945         int ret;
3946         mutex_lock(&codec->bus->prepare_mutex);
3947         ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
3948         if (ret >= 0)
3949                 purify_inactive_streams(codec);
3950         mutex_unlock(&codec->bus->prepare_mutex);
3951         return ret;
3952 }
3953 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
3954
3955 void snd_hda_codec_cleanup(struct hda_codec *codec,
3956                            struct hda_pcm_stream *hinfo,
3957                            struct snd_pcm_substream *substream)
3958 {
3959         mutex_lock(&codec->bus->prepare_mutex);
3960         hinfo->ops.cleanup(hinfo, codec, substream);
3961         mutex_unlock(&codec->bus->prepare_mutex);
3962 }
3963 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
3964
3965 /* global */
3966 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3967         "Audio", "SPDIF", "HDMI", "Modem"
3968 };
3969
3970 /*
3971  * get the empty PCM device number to assign
3972  *
3973  * note the max device number is limited by HDA_MAX_PCMS, currently 10
3974  */
3975 static int get_empty_pcm_device(struct hda_bus *bus, int type)
3976 {
3977         /* audio device indices; not linear to keep compatibility */
3978         static int audio_idx[HDA_PCM_NTYPES][5] = {
3979                 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3980                 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3981                 [HDA_PCM_TYPE_HDMI]  = { 3, 7, 8, 9, -1 },
3982                 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
3983         };
3984         int i;
3985
3986         if (type >= HDA_PCM_NTYPES) {
3987                 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3988                 return -EINVAL;
3989         }
3990
3991         for (i = 0; audio_idx[type][i] >= 0 ; i++)
3992                 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3993                         return audio_idx[type][i];
3994
3995         /* non-fixed slots starting from 10 */
3996         for (i = 10; i < 32; i++) {
3997                 if (!test_and_set_bit(i, bus->pcm_dev_bits))
3998                         return i;
3999         }
4000
4001         snd_printk(KERN_WARNING "Too many %s devices\n",
4002                 snd_hda_pcm_type_name[type]);
4003         return -EAGAIN;
4004 }
4005
4006 /*
4007  * attach a new PCM stream
4008  */
4009 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4010 {
4011         struct hda_bus *bus = codec->bus;
4012         struct hda_pcm_stream *info;
4013         int stream, err;
4014
4015         if (snd_BUG_ON(!pcm->name))
4016                 return -EINVAL;
4017         for (stream = 0; stream < 2; stream++) {
4018                 info = &pcm->stream[stream];
4019                 if (info->substreams) {
4020                         err = set_pcm_default_values(codec, info);
4021                         if (err < 0)
4022                                 return err;
4023                 }
4024         }
4025         return bus->ops.attach_pcm(bus, codec, pcm);
4026 }
4027
4028 /* assign all PCMs of the given codec */
4029 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4030 {
4031         unsigned int pcm;
4032         int err;
4033
4034         if (!codec->num_pcms) {
4035                 if (!codec->patch_ops.build_pcms)
4036                         return 0;
4037                 err = codec->patch_ops.build_pcms(codec);
4038                 if (err < 0) {
4039                         printk(KERN_ERR "hda_codec: cannot build PCMs"
4040                                "for #%d (error %d)\n", codec->addr, err);
4041                         err = snd_hda_codec_reset(codec);
4042                         if (err < 0) {
4043                                 printk(KERN_ERR
4044                                        "hda_codec: cannot revert codec\n");
4045                                 return err;
4046                         }
4047                 }
4048         }
4049         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4050                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4051                 int dev;
4052
4053                 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4054                         continue; /* no substreams assigned */
4055
4056                 if (!cpcm->pcm) {
4057                         dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4058                         if (dev < 0)
4059                                 continue; /* no fatal error */
4060                         cpcm->device = dev;
4061                         err = snd_hda_attach_pcm(codec, cpcm);
4062                         if (err < 0) {
4063                                 printk(KERN_ERR "hda_codec: cannot attach "
4064                                        "PCM stream %d for codec #%d\n",
4065                                        dev, codec->addr);
4066                                 continue; /* no fatal error */
4067                         }
4068                 }
4069         }
4070         return 0;
4071 }
4072
4073 /**
4074  * snd_hda_build_pcms - build PCM information
4075  * @bus: the BUS
4076  *
4077  * Create PCM information for each codec included in the bus.
4078  *
4079  * The build_pcms codec patch is requested to set up codec->num_pcms and
4080  * codec->pcm_info properly.  The array is referred by the top-level driver
4081  * to create its PCM instances.
4082  * The allocated codec->pcm_info should be released in codec->patch_ops.free
4083  * callback.
4084  *
4085  * At least, substreams, channels_min and channels_max must be filled for
4086  * each stream.  substreams = 0 indicates that the stream doesn't exist.
4087  * When rates and/or formats are zero, the supported values are queried
4088  * from the given nid.  The nid is used also by the default ops.prepare
4089  * and ops.cleanup callbacks.
4090  *
4091  * The driver needs to call ops.open in its open callback.  Similarly,
4092  * ops.close is supposed to be called in the close callback.
4093  * ops.prepare should be called in the prepare or hw_params callback
4094  * with the proper parameters for set up.
4095  * ops.cleanup should be called in hw_free for clean up of streams.
4096  *
4097  * This function returns 0 if successful, or a negative error code.
4098  */
4099 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
4100 {
4101         struct hda_codec *codec;
4102
4103         list_for_each_entry(codec, &bus->codec_list, list) {
4104                 int err = snd_hda_codec_build_pcms(codec);
4105                 if (err < 0)
4106                         return err;
4107         }
4108         return 0;
4109 }
4110 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
4111
4112 /**
4113  * snd_hda_check_board_config - compare the current codec with the config table
4114  * @codec: the HDA codec
4115  * @num_configs: number of config enums
4116  * @models: array of model name strings
4117  * @tbl: configuration table, terminated by null entries
4118  *
4119  * Compares the modelname or PCI subsystem id of the current codec with the
4120  * given configuration table.  If a matching entry is found, returns its
4121  * config value (supposed to be 0 or positive).
4122  *
4123  * If no entries are matching, the function returns a negative value.
4124  */
4125 int snd_hda_check_board_config(struct hda_codec *codec,
4126                                int num_configs, const char * const *models,
4127                                const struct snd_pci_quirk *tbl)
4128 {
4129         if (codec->modelname && models) {
4130                 int i;
4131                 for (i = 0; i < num_configs; i++) {
4132                         if (models[i] &&
4133                             !strcmp(codec->modelname, models[i])) {
4134                                 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4135                                            "selected\n", models[i]);
4136                                 return i;
4137                         }
4138                 }
4139         }
4140
4141         if (!codec->bus->pci || !tbl)
4142                 return -1;
4143
4144         tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4145         if (!tbl)
4146                 return -1;
4147         if (tbl->value >= 0 && tbl->value < num_configs) {
4148 #ifdef CONFIG_SND_DEBUG_VERBOSE
4149                 char tmp[10];
4150                 const char *model = NULL;
4151                 if (models)
4152                         model = models[tbl->value];
4153                 if (!model) {
4154                         sprintf(tmp, "#%d", tbl->value);
4155                         model = tmp;
4156                 }
4157                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4158                             "for config %x:%x (%s)\n",
4159                             model, tbl->subvendor, tbl->subdevice,
4160                             (tbl->name ? tbl->name : "Unknown device"));
4161 #endif
4162                 return tbl->value;
4163         }
4164         return -1;
4165 }
4166 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
4167
4168 /**
4169  * snd_hda_check_board_codec_sid_config - compare the current codec
4170                                         subsystem ID with the
4171                                         config table
4172
4173            This is important for Gateway notebooks with SB450 HDA Audio
4174            where the vendor ID of the PCI device is:
4175                 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4176            and the vendor/subvendor are found only at the codec.
4177
4178  * @codec: the HDA codec
4179  * @num_configs: number of config enums
4180  * @models: array of model name strings
4181  * @tbl: configuration table, terminated by null entries
4182  *
4183  * Compares the modelname or PCI subsystem id of the current codec with the
4184  * given configuration table.  If a matching entry is found, returns its
4185  * config value (supposed to be 0 or positive).
4186  *
4187  * If no entries are matching, the function returns a negative value.
4188  */
4189 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4190                                int num_configs, const char * const *models,
4191                                const struct snd_pci_quirk *tbl)
4192 {
4193         const struct snd_pci_quirk *q;
4194
4195         /* Search for codec ID */
4196         for (q = tbl; q->subvendor; q++) {
4197                 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4198                 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4199                 if ((codec->subsystem_id & mask) == id)
4200                         break;
4201         }
4202
4203         if (!q->subvendor)
4204                 return -1;
4205
4206         tbl = q;
4207
4208         if (tbl->value >= 0 && tbl->value < num_configs) {
4209 #ifdef CONFIG_SND_DEBUG_VERBOSE
4210                 char tmp[10];
4211                 const char *model = NULL;
4212                 if (models)
4213                         model = models[tbl->value];
4214                 if (!model) {
4215                         sprintf(tmp, "#%d", tbl->value);
4216                         model = tmp;
4217                 }
4218                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4219                             "for config %x:%x (%s)\n",
4220                             model, tbl->subvendor, tbl->subdevice,
4221                             (tbl->name ? tbl->name : "Unknown device"));
4222 #endif
4223                 return tbl->value;
4224         }
4225         return -1;
4226 }
4227 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4228
4229 /**
4230  * snd_hda_add_new_ctls - create controls from the array
4231  * @codec: the HDA codec
4232  * @knew: the array of struct snd_kcontrol_new
4233  *
4234  * This helper function creates and add new controls in the given array.
4235  * The array must be terminated with an empty entry as terminator.
4236  *
4237  * Returns 0 if successful, or a negative error code.
4238  */
4239 int snd_hda_add_new_ctls(struct hda_codec *codec,
4240                          const struct snd_kcontrol_new *knew)
4241 {
4242         int err;
4243
4244         for (; knew->name; knew++) {
4245                 struct snd_kcontrol *kctl;
4246                 int addr = 0, idx = 0;
4247                 if (knew->iface == -1)  /* skip this codec private value */
4248                         continue;
4249                 for (;;) {
4250                         kctl = snd_ctl_new1(knew, codec);
4251                         if (!kctl)
4252                                 return -ENOMEM;
4253                         if (addr > 0)
4254                                 kctl->id.device = addr;
4255                         if (idx > 0)
4256                                 kctl->id.index = idx;
4257                         err = snd_hda_ctl_add(codec, 0, kctl);
4258                         if (!err)
4259                                 break;
4260                         /* try first with another device index corresponding to
4261                          * the codec addr; if it still fails (or it's the
4262                          * primary codec), then try another control index
4263                          */
4264                         if (!addr && codec->addr)
4265                                 addr = codec->addr;
4266                         else if (!idx && !knew->index) {
4267                                 idx = find_empty_mixer_ctl_idx(codec,
4268                                                                knew->name);
4269                                 if (idx <= 0)
4270                                         return err;
4271                         } else
4272                                 return err;
4273                 }
4274         }
4275         return 0;
4276 }
4277 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4278
4279 #ifdef CONFIG_SND_HDA_POWER_SAVE
4280 static void hda_power_work(struct work_struct *work)
4281 {
4282         struct hda_codec *codec =
4283                 container_of(work, struct hda_codec, power_work.work);
4284         struct hda_bus *bus = codec->bus;
4285
4286         if (!codec->power_on || codec->power_count) {
4287                 codec->power_transition = 0;
4288                 return;
4289         }
4290
4291         trace_hda_power_down(codec);
4292         hda_call_codec_suspend(codec);
4293         if (bus->ops.pm_notify)
4294                 bus->ops.pm_notify(bus);
4295 }
4296
4297 static void hda_keep_power_on(struct hda_codec *codec)
4298 {
4299         codec->power_count++;
4300         codec->power_on = 1;
4301         codec->power_jiffies = jiffies;
4302 }
4303
4304 /* update the power on/off account with the current jiffies */
4305 void snd_hda_update_power_acct(struct hda_codec *codec)
4306 {
4307         unsigned long delta = jiffies - codec->power_jiffies;
4308         if (codec->power_on)
4309                 codec->power_on_acct += delta;
4310         else
4311                 codec->power_off_acct += delta;
4312         codec->power_jiffies += delta;
4313 }
4314
4315 /**
4316  * snd_hda_power_up - Power-up the codec
4317  * @codec: HD-audio codec
4318  *
4319  * Increment the power-up counter and power up the hardware really when
4320  * not turned on yet.
4321  */
4322 void snd_hda_power_up(struct hda_codec *codec)
4323 {
4324         struct hda_bus *bus = codec->bus;
4325
4326         codec->power_count++;
4327         if (codec->power_on || codec->power_transition)
4328                 return;
4329
4330         trace_hda_power_up(codec);
4331         snd_hda_update_power_acct(codec);
4332         codec->power_on = 1;
4333         codec->power_jiffies = jiffies;
4334         if (bus->ops.pm_notify)
4335                 bus->ops.pm_notify(bus);
4336         hda_call_codec_resume(codec);
4337         cancel_delayed_work(&codec->power_work);
4338         codec->power_transition = 0;
4339 }
4340 EXPORT_SYMBOL_HDA(snd_hda_power_up);
4341
4342 #define power_save(codec)       \
4343         ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4344
4345 /**
4346  * snd_hda_power_down - Power-down the codec
4347  * @codec: HD-audio codec
4348  *
4349  * Decrement the power-up counter and schedules the power-off work if
4350  * the counter rearches to zero.
4351  */
4352 void snd_hda_power_down(struct hda_codec *codec)
4353 {
4354         --codec->power_count;
4355         if (!codec->power_on || codec->power_count || codec->power_transition)
4356                 return;
4357         if (power_save(codec)) {
4358                 codec->power_transition = 1; /* avoid reentrance */
4359                 queue_delayed_work(codec->bus->workq, &codec->power_work,
4360                                 msecs_to_jiffies(power_save(codec) * 1000));
4361         }
4362 }
4363 EXPORT_SYMBOL_HDA(snd_hda_power_down);
4364
4365 /**
4366  * snd_hda_check_amp_list_power - Check the amp list and update the power
4367  * @codec: HD-audio codec
4368  * @check: the object containing an AMP list and the status
4369  * @nid: NID to check / update
4370  *
4371  * Check whether the given NID is in the amp list.  If it's in the list,
4372  * check the current AMP status, and update the the power-status according
4373  * to the mute status.
4374  *
4375  * This function is supposed to be set or called from the check_power_status
4376  * patch ops.
4377  */
4378 int snd_hda_check_amp_list_power(struct hda_codec *codec,
4379                                  struct hda_loopback_check *check,
4380                                  hda_nid_t nid)
4381 {
4382         const struct hda_amp_list *p;
4383         int ch, v;
4384
4385         if (!check->amplist)
4386                 return 0;
4387         for (p = check->amplist; p->nid; p++) {
4388                 if (p->nid == nid)
4389                         break;
4390         }
4391         if (!p->nid)
4392                 return 0; /* nothing changed */
4393
4394         for (p = check->amplist; p->nid; p++) {
4395                 for (ch = 0; ch < 2; ch++) {
4396                         v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4397                                                    p->idx);
4398                         if (!(v & HDA_AMP_MUTE) && v > 0) {
4399                                 if (!check->power_on) {
4400                                         check->power_on = 1;
4401                                         snd_hda_power_up(codec);
4402                                 }
4403                                 return 1;
4404                         }
4405                 }
4406         }
4407         if (check->power_on) {
4408                 check->power_on = 0;
4409                 snd_hda_power_down(codec);
4410         }
4411         return 0;
4412 }
4413 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
4414 #endif
4415
4416 /*
4417  * Channel mode helper
4418  */
4419
4420 /**
4421  * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4422  */
4423 int snd_hda_ch_mode_info(struct hda_codec *codec,
4424                          struct snd_ctl_elem_info *uinfo,
4425                          const struct hda_channel_mode *chmode,
4426                          int num_chmodes)
4427 {
4428         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4429         uinfo->count = 1;
4430         uinfo->value.enumerated.items = num_chmodes;
4431         if (uinfo->value.enumerated.item >= num_chmodes)
4432                 uinfo->value.enumerated.item = num_chmodes - 1;
4433         sprintf(uinfo->value.enumerated.name, "%dch",
4434                 chmode[uinfo->value.enumerated.item].channels);
4435         return 0;
4436 }
4437 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4438
4439 /**
4440  * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4441  */
4442 int snd_hda_ch_mode_get(struct hda_codec *codec,
4443                         struct snd_ctl_elem_value *ucontrol,
4444                         const struct hda_channel_mode *chmode,
4445                         int num_chmodes,
4446                         int max_channels)
4447 {
4448         int i;
4449
4450         for (i = 0; i < num_chmodes; i++) {
4451                 if (max_channels == chmode[i].channels) {
4452                         ucontrol->value.enumerated.item[0] = i;
4453                         break;
4454                 }
4455         }
4456         return 0;
4457 }
4458 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4459
4460 /**
4461  * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4462  */
4463 int snd_hda_ch_mode_put(struct hda_codec *codec,
4464                         struct snd_ctl_elem_value *ucontrol,
4465                         const struct hda_channel_mode *chmode,
4466                         int num_chmodes,
4467                         int *max_channelsp)
4468 {
4469         unsigned int mode;
4470
4471         mode = ucontrol->value.enumerated.item[0];
4472         if (mode >= num_chmodes)
4473                 return -EINVAL;
4474         if (*max_channelsp == chmode[mode].channels)
4475                 return 0;
4476         /* change the current channel setting */
4477         *max_channelsp = chmode[mode].channels;
4478         if (chmode[mode].sequence)
4479                 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4480         return 1;
4481 }
4482 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4483
4484 /*
4485  * input MUX helper
4486  */
4487
4488 /**
4489  * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4490  */
4491 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4492                            struct snd_ctl_elem_info *uinfo)
4493 {
4494         unsigned int index;
4495
4496         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4497         uinfo->count = 1;
4498         uinfo->value.enumerated.items = imux->num_items;
4499         if (!imux->num_items)
4500                 return 0;
4501         index = uinfo->value.enumerated.item;
4502         if (index >= imux->num_items)
4503                 index = imux->num_items - 1;
4504         strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4505         return 0;
4506 }
4507 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4508
4509 /**
4510  * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4511  */
4512 int snd_hda_input_mux_put(struct hda_codec *codec,
4513                           const struct hda_input_mux *imux,
4514                           struct snd_ctl_elem_value *ucontrol,
4515                           hda_nid_t nid,
4516                           unsigned int *cur_val)
4517 {
4518         unsigned int idx;
4519
4520         if (!imux->num_items)
4521                 return 0;
4522         idx = ucontrol->value.enumerated.item[0];
4523         if (idx >= imux->num_items)
4524                 idx = imux->num_items - 1;
4525         if (*cur_val == idx)
4526                 return 0;
4527         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4528                                   imux->items[idx].index);
4529         *cur_val = idx;
4530         return 1;
4531 }
4532 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4533
4534
4535 /*
4536  * Multi-channel / digital-out PCM helper functions
4537  */
4538
4539 /* setup SPDIF output stream */
4540 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4541                                  unsigned int stream_tag, unsigned int format)
4542 {
4543         struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4544
4545         /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4546         if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4547                 set_dig_out_convert(codec, nid,
4548                                     spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
4549                                     -1);
4550         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4551         if (codec->slave_dig_outs) {
4552                 const hda_nid_t *d;
4553                 for (d = codec->slave_dig_outs; *d; d++)
4554                         snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4555                                                    format);
4556         }
4557         /* turn on again (if needed) */
4558         if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4559                 set_dig_out_convert(codec, nid,
4560                                     spdif->ctls & 0xff, -1);
4561 }
4562
4563 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4564 {
4565         snd_hda_codec_cleanup_stream(codec, nid);
4566         if (codec->slave_dig_outs) {
4567                 const hda_nid_t *d;
4568                 for (d = codec->slave_dig_outs; *d; d++)
4569                         snd_hda_codec_cleanup_stream(codec, *d);
4570         }
4571 }
4572
4573 /**
4574  * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4575  * @bus: HD-audio bus
4576  */
4577 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4578 {
4579         struct hda_codec *codec;
4580
4581         if (!bus)
4582                 return;
4583         list_for_each_entry(codec, &bus->codec_list, list) {
4584                 if (hda_codec_is_power_on(codec) &&
4585                     codec->patch_ops.reboot_notify)
4586                         codec->patch_ops.reboot_notify(codec);
4587         }
4588 }
4589 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
4590
4591 /**
4592  * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4593  */
4594 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4595                                struct hda_multi_out *mout)
4596 {
4597         mutex_lock(&codec->spdif_mutex);
4598         if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4599                 /* already opened as analog dup; reset it once */
4600                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4601         mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4602         mutex_unlock(&codec->spdif_mutex);
4603         return 0;
4604 }
4605 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
4606
4607 /**
4608  * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4609  */
4610 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4611                                   struct hda_multi_out *mout,
4612                                   unsigned int stream_tag,
4613                                   unsigned int format,
4614                                   struct snd_pcm_substream *substream)
4615 {
4616         mutex_lock(&codec->spdif_mutex);
4617         setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4618         mutex_unlock(&codec->spdif_mutex);
4619         return 0;
4620 }
4621 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
4622
4623 /**
4624  * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4625  */
4626 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4627                                   struct hda_multi_out *mout)
4628 {
4629         mutex_lock(&codec->spdif_mutex);
4630         cleanup_dig_out_stream(codec, mout->dig_out_nid);
4631         mutex_unlock(&codec->spdif_mutex);
4632         return 0;
4633 }
4634 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4635
4636 /**
4637  * snd_hda_multi_out_dig_close - release the digital out stream
4638  */
4639 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4640                                 struct hda_multi_out *mout)
4641 {
4642         mutex_lock(&codec->spdif_mutex);
4643         mout->dig_out_used = 0;
4644         mutex_unlock(&codec->spdif_mutex);
4645         return 0;
4646 }
4647 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
4648
4649 /**
4650  * snd_hda_multi_out_analog_open - open analog outputs
4651  *
4652  * Open analog outputs and set up the hw-constraints.
4653  * If the digital outputs can be opened as slave, open the digital
4654  * outputs, too.
4655  */
4656 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4657                                   struct hda_multi_out *mout,
4658                                   struct snd_pcm_substream *substream,
4659                                   struct hda_pcm_stream *hinfo)
4660 {
4661         struct snd_pcm_runtime *runtime = substream->runtime;
4662         runtime->hw.channels_max = mout->max_channels;
4663         if (mout->dig_out_nid) {
4664                 if (!mout->analog_rates) {
4665                         mout->analog_rates = hinfo->rates;
4666                         mout->analog_formats = hinfo->formats;
4667                         mout->analog_maxbps = hinfo->maxbps;
4668                 } else {
4669                         runtime->hw.rates = mout->analog_rates;
4670                         runtime->hw.formats = mout->analog_formats;
4671                         hinfo->maxbps = mout->analog_maxbps;
4672                 }
4673                 if (!mout->spdif_rates) {
4674                         snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4675                                                     &mout->spdif_rates,
4676                                                     &mout->spdif_formats,
4677                                                     &mout->spdif_maxbps);
4678                 }
4679                 mutex_lock(&codec->spdif_mutex);
4680                 if (mout->share_spdif) {
4681                         if ((runtime->hw.rates & mout->spdif_rates) &&
4682                             (runtime->hw.formats & mout->spdif_formats)) {
4683                                 runtime->hw.rates &= mout->spdif_rates;
4684                                 runtime->hw.formats &= mout->spdif_formats;
4685                                 if (mout->spdif_maxbps < hinfo->maxbps)
4686                                         hinfo->maxbps = mout->spdif_maxbps;
4687                         } else {
4688                                 mout->share_spdif = 0;
4689                                 /* FIXME: need notify? */
4690                         }
4691                 }
4692                 mutex_unlock(&codec->spdif_mutex);
4693         }
4694         return snd_pcm_hw_constraint_step(substream->runtime, 0,
4695                                           SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4696 }
4697 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
4698
4699 /**
4700  * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4701  *
4702  * Set up the i/o for analog out.
4703  * When the digital out is available, copy the front out to digital out, too.
4704  */
4705 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4706                                      struct hda_multi_out *mout,
4707                                      unsigned int stream_tag,
4708                                      unsigned int format,
4709                                      struct snd_pcm_substream *substream)
4710 {
4711         const hda_nid_t *nids = mout->dac_nids;
4712         int chs = substream->runtime->channels;
4713         struct hda_spdif_out *spdif =
4714                         snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
4715         int i;
4716
4717         mutex_lock(&codec->spdif_mutex);
4718         if (mout->dig_out_nid && mout->share_spdif &&
4719             mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4720                 if (chs == 2 &&
4721                     snd_hda_is_supported_format(codec, mout->dig_out_nid,
4722                                                 format) &&
4723                     !(spdif->status & IEC958_AES0_NONAUDIO)) {
4724                         mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4725                         setup_dig_out_stream(codec, mout->dig_out_nid,
4726                                              stream_tag, format);
4727                 } else {
4728                         mout->dig_out_used = 0;
4729                         cleanup_dig_out_stream(codec, mout->dig_out_nid);
4730                 }
4731         }
4732         mutex_unlock(&codec->spdif_mutex);
4733
4734         /* front */
4735         snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4736                                    0, format);
4737         if (!mout->no_share_stream &&
4738             mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4739                 /* headphone out will just decode front left/right (stereo) */
4740                 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4741                                            0, format);
4742         /* extra outputs copied from front */
4743         for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4744                 if (!mout->no_share_stream && mout->hp_out_nid[i])
4745                         snd_hda_codec_setup_stream(codec,
4746                                                    mout->hp_out_nid[i],
4747                                                    stream_tag, 0, format);
4748         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4749                 if (!mout->no_share_stream && mout->extra_out_nid[i])
4750                         snd_hda_codec_setup_stream(codec,
4751                                                    mout->extra_out_nid[i],
4752                                                    stream_tag, 0, format);
4753
4754         /* surrounds */
4755         for (i = 1; i < mout->num_dacs; i++) {
4756                 if (chs >= (i + 1) * 2) /* independent out */
4757                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4758                                                    i * 2, format);
4759                 else if (!mout->no_share_stream) /* copy front */
4760                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4761                                                    0, format);
4762         }
4763         return 0;
4764 }
4765 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
4766
4767 /**
4768  * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4769  */
4770 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4771                                      struct hda_multi_out *mout)
4772 {
4773         const hda_nid_t *nids = mout->dac_nids;
4774         int i;
4775
4776         for (i = 0; i < mout->num_dacs; i++)
4777                 snd_hda_codec_cleanup_stream(codec, nids[i]);
4778         if (mout->hp_nid)
4779                 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4780         for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4781                 if (mout->hp_out_nid[i])
4782                         snd_hda_codec_cleanup_stream(codec,
4783                                                      mout->hp_out_nid[i]);
4784         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4785                 if (mout->extra_out_nid[i])
4786                         snd_hda_codec_cleanup_stream(codec,
4787                                                      mout->extra_out_nid[i]);
4788         mutex_lock(&codec->spdif_mutex);
4789         if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4790                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4791                 mout->dig_out_used = 0;
4792         }
4793         mutex_unlock(&codec->spdif_mutex);
4794         return 0;
4795 }
4796 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4797
4798 /*
4799  * Helper for automatic pin configuration
4800  */
4801
4802 static int is_in_nid_list(hda_nid_t nid, const hda_nid_t *list)
4803 {
4804         for (; *list; list++)
4805                 if (*list == nid)
4806                         return 1;
4807         return 0;
4808 }
4809
4810
4811 /*
4812  * Sort an associated group of pins according to their sequence numbers.
4813  */
4814 static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences,
4815                                   int num_pins)
4816 {
4817         int i, j;
4818         short seq;
4819         hda_nid_t nid;
4820
4821         for (i = 0; i < num_pins; i++) {
4822                 for (j = i + 1; j < num_pins; j++) {
4823                         if (sequences[i] > sequences[j]) {
4824                                 seq = sequences[i];
4825                                 sequences[i] = sequences[j];
4826                                 sequences[j] = seq;
4827                                 nid = pins[i];
4828                                 pins[i] = pins[j];
4829                                 pins[j] = nid;
4830                         }
4831                 }
4832         }
4833 }
4834
4835
4836 /* add the found input-pin to the cfg->inputs[] table */
4837 static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid,
4838                                    int type)
4839 {
4840         if (cfg->num_inputs < AUTO_CFG_MAX_INS) {
4841                 cfg->inputs[cfg->num_inputs].pin = nid;
4842                 cfg->inputs[cfg->num_inputs].type = type;
4843                 cfg->num_inputs++;
4844         }
4845 }
4846
4847 /* sort inputs in the order of AUTO_PIN_* type */
4848 static void sort_autocfg_input_pins(struct auto_pin_cfg *cfg)
4849 {
4850         int i, j;
4851
4852         for (i = 0; i < cfg->num_inputs; i++) {
4853                 for (j = i + 1; j < cfg->num_inputs; j++) {
4854                         if (cfg->inputs[i].type > cfg->inputs[j].type) {
4855                                 struct auto_pin_cfg_item tmp;
4856                                 tmp = cfg->inputs[i];
4857                                 cfg->inputs[i] = cfg->inputs[j];
4858                                 cfg->inputs[j] = tmp;
4859                         }
4860                 }
4861         }
4862 }
4863
4864 /* Reorder the surround channels
4865  * ALSA sequence is front/surr/clfe/side
4866  * HDA sequence is:
4867  *    4-ch: front/surr  =>  OK as it is
4868  *    6-ch: front/clfe/surr
4869  *    8-ch: front/clfe/rear/side|fc
4870  */
4871 static void reorder_outputs(unsigned int nums, hda_nid_t *pins)
4872 {
4873         hda_nid_t nid;
4874
4875         switch (nums) {
4876         case 3:
4877         case 4:
4878                 nid = pins[1];
4879                 pins[1] = pins[2];
4880                 pins[2] = nid;
4881                 break;
4882         }
4883 }
4884
4885 /*
4886  * Parse all pin widgets and store the useful pin nids to cfg
4887  *
4888  * The number of line-outs or any primary output is stored in line_outs,
4889  * and the corresponding output pins are assigned to line_out_pins[],
4890  * in the order of front, rear, CLFE, side, ...
4891  *
4892  * If more extra outputs (speaker and headphone) are found, the pins are
4893  * assisnged to hp_pins[] and speaker_pins[], respectively.  If no line-out jack
4894  * is detected, one of speaker of HP pins is assigned as the primary
4895  * output, i.e. to line_out_pins[0].  So, line_outs is always positive
4896  * if any analog output exists.
4897  *
4898  * The analog input pins are assigned to inputs array.
4899  * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4900  * respectively.
4901  */
4902 int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
4903                              struct auto_pin_cfg *cfg,
4904                              const hda_nid_t *ignore_nids,
4905                              unsigned int cond_flags)
4906 {
4907         hda_nid_t nid, end_nid;
4908         short seq, assoc_line_out;
4909         short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4910         short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
4911         short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
4912         int i;
4913
4914         memset(cfg, 0, sizeof(*cfg));
4915
4916         memset(sequences_line_out, 0, sizeof(sequences_line_out));
4917         memset(sequences_speaker, 0, sizeof(sequences_speaker));
4918         memset(sequences_hp, 0, sizeof(sequences_hp));
4919         assoc_line_out = 0;
4920
4921         codec->ignore_misc_bit = true;
4922         end_nid = codec->start_nid + codec->num_nodes;
4923         for (nid = codec->start_nid; nid < end_nid; nid++) {
4924                 unsigned int wid_caps = get_wcaps(codec, nid);
4925                 unsigned int wid_type = get_wcaps_type(wid_caps);
4926                 unsigned int def_conf;
4927                 short assoc, loc, conn, dev;
4928
4929                 /* read all default configuration for pin complex */
4930                 if (wid_type != AC_WID_PIN)
4931                         continue;
4932                 /* ignore the given nids (e.g. pc-beep returns error) */
4933                 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4934                         continue;
4935
4936                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4937                 if (!(get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
4938                       AC_DEFCFG_MISC_NO_PRESENCE))
4939                         codec->ignore_misc_bit = false;
4940                 conn = get_defcfg_connect(def_conf);
4941                 if (conn == AC_JACK_PORT_NONE)
4942                         continue;
4943                 loc = get_defcfg_location(def_conf);
4944                 dev = get_defcfg_device(def_conf);
4945
4946                 /* workaround for buggy BIOS setups */
4947                 if (dev == AC_JACK_LINE_OUT) {
4948                         if (conn == AC_JACK_PORT_FIXED)
4949                                 dev = AC_JACK_SPEAKER;
4950                 }
4951
4952                 switch (dev) {
4953                 case AC_JACK_LINE_OUT:
4954                         seq = get_defcfg_sequence(def_conf);
4955                         assoc = get_defcfg_association(def_conf);
4956
4957                         if (!(wid_caps & AC_WCAP_STEREO))
4958                                 if (!cfg->mono_out_pin)
4959                                         cfg->mono_out_pin = nid;
4960                         if (!assoc)
4961                                 continue;
4962                         if (!assoc_line_out)
4963                                 assoc_line_out = assoc;
4964                         else if (assoc_line_out != assoc)
4965                                 continue;
4966                         if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4967                                 continue;
4968                         cfg->line_out_pins[cfg->line_outs] = nid;
4969                         sequences_line_out[cfg->line_outs] = seq;
4970                         cfg->line_outs++;
4971                         break;
4972                 case AC_JACK_SPEAKER:
4973                         seq = get_defcfg_sequence(def_conf);
4974                         assoc = get_defcfg_association(def_conf);
4975                         if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4976                                 continue;
4977                         cfg->speaker_pins[cfg->speaker_outs] = nid;
4978                         sequences_speaker[cfg->speaker_outs] = (assoc << 4) | seq;
4979                         cfg->speaker_outs++;
4980                         break;
4981                 case AC_JACK_HP_OUT:
4982                         seq = get_defcfg_sequence(def_conf);
4983                         assoc = get_defcfg_association(def_conf);
4984                         if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4985                                 continue;
4986                         cfg->hp_pins[cfg->hp_outs] = nid;
4987                         sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
4988                         cfg->hp_outs++;
4989                         break;
4990                 case AC_JACK_MIC_IN:
4991                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_MIC);
4992                         break;
4993                 case AC_JACK_LINE_IN:
4994                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_LINE_IN);
4995                         break;
4996                 case AC_JACK_CD:
4997                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD);
4998                         break;
4999                 case AC_JACK_AUX:
5000                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX);
5001                         break;
5002                 case AC_JACK_SPDIF_OUT:
5003                 case AC_JACK_DIG_OTHER_OUT:
5004                         if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
5005                                 continue;
5006                         cfg->dig_out_pins[cfg->dig_outs] = nid;
5007                         cfg->dig_out_type[cfg->dig_outs] =
5008                                 (loc == AC_JACK_LOC_HDMI) ?
5009                                 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
5010                         cfg->dig_outs++;
5011                         break;
5012                 case AC_JACK_SPDIF_IN:
5013                 case AC_JACK_DIG_OTHER_IN:
5014                         cfg->dig_in_pin = nid;
5015                         if (loc == AC_JACK_LOC_HDMI)
5016                                 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
5017                         else
5018                                 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
5019                         break;
5020                 }
5021         }
5022
5023         /* FIX-UP:
5024          * If no line-out is defined but multiple HPs are found,
5025          * some of them might be the real line-outs.
5026          */
5027         if (!cfg->line_outs && cfg->hp_outs > 1 &&
5028             !(cond_flags & HDA_PINCFG_NO_HP_FIXUP)) {
5029                 int i = 0;
5030                 while (i < cfg->hp_outs) {
5031                         /* The real HPs should have the sequence 0x0f */
5032                         if ((sequences_hp[i] & 0x0f) == 0x0f) {
5033                                 i++;
5034                                 continue;
5035                         }
5036                         /* Move it to the line-out table */
5037                         cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
5038                         sequences_line_out[cfg->line_outs] = sequences_hp[i];
5039                         cfg->line_outs++;
5040                         cfg->hp_outs--;
5041                         memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
5042                                 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
5043                         memmove(sequences_hp + i, sequences_hp + i + 1,
5044                                 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
5045                 }
5046                 memset(cfg->hp_pins + cfg->hp_outs, 0,
5047                        sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs));
5048                 if (!cfg->hp_outs)
5049                         cfg->line_out_type = AUTO_PIN_HP_OUT;
5050
5051         }
5052
5053         /* sort by sequence */
5054         sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
5055                               cfg->line_outs);
5056         sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
5057                               cfg->speaker_outs);
5058         sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
5059                               cfg->hp_outs);
5060
5061         /*
5062          * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
5063          * as a primary output
5064          */
5065         if (!cfg->line_outs &&
5066             !(cond_flags & HDA_PINCFG_NO_LO_FIXUP)) {
5067                 if (cfg->speaker_outs) {
5068                         cfg->line_outs = cfg->speaker_outs;
5069                         memcpy(cfg->line_out_pins, cfg->speaker_pins,
5070                                sizeof(cfg->speaker_pins));
5071                         cfg->speaker_outs = 0;
5072                         memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
5073                         cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
5074                 } else if (cfg->hp_outs) {
5075                         cfg->line_outs = cfg->hp_outs;
5076                         memcpy(cfg->line_out_pins, cfg->hp_pins,
5077                                sizeof(cfg->hp_pins));
5078                         cfg->hp_outs = 0;
5079                         memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
5080                         cfg->line_out_type = AUTO_PIN_HP_OUT;
5081                 }
5082         }
5083
5084         reorder_outputs(cfg->line_outs, cfg->line_out_pins);
5085         reorder_outputs(cfg->hp_outs, cfg->hp_pins);
5086         reorder_outputs(cfg->speaker_outs, cfg->speaker_pins);
5087
5088         sort_autocfg_input_pins(cfg);
5089
5090         /*
5091          * debug prints of the parsed results
5092          */
5093         snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
5094                    cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
5095                    cfg->line_out_pins[2], cfg->line_out_pins[3],
5096                    cfg->line_out_pins[4],
5097                    cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
5098                    (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT ?
5099                     "speaker" : "line"));
5100         snd_printd("   speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
5101                    cfg->speaker_outs, cfg->speaker_pins[0],
5102                    cfg->speaker_pins[1], cfg->speaker_pins[2],
5103                    cfg->speaker_pins[3], cfg->speaker_pins[4]);
5104         snd_printd("   hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
5105                    cfg->hp_outs, cfg->hp_pins[0],
5106                    cfg->hp_pins[1], cfg->hp_pins[2],
5107                    cfg->hp_pins[3], cfg->hp_pins[4]);
5108         snd_printd("   mono: mono_out=0x%x\n", cfg->mono_out_pin);
5109         if (cfg->dig_outs)
5110                 snd_printd("   dig-out=0x%x/0x%x\n",
5111                            cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
5112         snd_printd("   inputs:");
5113         for (i = 0; i < cfg->num_inputs; i++) {
5114                 snd_printd(" %s=0x%x",
5115                             hda_get_autocfg_input_label(codec, cfg, i),
5116                             cfg->inputs[i].pin);
5117         }
5118         snd_printd("\n");
5119         if (cfg->dig_in_pin)
5120                 snd_printd("   dig-in=0x%x\n", cfg->dig_in_pin);
5121
5122         return 0;
5123 }
5124 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_defcfg);
5125
5126 int snd_hda_get_input_pin_attr(unsigned int def_conf)
5127 {
5128         unsigned int loc = get_defcfg_location(def_conf);
5129         unsigned int conn = get_defcfg_connect(def_conf);
5130         if (conn == AC_JACK_PORT_NONE)
5131                 return INPUT_PIN_ATTR_UNUSED;
5132         /* Windows may claim the internal mic to be BOTH, too */
5133         if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH)
5134                 return INPUT_PIN_ATTR_INT;
5135         if ((loc & 0x30) == AC_JACK_LOC_INTERNAL)
5136                 return INPUT_PIN_ATTR_INT;
5137         if ((loc & 0x30) == AC_JACK_LOC_SEPARATE)
5138                 return INPUT_PIN_ATTR_DOCK;
5139         if (loc == AC_JACK_LOC_REAR)
5140                 return INPUT_PIN_ATTR_REAR;
5141         if (loc == AC_JACK_LOC_FRONT)
5142                 return INPUT_PIN_ATTR_FRONT;
5143         return INPUT_PIN_ATTR_NORMAL;
5144 }
5145 EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
5146
5147 /**
5148  * hda_get_input_pin_label - Give a label for the given input pin
5149  *
5150  * When check_location is true, the function checks the pin location
5151  * for mic and line-in pins, and set an appropriate prefix like "Front",
5152  * "Rear", "Internal".
5153  */
5154
5155 static const char *hda_get_input_pin_label(struct hda_codec *codec,
5156                                            hda_nid_t pin, bool check_location)
5157 {
5158         unsigned int def_conf;
5159         static const char * const mic_names[] = {
5160                 "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic",
5161         };
5162         int attr;
5163
5164         def_conf = snd_hda_codec_get_pincfg(codec, pin);
5165
5166         switch (get_defcfg_device(def_conf)) {
5167         case AC_JACK_MIC_IN:
5168                 if (!check_location)
5169                         return "Mic";
5170                 attr = snd_hda_get_input_pin_attr(def_conf);
5171                 if (!attr)
5172                         return "None";
5173                 return mic_names[attr - 1];
5174         case AC_JACK_LINE_IN:
5175                 if (!check_location)
5176                         return "Line";
5177                 attr = snd_hda_get_input_pin_attr(def_conf);
5178                 if (!attr)
5179                         return "None";
5180                 if (attr == INPUT_PIN_ATTR_DOCK)
5181                         return "Dock Line";
5182                 return "Line";
5183         case AC_JACK_AUX:
5184                 return "Aux";
5185         case AC_JACK_CD:
5186                 return "CD";
5187         case AC_JACK_SPDIF_IN:
5188                 return "SPDIF In";
5189         case AC_JACK_DIG_OTHER_IN:
5190                 return "Digital In";
5191         default:
5192                 return "Misc";
5193         }
5194 }
5195
5196 /* Check whether the location prefix needs to be added to the label.
5197  * If all mic-jacks are in the same location (e.g. rear panel), we don't
5198  * have to put "Front" prefix to each label.  In such a case, returns false.
5199  */
5200 static int check_mic_location_need(struct hda_codec *codec,
5201                                    const struct auto_pin_cfg *cfg,
5202                                    int input)
5203 {
5204         unsigned int defc;
5205         int i, attr, attr2;
5206
5207         defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin);
5208         attr = snd_hda_get_input_pin_attr(defc);
5209         /* for internal or docking mics, we need locations */
5210         if (attr <= INPUT_PIN_ATTR_NORMAL)
5211                 return 1;
5212
5213         attr = 0;
5214         for (i = 0; i < cfg->num_inputs; i++) {
5215                 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin);
5216                 attr2 = snd_hda_get_input_pin_attr(defc);
5217                 if (attr2 >= INPUT_PIN_ATTR_NORMAL) {
5218                         if (attr && attr != attr2)
5219                                 return 1; /* different locations found */
5220                         attr = attr2;
5221                 }
5222         }
5223         return 0;
5224 }
5225
5226 /**
5227  * hda_get_autocfg_input_label - Get a label for the given input
5228  *
5229  * Get a label for the given input pin defined by the autocfg item.
5230  * Unlike hda_get_input_pin_label(), this function checks all inputs
5231  * defined in autocfg and avoids the redundant mic/line prefix as much as
5232  * possible.
5233  */
5234 const char *hda_get_autocfg_input_label(struct hda_codec *codec,
5235                                         const struct auto_pin_cfg *cfg,
5236                                         int input)
5237 {
5238         int type = cfg->inputs[input].type;
5239         int has_multiple_pins = 0;
5240
5241         if ((input > 0 && cfg->inputs[input - 1].type == type) ||
5242             (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type))
5243                 has_multiple_pins = 1;
5244         if (has_multiple_pins && type == AUTO_PIN_MIC)
5245                 has_multiple_pins &= check_mic_location_need(codec, cfg, input);
5246         return hda_get_input_pin_label(codec, cfg->inputs[input].pin,
5247                                        has_multiple_pins);
5248 }
5249 EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
5250
5251 /* return the position of NID in the list, or -1 if not found */
5252 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
5253 {
5254         int i;
5255         for (i = 0; i < nums; i++)
5256                 if (list[i] == nid)
5257                         return i;
5258         return -1;
5259 }
5260
5261 /* get a unique suffix or an index number */
5262 static const char *check_output_sfx(hda_nid_t nid, const hda_nid_t *pins,
5263                                     int num_pins, int *indexp)
5264 {
5265         static const char * const channel_sfx[] = {
5266                 " Front", " Surround", " CLFE", " Side"
5267         };
5268         int i;
5269
5270         i = find_idx_in_nid_list(nid, pins, num_pins);
5271         if (i < 0)
5272                 return NULL;
5273         if (num_pins == 1)
5274                 return "";
5275         if (num_pins > ARRAY_SIZE(channel_sfx)) {
5276                 if (indexp)
5277                         *indexp = i;
5278                 return "";
5279         }
5280         return channel_sfx[i];
5281 }
5282
5283 static int fill_audio_out_name(struct hda_codec *codec, hda_nid_t nid,
5284                                const struct auto_pin_cfg *cfg,
5285                                const char *name, char *label, int maxlen,
5286                                int *indexp)
5287 {
5288         unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5289         int attr = snd_hda_get_input_pin_attr(def_conf);
5290         const char *pfx = "", *sfx = "";
5291
5292         /* handle as a speaker if it's a fixed line-out */
5293         if (!strcmp(name, "Line Out") && attr == INPUT_PIN_ATTR_INT)
5294                 name = "Speaker";
5295         /* check the location */
5296         switch (attr) {
5297         case INPUT_PIN_ATTR_DOCK:
5298                 pfx = "Dock ";
5299                 break;
5300         case INPUT_PIN_ATTR_FRONT:
5301                 pfx = "Front ";
5302                 break;
5303         }
5304         if (cfg) {
5305                 /* try to give a unique suffix if needed */
5306                 sfx = check_output_sfx(nid, cfg->line_out_pins, cfg->line_outs,
5307                                        indexp);
5308                 if (!sfx)
5309                         sfx = check_output_sfx(nid, cfg->speaker_pins, cfg->speaker_outs,
5310                                                indexp);
5311                 if (!sfx) {
5312                         /* don't add channel suffix for Headphone controls */
5313                         int idx = find_idx_in_nid_list(nid, cfg->hp_pins,
5314                                                        cfg->hp_outs);
5315                         if (idx >= 0)
5316                                 *indexp = idx;
5317                         sfx = "";
5318                 }
5319         }
5320         snprintf(label, maxlen, "%s%s%s", pfx, name, sfx);
5321         return 1;
5322 }
5323
5324 /**
5325  * snd_hda_get_pin_label - Get a label for the given I/O pin
5326  *
5327  * Get a label for the given pin.  This function works for both input and
5328  * output pins.  When @cfg is given as non-NULL, the function tries to get
5329  * an optimized label using hda_get_autocfg_input_label().
5330  *
5331  * This function tries to give a unique label string for the pin as much as
5332  * possible.  For example, when the multiple line-outs are present, it adds
5333  * the channel suffix like "Front", "Surround", etc (only when @cfg is given).
5334  * If no unique name with a suffix is available and @indexp is non-NULL, the
5335  * index number is stored in the pointer.
5336  */
5337 int snd_hda_get_pin_label(struct hda_codec *codec, hda_nid_t nid,
5338                           const struct auto_pin_cfg *cfg,
5339                           char *label, int maxlen, int *indexp)
5340 {
5341         unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5342         const char *name = NULL;
5343         int i;
5344
5345         if (indexp)
5346                 *indexp = 0;
5347         if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
5348                 return 0;
5349
5350         switch (get_defcfg_device(def_conf)) {
5351         case AC_JACK_LINE_OUT:
5352                 return fill_audio_out_name(codec, nid, cfg, "Line Out",
5353                                            label, maxlen, indexp);
5354         case AC_JACK_SPEAKER:
5355                 return fill_audio_out_name(codec, nid, cfg, "Speaker",
5356                                            label, maxlen, indexp);
5357         case AC_JACK_HP_OUT:
5358                 return fill_audio_out_name(codec, nid, cfg, "Headphone",
5359                                            label, maxlen, indexp);
5360         case AC_JACK_SPDIF_OUT:
5361         case AC_JACK_DIG_OTHER_OUT:
5362                 if (get_defcfg_location(def_conf) == AC_JACK_LOC_HDMI)
5363                         name = "HDMI";
5364                 else
5365                         name = "SPDIF";
5366                 if (cfg && indexp) {
5367                         i = find_idx_in_nid_list(nid, cfg->dig_out_pins,
5368                                                  cfg->dig_outs);
5369                         if (i >= 0)
5370                                 *indexp = i;
5371                 }
5372                 break;
5373         default:
5374                 if (cfg) {
5375                         for (i = 0; i < cfg->num_inputs; i++) {
5376                                 if (cfg->inputs[i].pin != nid)
5377                                         continue;
5378                                 name = hda_get_autocfg_input_label(codec, cfg, i);
5379                                 if (name)
5380                                         break;
5381                         }
5382                 }
5383                 if (!name)
5384                         name = hda_get_input_pin_label(codec, nid, true);
5385                 break;
5386         }
5387         if (!name)
5388                 return 0;
5389         strlcpy(label, name, maxlen);
5390         return 1;
5391 }
5392 EXPORT_SYMBOL_HDA(snd_hda_get_pin_label);
5393
5394 /**
5395  * snd_hda_add_imux_item - Add an item to input_mux
5396  *
5397  * When the same label is used already in the existing items, the number
5398  * suffix is appended to the label.  This label index number is stored
5399  * to type_idx when non-NULL pointer is given.
5400  */
5401 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5402                           int index, int *type_idx)
5403 {
5404         int i, label_idx = 0;
5405         if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5406                 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5407                 return -EINVAL;
5408         }
5409         for (i = 0; i < imux->num_items; i++) {
5410                 if (!strncmp(label, imux->items[i].label, strlen(label)))
5411                         label_idx++;
5412         }
5413         if (type_idx)
5414                 *type_idx = label_idx;
5415         if (label_idx > 0)
5416                 snprintf(imux->items[imux->num_items].label,
5417                          sizeof(imux->items[imux->num_items].label),
5418                          "%s %d", label, label_idx);
5419         else
5420                 strlcpy(imux->items[imux->num_items].label, label,
5421                         sizeof(imux->items[imux->num_items].label));
5422         imux->items[imux->num_items].index = index;
5423         imux->num_items++;
5424         return 0;
5425 }
5426 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5427
5428
5429 #ifdef CONFIG_PM
5430 /*
5431  * power management
5432  */
5433
5434 /**
5435  * snd_hda_suspend - suspend the codecs
5436  * @bus: the HDA bus
5437  *
5438  * Returns 0 if successful.
5439  */
5440 int snd_hda_suspend(struct hda_bus *bus)
5441 {
5442         struct hda_codec *codec;
5443
5444         list_for_each_entry(codec, &bus->codec_list, list) {
5445                 if (hda_codec_is_power_on(codec))
5446                         hda_call_codec_suspend(codec);
5447                 else /* forcibly change the power to D3 even if not used */
5448                         hda_set_power_state(codec,
5449                                             codec->afg ? codec->afg : codec->mfg,
5450                                             AC_PWRST_D3);
5451                 if (codec->patch_ops.post_suspend)
5452                         codec->patch_ops.post_suspend(codec);
5453         }
5454         return 0;
5455 }
5456 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5457
5458 /**
5459  * snd_hda_resume - resume the codecs
5460  * @bus: the HDA bus
5461  *
5462  * Returns 0 if successful.
5463  *
5464  * This function is defined only when POWER_SAVE isn't set.
5465  * In the power-save mode, the codec is resumed dynamically.
5466  */
5467 int snd_hda_resume(struct hda_bus *bus)
5468 {
5469         struct hda_codec *codec;
5470
5471         list_for_each_entry(codec, &bus->codec_list, list) {
5472                 if (codec->patch_ops.pre_resume)
5473                         codec->patch_ops.pre_resume(codec);
5474                 if (snd_hda_codec_needs_resume(codec))
5475                         hda_call_codec_resume(codec);
5476         }
5477         return 0;
5478 }
5479 EXPORT_SYMBOL_HDA(snd_hda_resume);
5480 #endif /* CONFIG_PM */
5481
5482 /*
5483  * generic arrays
5484  */
5485
5486 /**
5487  * snd_array_new - get a new element from the given array
5488  * @array: the array object
5489  *
5490  * Get a new element from the given array.  If it exceeds the
5491  * pre-allocated array size, re-allocate the array.
5492  *
5493  * Returns NULL if allocation failed.
5494  */
5495 void *snd_array_new(struct snd_array *array)
5496 {
5497         if (array->used >= array->alloced) {
5498                 int num = array->alloced + array->alloc_align;
5499                 int size = (num + 1) * array->elem_size;
5500                 int oldsize = array->alloced * array->elem_size;
5501                 void *nlist;
5502                 if (snd_BUG_ON(num >= 4096))
5503                         return NULL;
5504                 nlist = krealloc(array->list, size, GFP_KERNEL);
5505                 if (!nlist)
5506                         return NULL;
5507                 memset(nlist + oldsize, 0, size - oldsize);
5508                 array->list = nlist;
5509                 array->alloced = num;
5510         }
5511         return snd_array_elem(array, array->used++);
5512 }
5513 EXPORT_SYMBOL_HDA(snd_array_new);
5514
5515 /**
5516  * snd_array_free - free the given array elements
5517  * @array: the array object
5518  */
5519 void snd_array_free(struct snd_array *array)
5520 {
5521         kfree(array->list);
5522         array->used = 0;
5523         array->alloced = 0;
5524         array->list = NULL;
5525 }
5526 EXPORT_SYMBOL_HDA(snd_array_free);
5527
5528 /**
5529  * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5530  * @pcm: PCM caps bits
5531  * @buf: the string buffer to write
5532  * @buflen: the max buffer length
5533  *
5534  * used by hda_proc.c and hda_eld.c
5535  */
5536 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5537 {
5538         static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5539         int i, j;
5540
5541         for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5542                 if (pcm & (AC_SUPPCM_BITS_8 << i))
5543                         j += snprintf(buf + j, buflen - j,  " %d", bits[i]);
5544
5545         buf[j] = '\0'; /* necessary when j == 0 */
5546 }
5547 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5548
5549 MODULE_DESCRIPTION("HDA codec core");
5550 MODULE_LICENSE("GPL");