Merge commit 'main-jb-2012.08.03-B4' into t114-0806
[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_freezable_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         snd_hda_jack_tbl_clear(codec);
1196         restore_init_pincfgs(codec);
1197 #ifdef CONFIG_SND_HDA_POWER_SAVE
1198         cancel_delayed_work(&codec->power_work);
1199         flush_workqueue(codec->bus->workq);
1200 #endif
1201         list_del(&codec->list);
1202         snd_array_free(&codec->mixers);
1203         snd_array_free(&codec->nids);
1204         snd_array_free(&codec->cvt_setups);
1205         snd_array_free(&codec->conn_lists);
1206         snd_array_free(&codec->spdif_out);
1207         codec->bus->caddr_tbl[codec->addr] = NULL;
1208         if (codec->patch_ops.free)
1209                 codec->patch_ops.free(codec);
1210         module_put(codec->owner);
1211         free_hda_cache(&codec->amp_cache);
1212         free_hda_cache(&codec->cmd_cache);
1213         kfree(codec->vendor_name);
1214         kfree(codec->chip_name);
1215         kfree(codec->modelname);
1216         kfree(codec->wcaps);
1217         kfree(codec);
1218 }
1219
1220 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1221                                 unsigned int power_state);
1222
1223 /**
1224  * snd_hda_codec_new - create a HDA codec
1225  * @bus: the bus to assign
1226  * @codec_addr: the codec address
1227  * @codecp: the pointer to store the generated codec
1228  *
1229  * Returns 0 if successful, or a negative error code.
1230  */
1231 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
1232                                 unsigned int codec_addr,
1233                                 struct hda_codec **codecp)
1234 {
1235         struct hda_codec *codec;
1236         char component[31];
1237         int err;
1238
1239         if (snd_BUG_ON(!bus))
1240                 return -EINVAL;
1241         if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1242                 return -EINVAL;
1243
1244         if (bus->caddr_tbl[codec_addr]) {
1245                 snd_printk(KERN_ERR "hda_codec: "
1246                            "address 0x%x is already occupied\n", codec_addr);
1247                 return -EBUSY;
1248         }
1249
1250         codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1251         if (codec == NULL) {
1252                 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1253                 return -ENOMEM;
1254         }
1255
1256         codec->bus = bus;
1257         codec->addr = codec_addr;
1258         mutex_init(&codec->spdif_mutex);
1259         mutex_init(&codec->control_mutex);
1260         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1261         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1262         snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1263         snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1264         snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1265         snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1266         snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1267         snd_array_init(&codec->conn_lists, sizeof(hda_nid_t), 64);
1268         snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1269         if (codec->bus->modelname) {
1270                 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1271                 if (!codec->modelname) {
1272                         snd_hda_codec_free(codec);
1273                         return -ENODEV;
1274                 }
1275         }
1276
1277 #ifdef CONFIG_SND_HDA_POWER_SAVE
1278         INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1279         /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1280          * the caller has to power down appropriatley after initialization
1281          * phase.
1282          */
1283         hda_keep_power_on(codec);
1284 #endif
1285
1286         list_add_tail(&codec->list, &bus->codec_list);
1287         bus->caddr_tbl[codec_addr] = codec;
1288
1289         codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1290                                               AC_PAR_VENDOR_ID);
1291         if (codec->vendor_id == -1)
1292                 /* read again, hopefully the access method was corrected
1293                  * in the last read...
1294                  */
1295                 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1296                                                       AC_PAR_VENDOR_ID);
1297         codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1298                                                  AC_PAR_SUBSYSTEM_ID);
1299         codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1300                                                 AC_PAR_REV_ID);
1301
1302         setup_fg_nodes(codec);
1303         if (!codec->afg && !codec->mfg) {
1304                 snd_printdd("hda_codec: no AFG or MFG node found\n");
1305                 err = -ENODEV;
1306                 goto error;
1307         }
1308
1309         err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1310         if (err < 0) {
1311                 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1312                 goto error;
1313         }
1314         err = read_pin_defaults(codec);
1315         if (err < 0)
1316                 goto error;
1317
1318         if (!codec->subsystem_id) {
1319                 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
1320                 codec->subsystem_id =
1321                         snd_hda_codec_read(codec, nid, 0,
1322                                            AC_VERB_GET_SUBSYSTEM_ID, 0);
1323         }
1324
1325         /* power-up all before initialization */
1326         hda_set_power_state(codec,
1327                             codec->afg ? codec->afg : codec->mfg,
1328                             AC_PWRST_D0);
1329
1330         snd_hda_codec_proc_new(codec);
1331
1332         snd_hda_create_hwdep(codec);
1333
1334         sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1335                 codec->subsystem_id, codec->revision_id);
1336         snd_component_add(codec->bus->card, component);
1337
1338         if (codecp)
1339                 *codecp = codec;
1340         return 0;
1341
1342  error:
1343         snd_hda_codec_free(codec);
1344         return err;
1345 }
1346 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1347
1348 /**
1349  * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1350  * @codec: the HDA codec
1351  *
1352  * Start parsing of the given codec tree and (re-)initialize the whole
1353  * patch instance.
1354  *
1355  * Returns 0 if successful or a negative error code.
1356  */
1357 int snd_hda_codec_configure(struct hda_codec *codec)
1358 {
1359         int err;
1360
1361         codec->preset = find_codec_preset(codec);
1362         if (!codec->vendor_name || !codec->chip_name) {
1363                 err = get_codec_name(codec);
1364                 if (err < 0)
1365                         return err;
1366         }
1367
1368         if (is_generic_config(codec)) {
1369                 err = snd_hda_parse_generic_codec(codec);
1370                 goto patched;
1371         }
1372         if (codec->preset && codec->preset->patch) {
1373                 err = codec->preset->patch(codec);
1374                 goto patched;
1375         }
1376
1377         /* call the default parser */
1378         err = snd_hda_parse_generic_codec(codec);
1379         if (err < 0)
1380                 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1381
1382  patched:
1383         if (!err && codec->patch_ops.unsol_event)
1384                 err = init_unsol_queue(codec->bus);
1385         /* audio codec should override the mixer name */
1386         if (!err && (codec->afg || !*codec->bus->card->mixername))
1387                 snprintf(codec->bus->card->mixername,
1388                          sizeof(codec->bus->card->mixername),
1389                          "%s %s", codec->vendor_name, codec->chip_name);
1390         return err;
1391 }
1392 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1393
1394 /**
1395  * snd_hda_codec_setup_stream - set up the codec for streaming
1396  * @codec: the CODEC to set up
1397  * @nid: the NID to set up
1398  * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1399  * @channel_id: channel id to pass, zero based.
1400  * @format: stream format.
1401  */
1402 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1403                                 u32 stream_tag,
1404                                 int channel_id, int format)
1405 {
1406         struct hda_codec *c;
1407         struct hda_cvt_setup *p;
1408         unsigned int oldval, newval;
1409         int type;
1410         int i;
1411
1412         if (!nid)
1413                 return;
1414
1415         snd_printdd("hda_codec_setup_stream: "
1416                     "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1417                     nid, stream_tag, channel_id, format);
1418         p = get_hda_cvt_setup(codec, nid);
1419         if (!p)
1420                 return;
1421         /* update the stream-id if changed */
1422         if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1423                 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1424                 newval = (stream_tag << 4) | channel_id;
1425                 if (oldval != newval)
1426                         snd_hda_codec_write(codec, nid, 0,
1427                                             AC_VERB_SET_CHANNEL_STREAMID,
1428                                             newval);
1429                 p->stream_tag = stream_tag;
1430                 p->channel_id = channel_id;
1431         }
1432         /* update the format-id if changed */
1433         if (p->format_id != format) {
1434                 oldval = snd_hda_codec_read(codec, nid, 0,
1435                                             AC_VERB_GET_STREAM_FORMAT, 0);
1436                 if (oldval != format) {
1437                         msleep(1);
1438                         snd_hda_codec_write(codec, nid, 0,
1439                                             AC_VERB_SET_STREAM_FORMAT,
1440                                             format);
1441                 }
1442                 p->format_id = format;
1443         }
1444         p->active = 1;
1445         p->dirty = 0;
1446
1447         /* make other inactive cvts with the same stream-tag dirty */
1448         type = get_wcaps_type(get_wcaps(codec, nid));
1449         list_for_each_entry(c, &codec->bus->codec_list, list) {
1450                 for (i = 0; i < c->cvt_setups.used; i++) {
1451                         p = snd_array_elem(&c->cvt_setups, i);
1452                         if (!p->active && p->stream_tag == stream_tag &&
1453                             get_wcaps_type(get_wcaps(c, p->nid)) == type)
1454                                 p->dirty = 1;
1455                 }
1456         }
1457 }
1458 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1459
1460 static void really_cleanup_stream(struct hda_codec *codec,
1461                                   struct hda_cvt_setup *q);
1462
1463 /**
1464  * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1465  * @codec: the CODEC to clean up
1466  * @nid: the NID to clean up
1467  * @do_now: really clean up the stream instead of clearing the active flag
1468  */
1469 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1470                                     int do_now)
1471 {
1472         struct hda_cvt_setup *p;
1473
1474         if (!nid)
1475                 return;
1476
1477         if (codec->no_sticky_stream)
1478                 do_now = 1;
1479
1480         snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1481         p = get_hda_cvt_setup(codec, nid);
1482         if (p) {
1483                 /* here we just clear the active flag when do_now isn't set;
1484                  * actual clean-ups will be done later in
1485                  * purify_inactive_streams() called from snd_hda_codec_prpapre()
1486                  */
1487                 if (do_now)
1488                         really_cleanup_stream(codec, p);
1489                 else
1490                         p->active = 0;
1491         }
1492 }
1493 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1494
1495 static void really_cleanup_stream(struct hda_codec *codec,
1496                                   struct hda_cvt_setup *q)
1497 {
1498         hda_nid_t nid = q->nid;
1499         if (q->stream_tag || q->channel_id)
1500                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1501         if (q->format_id)
1502                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1503 );
1504         memset(q, 0, sizeof(*q));
1505         q->nid = nid;
1506 }
1507
1508 /* clean up the all conflicting obsolete streams */
1509 static void purify_inactive_streams(struct hda_codec *codec)
1510 {
1511         struct hda_codec *c;
1512         int i;
1513
1514         list_for_each_entry(c, &codec->bus->codec_list, list) {
1515                 for (i = 0; i < c->cvt_setups.used; i++) {
1516                         struct hda_cvt_setup *p;
1517                         p = snd_array_elem(&c->cvt_setups, i);
1518                         if (p->dirty)
1519                                 really_cleanup_stream(c, p);
1520                 }
1521         }
1522 }
1523
1524 #ifdef CONFIG_PM
1525 /* clean up all streams; called from suspend */
1526 static void hda_cleanup_all_streams(struct hda_codec *codec)
1527 {
1528         int i;
1529
1530         for (i = 0; i < codec->cvt_setups.used; i++) {
1531                 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1532                 if (p->stream_tag)
1533                         really_cleanup_stream(codec, p);
1534         }
1535 }
1536 #endif
1537
1538 /*
1539  * amp access functions
1540  */
1541
1542 /* FIXME: more better hash key? */
1543 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1544 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1545 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1546 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1547 #define INFO_AMP_CAPS   (1<<0)
1548 #define INFO_AMP_VOL(ch)        (1 << (1 + (ch)))
1549
1550 /* initialize the hash table */
1551 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1552                                      unsigned int record_size)
1553 {
1554         memset(cache, 0, sizeof(*cache));
1555         memset(cache->hash, 0xff, sizeof(cache->hash));
1556         snd_array_init(&cache->buf, record_size, 64);
1557 }
1558
1559 static void free_hda_cache(struct hda_cache_rec *cache)
1560 {
1561         snd_array_free(&cache->buf);
1562 }
1563
1564 /* query the hash.  allocate an entry if not found. */
1565 static struct hda_cache_head  *get_hash(struct hda_cache_rec *cache, u32 key)
1566 {
1567         u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1568         u16 cur = cache->hash[idx];
1569         struct hda_cache_head *info;
1570
1571         while (cur != 0xffff) {
1572                 info = snd_array_elem(&cache->buf, cur);
1573                 if (info->key == key)
1574                         return info;
1575                 cur = info->next;
1576         }
1577         return NULL;
1578 }
1579
1580 /* query the hash.  allocate an entry if not found. */
1581 static struct hda_cache_head  *get_alloc_hash(struct hda_cache_rec *cache,
1582                                               u32 key)
1583 {
1584         struct hda_cache_head *info = get_hash(cache, key);
1585         if (!info) {
1586                 u16 idx, cur;
1587                 /* add a new hash entry */
1588                 info = snd_array_new(&cache->buf);
1589                 if (!info)
1590                         return NULL;
1591                 cur = snd_array_index(&cache->buf, info);
1592                 info->key = key;
1593                 info->val = 0;
1594                 idx = key % (u16)ARRAY_SIZE(cache->hash);
1595                 info->next = cache->hash[idx];
1596                 cache->hash[idx] = cur;
1597         }
1598         return info;
1599 }
1600
1601 /* query and allocate an amp hash entry */
1602 static inline struct hda_amp_info *
1603 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1604 {
1605         return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1606 }
1607
1608 /**
1609  * query_amp_caps - query AMP capabilities
1610  * @codec: the HD-auio codec
1611  * @nid: the NID to query
1612  * @direction: either #HDA_INPUT or #HDA_OUTPUT
1613  *
1614  * Query AMP capabilities for the given widget and direction.
1615  * Returns the obtained capability bits.
1616  *
1617  * When cap bits have been already read, this doesn't read again but
1618  * returns the cached value.
1619  */
1620 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1621 {
1622         struct hda_amp_info *info;
1623
1624         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1625         if (!info)
1626                 return 0;
1627         if (!(info->head.val & INFO_AMP_CAPS)) {
1628                 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1629                         nid = codec->afg;
1630                 info->amp_caps = snd_hda_param_read(codec, nid,
1631                                                     direction == HDA_OUTPUT ?
1632                                                     AC_PAR_AMP_OUT_CAP :
1633                                                     AC_PAR_AMP_IN_CAP);
1634                 if (info->amp_caps)
1635                         info->head.val |= INFO_AMP_CAPS;
1636         }
1637         return info->amp_caps;
1638 }
1639 EXPORT_SYMBOL_HDA(query_amp_caps);
1640
1641 /**
1642  * snd_hda_override_amp_caps - Override the AMP capabilities
1643  * @codec: the CODEC to clean up
1644  * @nid: the NID to clean up
1645  * @direction: either #HDA_INPUT or #HDA_OUTPUT
1646  * @caps: the capability bits to set
1647  *
1648  * Override the cached AMP caps bits value by the given one.
1649  * This function is useful if the driver needs to adjust the AMP ranges,
1650  * e.g. limit to 0dB, etc.
1651  *
1652  * Returns zero if successful or a negative error code.
1653  */
1654 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1655                               unsigned int caps)
1656 {
1657         struct hda_amp_info *info;
1658
1659         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1660         if (!info)
1661                 return -EINVAL;
1662         info->amp_caps = caps;
1663         info->head.val |= INFO_AMP_CAPS;
1664         return 0;
1665 }
1666 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1667
1668 static unsigned int
1669 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1670                 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1671 {
1672         struct hda_amp_info *info;
1673
1674         info = get_alloc_amp_hash(codec, key);
1675         if (!info)
1676                 return 0;
1677         if (!info->head.val) {
1678                 info->head.val |= INFO_AMP_CAPS;
1679                 info->amp_caps = func(codec, nid);
1680         }
1681         return info->amp_caps;
1682 }
1683
1684 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1685 {
1686         return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1687 }
1688
1689 /**
1690  * snd_hda_query_pin_caps - Query PIN capabilities
1691  * @codec: the HD-auio codec
1692  * @nid: the NID to query
1693  *
1694  * Query PIN capabilities for the given widget.
1695  * Returns the obtained capability bits.
1696  *
1697  * When cap bits have been already read, this doesn't read again but
1698  * returns the cached value.
1699  */
1700 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1701 {
1702         return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1703                                read_pin_cap);
1704 }
1705 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1706
1707 /**
1708  * snd_hda_override_pin_caps - Override the pin capabilities
1709  * @codec: the CODEC
1710  * @nid: the NID to override
1711  * @caps: the capability bits to set
1712  *
1713  * Override the cached PIN capabilitiy bits value by the given one.
1714  *
1715  * Returns zero if successful or a negative error code.
1716  */
1717 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1718                               unsigned int caps)
1719 {
1720         struct hda_amp_info *info;
1721         info = get_alloc_amp_hash(codec, HDA_HASH_PINCAP_KEY(nid));
1722         if (!info)
1723                 return -ENOMEM;
1724         info->amp_caps = caps;
1725         info->head.val |= INFO_AMP_CAPS;
1726         return 0;
1727 }
1728 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1729
1730 /*
1731  * read the current volume to info
1732  * if the cache exists, read the cache value.
1733  */
1734 static unsigned int get_vol_mute(struct hda_codec *codec,
1735                                  struct hda_amp_info *info, hda_nid_t nid,
1736                                  int ch, int direction, int index)
1737 {
1738         u32 val, parm;
1739
1740         if (info->head.val & INFO_AMP_VOL(ch))
1741                 return info->vol[ch];
1742
1743         parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1744         parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1745         parm |= index;
1746         val = snd_hda_codec_read(codec, nid, 0,
1747                                  AC_VERB_GET_AMP_GAIN_MUTE, parm);
1748         info->vol[ch] = val & 0xff;
1749         info->head.val |= INFO_AMP_VOL(ch);
1750         return info->vol[ch];
1751 }
1752
1753 /*
1754  * write the current volume in info to the h/w and update the cache
1755  */
1756 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1757                          hda_nid_t nid, int ch, int direction, int index,
1758                          int val)
1759 {
1760         u32 parm;
1761
1762         parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1763         parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1764         parm |= index << AC_AMP_SET_INDEX_SHIFT;
1765         if ((val & HDA_AMP_MUTE) && !(info->amp_caps & AC_AMPCAP_MUTE) &&
1766             (info->amp_caps & AC_AMPCAP_MIN_MUTE))
1767                 ; /* set the zero value as a fake mute */
1768         else
1769                 parm |= val;
1770         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1771         info->vol[ch] = val;
1772 }
1773
1774 /**
1775  * snd_hda_codec_amp_read - Read AMP value
1776  * @codec: HD-audio codec
1777  * @nid: NID to read the AMP value
1778  * @ch: channel (left=0 or right=1)
1779  * @direction: #HDA_INPUT or #HDA_OUTPUT
1780  * @index: the index value (only for input direction)
1781  *
1782  * Read AMP value.  The volume is between 0 to 0x7f, 0x80 = mute bit.
1783  */
1784 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1785                            int direction, int index)
1786 {
1787         struct hda_amp_info *info;
1788         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1789         if (!info)
1790                 return 0;
1791         return get_vol_mute(codec, info, nid, ch, direction, index);
1792 }
1793 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1794
1795 /**
1796  * snd_hda_codec_amp_update - update the AMP value
1797  * @codec: HD-audio codec
1798  * @nid: NID to read the AMP value
1799  * @ch: channel (left=0 or right=1)
1800  * @direction: #HDA_INPUT or #HDA_OUTPUT
1801  * @idx: the index value (only for input direction)
1802  * @mask: bit mask to set
1803  * @val: the bits value to set
1804  *
1805  * Update the AMP value with a bit mask.
1806  * Returns 0 if the value is unchanged, 1 if changed.
1807  */
1808 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1809                              int direction, int idx, int mask, int val)
1810 {
1811         struct hda_amp_info *info;
1812
1813         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1814         if (!info)
1815                 return 0;
1816         if (snd_BUG_ON(mask & ~0xff))
1817                 mask &= 0xff;
1818         val &= mask;
1819         val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1820         if (info->vol[ch] == val)
1821                 return 0;
1822         put_vol_mute(codec, info, nid, ch, direction, idx, val);
1823         return 1;
1824 }
1825 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1826
1827 /**
1828  * snd_hda_codec_amp_stereo - update the AMP stereo values
1829  * @codec: HD-audio codec
1830  * @nid: NID to read the AMP value
1831  * @direction: #HDA_INPUT or #HDA_OUTPUT
1832  * @idx: the index value (only for input direction)
1833  * @mask: bit mask to set
1834  * @val: the bits value to set
1835  *
1836  * Update the AMP values like snd_hda_codec_amp_update(), but for a
1837  * stereo widget with the same mask and value.
1838  */
1839 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1840                              int direction, int idx, int mask, int val)
1841 {
1842         int ch, ret = 0;
1843
1844         if (snd_BUG_ON(mask & ~0xff))
1845                 mask &= 0xff;
1846         for (ch = 0; ch < 2; ch++)
1847                 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1848                                                 idx, mask, val);
1849         return ret;
1850 }
1851 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1852
1853 #ifdef CONFIG_PM
1854 /**
1855  * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1856  * @codec: HD-audio codec
1857  *
1858  * Resume the all amp commands from the cache.
1859  */
1860 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1861 {
1862         struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1863         int i;
1864
1865         for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1866                 u32 key = buffer->head.key;
1867                 hda_nid_t nid;
1868                 unsigned int idx, dir, ch;
1869                 if (!key)
1870                         continue;
1871                 nid = key & 0xff;
1872                 idx = (key >> 16) & 0xff;
1873                 dir = (key >> 24) & 0xff;
1874                 for (ch = 0; ch < 2; ch++) {
1875                         if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1876                                 continue;
1877                         put_vol_mute(codec, buffer, nid, ch, dir, idx,
1878                                      buffer->vol[ch]);
1879                 }
1880         }
1881 }
1882 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1883 #endif /* CONFIG_PM */
1884
1885 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1886                              unsigned int ofs)
1887 {
1888         u32 caps = query_amp_caps(codec, nid, dir);
1889         /* get num steps */
1890         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1891         if (ofs < caps)
1892                 caps -= ofs;
1893         return caps;
1894 }
1895
1896 /**
1897  * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1898  *
1899  * The control element is supposed to have the private_value field
1900  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1901  */
1902 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1903                                   struct snd_ctl_elem_info *uinfo)
1904 {
1905         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1906         u16 nid = get_amp_nid(kcontrol);
1907         u8 chs = get_amp_channels(kcontrol);
1908         int dir = get_amp_direction(kcontrol);
1909         unsigned int ofs = get_amp_offset(kcontrol);
1910
1911         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1912         uinfo->count = chs == 3 ? 2 : 1;
1913         uinfo->value.integer.min = 0;
1914         uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1915         if (!uinfo->value.integer.max) {
1916                 printk(KERN_WARNING "hda_codec: "
1917                        "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1918                        kcontrol->id.name);
1919                 return -EINVAL;
1920         }
1921         return 0;
1922 }
1923 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1924
1925
1926 static inline unsigned int
1927 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1928                int ch, int dir, int idx, unsigned int ofs)
1929 {
1930         unsigned int val;
1931         val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1932         val &= HDA_AMP_VOLMASK;
1933         if (val >= ofs)
1934                 val -= ofs;
1935         else
1936                 val = 0;
1937         return val;
1938 }
1939
1940 static inline int
1941 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1942                  int ch, int dir, int idx, unsigned int ofs,
1943                  unsigned int val)
1944 {
1945         unsigned int maxval;
1946
1947         if (val > 0)
1948                 val += ofs;
1949         /* ofs = 0: raw max value */
1950         maxval = get_amp_max_value(codec, nid, dir, 0);
1951         if (val > maxval)
1952                 val = maxval;
1953         return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1954                                         HDA_AMP_VOLMASK, val);
1955 }
1956
1957 /**
1958  * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1959  *
1960  * The control element is supposed to have the private_value field
1961  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1962  */
1963 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1964                                  struct snd_ctl_elem_value *ucontrol)
1965 {
1966         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1967         hda_nid_t nid = get_amp_nid(kcontrol);
1968         int chs = get_amp_channels(kcontrol);
1969         int dir = get_amp_direction(kcontrol);
1970         int idx = get_amp_index(kcontrol);
1971         unsigned int ofs = get_amp_offset(kcontrol);
1972         long *valp = ucontrol->value.integer.value;
1973
1974         if (chs & 1)
1975                 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1976         if (chs & 2)
1977                 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1978         return 0;
1979 }
1980 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1981
1982 /**
1983  * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1984  *
1985  * The control element is supposed to have the private_value field
1986  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1987  */
1988 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1989                                  struct snd_ctl_elem_value *ucontrol)
1990 {
1991         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1992         hda_nid_t nid = get_amp_nid(kcontrol);
1993         int chs = get_amp_channels(kcontrol);
1994         int dir = get_amp_direction(kcontrol);
1995         int idx = get_amp_index(kcontrol);
1996         unsigned int ofs = get_amp_offset(kcontrol);
1997         long *valp = ucontrol->value.integer.value;
1998         int change = 0;
1999
2000         snd_hda_power_up(codec);
2001         if (chs & 1) {
2002                 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2003                 valp++;
2004         }
2005         if (chs & 2)
2006                 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2007         snd_hda_power_down(codec);
2008         return change;
2009 }
2010 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
2011
2012 /**
2013  * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2014  *
2015  * The control element is supposed to have the private_value field
2016  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2017  */
2018 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2019                           unsigned int size, unsigned int __user *_tlv)
2020 {
2021         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2022         hda_nid_t nid = get_amp_nid(kcontrol);
2023         int dir = get_amp_direction(kcontrol);
2024         unsigned int ofs = get_amp_offset(kcontrol);
2025         bool min_mute = get_amp_min_mute(kcontrol);
2026         u32 caps, val1, val2;
2027
2028         if (size < 4 * sizeof(unsigned int))
2029                 return -ENOMEM;
2030         caps = query_amp_caps(codec, nid, dir);
2031         val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2032         val2 = (val2 + 1) * 25;
2033         val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2034         val1 += ofs;
2035         val1 = ((int)val1) * ((int)val2);
2036         if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
2037                 val2 |= TLV_DB_SCALE_MUTE;
2038         if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2039                 return -EFAULT;
2040         if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2041                 return -EFAULT;
2042         if (put_user(val1, _tlv + 2))
2043                 return -EFAULT;
2044         if (put_user(val2, _tlv + 3))
2045                 return -EFAULT;
2046         return 0;
2047 }
2048 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
2049
2050 /**
2051  * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2052  * @codec: HD-audio codec
2053  * @nid: NID of a reference widget
2054  * @dir: #HDA_INPUT or #HDA_OUTPUT
2055  * @tlv: TLV data to be stored, at least 4 elements
2056  *
2057  * Set (static) TLV data for a virtual master volume using the AMP caps
2058  * obtained from the reference NID.
2059  * The volume range is recalculated as if the max volume is 0dB.
2060  */
2061 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2062                              unsigned int *tlv)
2063 {
2064         u32 caps;
2065         int nums, step;
2066
2067         caps = query_amp_caps(codec, nid, dir);
2068         nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2069         step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2070         step = (step + 1) * 25;
2071         tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2072         tlv[1] = 2 * sizeof(unsigned int);
2073         tlv[2] = -nums * step;
2074         tlv[3] = step;
2075 }
2076 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2077
2078 /* find a mixer control element with the given name */
2079 static struct snd_kcontrol *
2080 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
2081                         const char *name, int idx)
2082 {
2083         struct snd_ctl_elem_id id;
2084         memset(&id, 0, sizeof(id));
2085         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2086         id.index = idx;
2087         if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2088                 return NULL;
2089         strcpy(id.name, name);
2090         return snd_ctl_find_id(codec->bus->card, &id);
2091 }
2092
2093 /**
2094  * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2095  * @codec: HD-audio codec
2096  * @name: ctl id name string
2097  *
2098  * Get the control element with the given id string and IFACE_MIXER.
2099  */
2100 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2101                                             const char *name)
2102 {
2103         return _snd_hda_find_mixer_ctl(codec, name, 0);
2104 }
2105 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
2106
2107 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name)
2108 {
2109         int idx;
2110         for (idx = 0; idx < 16; idx++) { /* 16 ctlrs should be large enough */
2111                 if (!_snd_hda_find_mixer_ctl(codec, name, idx))
2112                         return idx;
2113         }
2114         return -EBUSY;
2115 }
2116
2117 /**
2118  * snd_hda_ctl_add - Add a control element and assign to the codec
2119  * @codec: HD-audio codec
2120  * @nid: corresponding NID (optional)
2121  * @kctl: the control element to assign
2122  *
2123  * Add the given control element to an array inside the codec instance.
2124  * All control elements belonging to a codec are supposed to be added
2125  * by this function so that a proper clean-up works at the free or
2126  * reconfiguration time.
2127  *
2128  * If non-zero @nid is passed, the NID is assigned to the control element.
2129  * The assignment is shown in the codec proc file.
2130  *
2131  * snd_hda_ctl_add() checks the control subdev id field whether
2132  * #HDA_SUBDEV_NID_FLAG bit is set.  If set (and @nid is zero), the lower
2133  * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2134  * specifies if kctl->private_value is a HDA amplifier value.
2135  */
2136 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2137                     struct snd_kcontrol *kctl)
2138 {
2139         int err;
2140         unsigned short flags = 0;
2141         struct hda_nid_item *item;
2142
2143         if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2144                 flags |= HDA_NID_ITEM_AMP;
2145                 if (nid == 0)
2146                         nid = get_amp_nid_(kctl->private_value);
2147         }
2148         if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2149                 nid = kctl->id.subdevice & 0xffff;
2150         if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2151                 kctl->id.subdevice = 0;
2152         err = snd_ctl_add(codec->bus->card, kctl);
2153         if (err < 0)
2154                 return err;
2155         item = snd_array_new(&codec->mixers);
2156         if (!item)
2157                 return -ENOMEM;
2158         item->kctl = kctl;
2159         item->nid = nid;
2160         item->flags = flags;
2161         return 0;
2162 }
2163 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
2164
2165 /**
2166  * snd_hda_add_nid - Assign a NID to a control element
2167  * @codec: HD-audio codec
2168  * @nid: corresponding NID (optional)
2169  * @kctl: the control element to assign
2170  * @index: index to kctl
2171  *
2172  * Add the given control element to an array inside the codec instance.
2173  * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2174  * NID:KCTL mapping - for example "Capture Source" selector.
2175  */
2176 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2177                     unsigned int index, hda_nid_t nid)
2178 {
2179         struct hda_nid_item *item;
2180
2181         if (nid > 0) {
2182                 item = snd_array_new(&codec->nids);
2183                 if (!item)
2184                         return -ENOMEM;
2185                 item->kctl = kctl;
2186                 item->index = index;
2187                 item->nid = nid;
2188                 return 0;
2189         }
2190         printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2191                kctl->id.name, kctl->id.index, index);
2192         return -EINVAL;
2193 }
2194 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2195
2196 /**
2197  * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2198  * @codec: HD-audio codec
2199  */
2200 void snd_hda_ctls_clear(struct hda_codec *codec)
2201 {
2202         int i;
2203         struct hda_nid_item *items = codec->mixers.list;
2204         for (i = 0; i < codec->mixers.used; i++)
2205                 snd_ctl_remove(codec->bus->card, items[i].kctl);
2206         snd_array_free(&codec->mixers);
2207         snd_array_free(&codec->nids);
2208 }
2209
2210 /* pseudo device locking
2211  * toggle card->shutdown to allow/disallow the device access (as a hack)
2212  */
2213 static int hda_lock_devices(struct snd_card *card)
2214 {
2215         spin_lock(&card->files_lock);
2216         if (card->shutdown) {
2217                 spin_unlock(&card->files_lock);
2218                 return -EINVAL;
2219         }
2220         card->shutdown = 1;
2221         spin_unlock(&card->files_lock);
2222         return 0;
2223 }
2224
2225 static void hda_unlock_devices(struct snd_card *card)
2226 {
2227         spin_lock(&card->files_lock);
2228         card->shutdown = 0;
2229         spin_unlock(&card->files_lock);
2230 }
2231
2232 /**
2233  * snd_hda_codec_reset - Clear all objects assigned to the codec
2234  * @codec: HD-audio codec
2235  *
2236  * This frees the all PCM and control elements assigned to the codec, and
2237  * clears the caches and restores the pin default configurations.
2238  *
2239  * When a device is being used, it returns -EBSY.  If successfully freed,
2240  * returns zero.
2241  */
2242 int snd_hda_codec_reset(struct hda_codec *codec)
2243 {
2244         struct snd_card *card = codec->bus->card;
2245         int i, pcm;
2246
2247         if (hda_lock_devices(card) < 0)
2248                 return -EBUSY;
2249         /* check whether the codec isn't used by any mixer or PCM streams */
2250         if (!list_empty(&card->ctl_files)) {
2251                 hda_unlock_devices(card);
2252                 return -EBUSY;
2253         }
2254         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2255                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2256                 if (!cpcm->pcm)
2257                         continue;
2258                 if (cpcm->pcm->streams[0].substream_opened ||
2259                     cpcm->pcm->streams[1].substream_opened) {
2260                         hda_unlock_devices(card);
2261                         return -EBUSY;
2262                 }
2263         }
2264
2265         /* OK, let it free */
2266
2267 #ifdef CONFIG_SND_HDA_POWER_SAVE
2268         cancel_delayed_work(&codec->power_work);
2269         flush_workqueue(codec->bus->workq);
2270 #endif
2271         snd_hda_ctls_clear(codec);
2272         /* relase PCMs */
2273         for (i = 0; i < codec->num_pcms; i++) {
2274                 if (codec->pcm_info[i].pcm) {
2275                         snd_device_free(card, codec->pcm_info[i].pcm);
2276                         clear_bit(codec->pcm_info[i].device,
2277                                   codec->bus->pcm_dev_bits);
2278                 }
2279         }
2280         if (codec->patch_ops.free)
2281                 codec->patch_ops.free(codec);
2282         snd_hda_jack_tbl_clear(codec);
2283         codec->proc_widget_hook = NULL;
2284         codec->spec = NULL;
2285         free_hda_cache(&codec->amp_cache);
2286         free_hda_cache(&codec->cmd_cache);
2287         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2288         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2289         /* free only driver_pins so that init_pins + user_pins are restored */
2290         snd_array_free(&codec->driver_pins);
2291         restore_pincfgs(codec);
2292         codec->num_pcms = 0;
2293         codec->pcm_info = NULL;
2294         codec->preset = NULL;
2295         memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2296         codec->slave_dig_outs = NULL;
2297         codec->spdif_status_reset = 0;
2298         module_put(codec->owner);
2299         codec->owner = NULL;
2300
2301         /* allow device access again */
2302         hda_unlock_devices(card);
2303         return 0;
2304 }
2305
2306 typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2307
2308 /* apply the function to all matching slave ctls in the mixer list */
2309 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2310                       const char *suffix, map_slave_func_t func, void *data) 
2311 {
2312         struct hda_nid_item *items;
2313         const char * const *s;
2314         int i, err;
2315
2316         items = codec->mixers.list;
2317         for (i = 0; i < codec->mixers.used; i++) {
2318                 struct snd_kcontrol *sctl = items[i].kctl;
2319                 if (!sctl || !sctl->id.name ||
2320                     sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2321                         continue;
2322                 for (s = slaves; *s; s++) {
2323                         char tmpname[sizeof(sctl->id.name)];
2324                         const char *name = *s;
2325                         if (suffix) {
2326                                 snprintf(tmpname, sizeof(tmpname), "%s %s",
2327                                          name, suffix);
2328                                 name = tmpname;
2329                         }
2330                         if (!strcmp(sctl->id.name, name)) {
2331                                 err = func(data, sctl);
2332                                 if (err)
2333                                         return err;
2334                                 break;
2335                         }
2336                 }
2337         }
2338         return 0;
2339 }
2340
2341 static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2342 {
2343         return 1;
2344 }
2345
2346 /* guess the value corresponding to 0dB */
2347 static int get_kctl_0dB_offset(struct snd_kcontrol *kctl)
2348 {
2349         int _tlv[4];
2350         const int *tlv = NULL;
2351         int val = -1;
2352
2353         if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2354                 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2355                 mm_segment_t fs = get_fs();
2356                 set_fs(get_ds());
2357                 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2358                         tlv = _tlv;
2359                 set_fs(fs);
2360         } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2361                 tlv = kctl->tlv.p;
2362         if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE)
2363                 val = -tlv[2] / tlv[3];
2364         return val;
2365 }
2366
2367 /* call kctl->put with the given value(s) */
2368 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2369 {
2370         struct snd_ctl_elem_value *ucontrol;
2371         ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2372         if (!ucontrol)
2373                 return -ENOMEM;
2374         ucontrol->value.integer.value[0] = val;
2375         ucontrol->value.integer.value[1] = val;
2376         kctl->put(kctl, ucontrol);
2377         kfree(ucontrol);
2378         return 0;
2379 }
2380
2381 /* initialize the slave volume with 0dB */
2382 static int init_slave_0dB(void *data, struct snd_kcontrol *slave)
2383 {
2384         int offset = get_kctl_0dB_offset(slave);
2385         if (offset > 0)
2386                 put_kctl_with_value(slave, offset);
2387         return 0;
2388 }
2389
2390 /* unmute the slave */
2391 static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2392 {
2393         return put_kctl_with_value(slave, 1);
2394 }
2395
2396 /**
2397  * snd_hda_add_vmaster - create a virtual master control and add slaves
2398  * @codec: HD-audio codec
2399  * @name: vmaster control name
2400  * @tlv: TLV data (optional)
2401  * @slaves: slave control names (optional)
2402  * @suffix: suffix string to each slave name (optional)
2403  * @init_slave_vol: initialize slaves to unmute/0dB
2404  * @ctl_ret: store the vmaster kcontrol in return
2405  *
2406  * Create a virtual master control with the given name.  The TLV data
2407  * must be either NULL or a valid data.
2408  *
2409  * @slaves is a NULL-terminated array of strings, each of which is a
2410  * slave control name.  All controls with these names are assigned to
2411  * the new virtual master control.
2412  *
2413  * This function returns zero if successful or a negative error code.
2414  */
2415 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2416                         unsigned int *tlv, const char * const *slaves,
2417                           const char *suffix, bool init_slave_vol,
2418                           struct snd_kcontrol **ctl_ret)
2419 {
2420         struct snd_kcontrol *kctl;
2421         int err;
2422
2423         if (ctl_ret)
2424                 *ctl_ret = NULL;
2425
2426         err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2427         if (err != 1) {
2428                 snd_printdd("No slave found for %s\n", name);
2429                 return 0;
2430         }
2431         kctl = snd_ctl_make_virtual_master(name, tlv);
2432         if (!kctl)
2433                 return -ENOMEM;
2434         err = snd_hda_ctl_add(codec, 0, kctl);
2435         if (err < 0)
2436                 return err;
2437
2438         err = map_slaves(codec, slaves, suffix,
2439                          (map_slave_func_t)snd_ctl_add_slave, kctl);
2440         if (err < 0)
2441                 return err;
2442
2443         /* init with master mute & zero volume */
2444         put_kctl_with_value(kctl, 0);
2445         if (init_slave_vol)
2446                 map_slaves(codec, slaves, suffix,
2447                            tlv ? init_slave_0dB : init_slave_unmute, kctl);
2448
2449         if (ctl_ret)
2450                 *ctl_ret = kctl;
2451         return 0;
2452 }
2453 EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
2454
2455 /*
2456  * mute-LED control using vmaster
2457  */
2458 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2459                                   struct snd_ctl_elem_info *uinfo)
2460 {
2461         static const char * const texts[] = {
2462                 "Off", "On", "Follow Master"
2463         };
2464         unsigned int index;
2465
2466         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2467         uinfo->count = 1;
2468         uinfo->value.enumerated.items = 3;
2469         index = uinfo->value.enumerated.item;
2470         if (index >= 3)
2471                 index = 2;
2472         strcpy(uinfo->value.enumerated.name, texts[index]);
2473         return 0;
2474 }
2475
2476 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2477                                  struct snd_ctl_elem_value *ucontrol)
2478 {
2479         struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2480         ucontrol->value.enumerated.item[0] = hook->mute_mode;
2481         return 0;
2482 }
2483
2484 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2485                                  struct snd_ctl_elem_value *ucontrol)
2486 {
2487         struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2488         unsigned int old_mode = hook->mute_mode;
2489
2490         hook->mute_mode = ucontrol->value.enumerated.item[0];
2491         if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2492                 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2493         if (old_mode == hook->mute_mode)
2494                 return 0;
2495         snd_hda_sync_vmaster_hook(hook);
2496         return 1;
2497 }
2498
2499 static struct snd_kcontrol_new vmaster_mute_mode = {
2500         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2501         .name = "Mute-LED Mode",
2502         .info = vmaster_mute_mode_info,
2503         .get = vmaster_mute_mode_get,
2504         .put = vmaster_mute_mode_put,
2505 };
2506
2507 /*
2508  * Add a mute-LED hook with the given vmaster switch kctl
2509  * "Mute-LED Mode" control is automatically created and associated with
2510  * the given hook.
2511  */
2512 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2513                              struct hda_vmaster_mute_hook *hook,
2514                              bool expose_enum_ctl)
2515 {
2516         struct snd_kcontrol *kctl;
2517
2518         if (!hook->hook || !hook->sw_kctl)
2519                 return 0;
2520         snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2521         hook->codec = codec;
2522         hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2523         if (!expose_enum_ctl)
2524                 return 0;
2525         kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2526         if (!kctl)
2527                 return -ENOMEM;
2528         return snd_hda_ctl_add(codec, 0, kctl);
2529 }
2530 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
2531
2532 /*
2533  * Call the hook with the current value for synchronization
2534  * Should be called in init callback
2535  */
2536 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2537 {
2538         if (!hook->hook || !hook->codec)
2539                 return;
2540         switch (hook->mute_mode) {
2541         case HDA_VMUTE_FOLLOW_MASTER:
2542                 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2543                 break;
2544         default:
2545                 hook->hook(hook->codec, hook->mute_mode);
2546                 break;
2547         }
2548 }
2549 EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
2550
2551
2552 /**
2553  * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2554  *
2555  * The control element is supposed to have the private_value field
2556  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2557  */
2558 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2559                                   struct snd_ctl_elem_info *uinfo)
2560 {
2561         int chs = get_amp_channels(kcontrol);
2562
2563         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2564         uinfo->count = chs == 3 ? 2 : 1;
2565         uinfo->value.integer.min = 0;
2566         uinfo->value.integer.max = 1;
2567         return 0;
2568 }
2569 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2570
2571 /**
2572  * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2573  *
2574  * The control element is supposed to have the private_value field
2575  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2576  */
2577 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2578                                  struct snd_ctl_elem_value *ucontrol)
2579 {
2580         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2581         hda_nid_t nid = get_amp_nid(kcontrol);
2582         int chs = get_amp_channels(kcontrol);
2583         int dir = get_amp_direction(kcontrol);
2584         int idx = get_amp_index(kcontrol);
2585         long *valp = ucontrol->value.integer.value;
2586
2587         if (chs & 1)
2588                 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2589                            HDA_AMP_MUTE) ? 0 : 1;
2590         if (chs & 2)
2591                 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2592                          HDA_AMP_MUTE) ? 0 : 1;
2593         return 0;
2594 }
2595 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2596
2597 /**
2598  * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2599  *
2600  * The control element is supposed to have the private_value field
2601  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2602  */
2603 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2604                                  struct snd_ctl_elem_value *ucontrol)
2605 {
2606         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2607         hda_nid_t nid = get_amp_nid(kcontrol);
2608         int chs = get_amp_channels(kcontrol);
2609         int dir = get_amp_direction(kcontrol);
2610         int idx = get_amp_index(kcontrol);
2611         long *valp = ucontrol->value.integer.value;
2612         int change = 0;
2613
2614         snd_hda_power_up(codec);
2615         if (chs & 1) {
2616                 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2617                                                   HDA_AMP_MUTE,
2618                                                   *valp ? 0 : HDA_AMP_MUTE);
2619                 valp++;
2620         }
2621         if (chs & 2)
2622                 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2623                                                    HDA_AMP_MUTE,
2624                                                    *valp ? 0 : HDA_AMP_MUTE);
2625         hda_call_check_power_status(codec, nid);
2626         snd_hda_power_down(codec);
2627         return change;
2628 }
2629 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2630
2631 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2632 /**
2633  * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2634  *
2635  * This function calls snd_hda_enable_beep_device(), which behaves differently
2636  * depending on beep_mode option.
2637  */
2638 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2639                                       struct snd_ctl_elem_value *ucontrol)
2640 {
2641         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2642         long *valp = ucontrol->value.integer.value;
2643
2644         snd_hda_enable_beep_device(codec, *valp);
2645         return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2646 }
2647 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
2648 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2649
2650 /*
2651  * bound volume controls
2652  *
2653  * bind multiple volumes (# indices, from 0)
2654  */
2655
2656 #define AMP_VAL_IDX_SHIFT       19
2657 #define AMP_VAL_IDX_MASK        (0x0f<<19)
2658
2659 /**
2660  * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2661  *
2662  * The control element is supposed to have the private_value field
2663  * set up via HDA_BIND_MUTE*() macros.
2664  */
2665 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2666                                   struct snd_ctl_elem_value *ucontrol)
2667 {
2668         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2669         unsigned long pval;
2670         int err;
2671
2672         mutex_lock(&codec->control_mutex);
2673         pval = kcontrol->private_value;
2674         kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2675         err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2676         kcontrol->private_value = pval;
2677         mutex_unlock(&codec->control_mutex);
2678         return err;
2679 }
2680 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2681
2682 /**
2683  * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2684  *
2685  * The control element is supposed to have the private_value field
2686  * set up via HDA_BIND_MUTE*() macros.
2687  */
2688 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2689                                   struct snd_ctl_elem_value *ucontrol)
2690 {
2691         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2692         unsigned long pval;
2693         int i, indices, err = 0, change = 0;
2694
2695         mutex_lock(&codec->control_mutex);
2696         pval = kcontrol->private_value;
2697         indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2698         for (i = 0; i < indices; i++) {
2699                 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2700                         (i << AMP_VAL_IDX_SHIFT);
2701                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2702                 if (err < 0)
2703                         break;
2704                 change |= err;
2705         }
2706         kcontrol->private_value = pval;
2707         mutex_unlock(&codec->control_mutex);
2708         return err < 0 ? err : change;
2709 }
2710 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2711
2712 /**
2713  * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2714  *
2715  * The control element is supposed to have the private_value field
2716  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2717  */
2718 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2719                                  struct snd_ctl_elem_info *uinfo)
2720 {
2721         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2722         struct hda_bind_ctls *c;
2723         int err;
2724
2725         mutex_lock(&codec->control_mutex);
2726         c = (struct hda_bind_ctls *)kcontrol->private_value;
2727         kcontrol->private_value = *c->values;
2728         err = c->ops->info(kcontrol, uinfo);
2729         kcontrol->private_value = (long)c;
2730         mutex_unlock(&codec->control_mutex);
2731         return err;
2732 }
2733 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2734
2735 /**
2736  * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2737  *
2738  * The control element is supposed to have the private_value field
2739  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2740  */
2741 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2742                                 struct snd_ctl_elem_value *ucontrol)
2743 {
2744         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2745         struct hda_bind_ctls *c;
2746         int err;
2747
2748         mutex_lock(&codec->control_mutex);
2749         c = (struct hda_bind_ctls *)kcontrol->private_value;
2750         kcontrol->private_value = *c->values;
2751         err = c->ops->get(kcontrol, ucontrol);
2752         kcontrol->private_value = (long)c;
2753         mutex_unlock(&codec->control_mutex);
2754         return err;
2755 }
2756 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2757
2758 /**
2759  * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2760  *
2761  * The control element is supposed to have the private_value field
2762  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2763  */
2764 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2765                                 struct snd_ctl_elem_value *ucontrol)
2766 {
2767         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2768         struct hda_bind_ctls *c;
2769         unsigned long *vals;
2770         int err = 0, change = 0;
2771
2772         mutex_lock(&codec->control_mutex);
2773         c = (struct hda_bind_ctls *)kcontrol->private_value;
2774         for (vals = c->values; *vals; vals++) {
2775                 kcontrol->private_value = *vals;
2776                 err = c->ops->put(kcontrol, ucontrol);
2777                 if (err < 0)
2778                         break;
2779                 change |= err;
2780         }
2781         kcontrol->private_value = (long)c;
2782         mutex_unlock(&codec->control_mutex);
2783         return err < 0 ? err : change;
2784 }
2785 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2786
2787 /**
2788  * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2789  *
2790  * The control element is supposed to have the private_value field
2791  * set up via HDA_BIND_VOL() macro.
2792  */
2793 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2794                            unsigned int size, unsigned int __user *tlv)
2795 {
2796         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2797         struct hda_bind_ctls *c;
2798         int err;
2799
2800         mutex_lock(&codec->control_mutex);
2801         c = (struct hda_bind_ctls *)kcontrol->private_value;
2802         kcontrol->private_value = *c->values;
2803         err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2804         kcontrol->private_value = (long)c;
2805         mutex_unlock(&codec->control_mutex);
2806         return err;
2807 }
2808 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2809
2810 struct hda_ctl_ops snd_hda_bind_vol = {
2811         .info = snd_hda_mixer_amp_volume_info,
2812         .get = snd_hda_mixer_amp_volume_get,
2813         .put = snd_hda_mixer_amp_volume_put,
2814         .tlv = snd_hda_mixer_amp_tlv
2815 };
2816 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2817
2818 struct hda_ctl_ops snd_hda_bind_sw = {
2819         .info = snd_hda_mixer_amp_switch_info,
2820         .get = snd_hda_mixer_amp_switch_get,
2821         .put = snd_hda_mixer_amp_switch_put,
2822         .tlv = snd_hda_mixer_amp_tlv
2823 };
2824 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2825
2826 /*
2827  * SPDIF out controls
2828  */
2829
2830 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2831                                    struct snd_ctl_elem_info *uinfo)
2832 {
2833         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2834         uinfo->count = 1;
2835         return 0;
2836 }
2837
2838 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2839                                    struct snd_ctl_elem_value *ucontrol)
2840 {
2841         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2842                                            IEC958_AES0_NONAUDIO |
2843                                            IEC958_AES0_CON_EMPHASIS_5015 |
2844                                            IEC958_AES0_CON_NOT_COPYRIGHT;
2845         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2846                                            IEC958_AES1_CON_ORIGINAL;
2847         return 0;
2848 }
2849
2850 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2851                                    struct snd_ctl_elem_value *ucontrol)
2852 {
2853         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2854                                            IEC958_AES0_NONAUDIO |
2855                                            IEC958_AES0_PRO_EMPHASIS_5015;
2856         return 0;
2857 }
2858
2859 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2860                                      struct snd_ctl_elem_value *ucontrol)
2861 {
2862         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2863         int idx = kcontrol->private_value;
2864         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2865
2866         ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2867         ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2868         ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2869         ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2870
2871         return 0;
2872 }
2873
2874 /* convert from SPDIF status bits to HDA SPDIF bits
2875  * bit 0 (DigEn) is always set zero (to be filled later)
2876  */
2877 static unsigned short convert_from_spdif_status(unsigned int sbits)
2878 {
2879         unsigned short val = 0;
2880
2881         if (sbits & IEC958_AES0_PROFESSIONAL)
2882                 val |= AC_DIG1_PROFESSIONAL;
2883         if (sbits & IEC958_AES0_NONAUDIO)
2884                 val |= AC_DIG1_NONAUDIO;
2885         if (sbits & IEC958_AES0_PROFESSIONAL) {
2886                 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2887                     IEC958_AES0_PRO_EMPHASIS_5015)
2888                         val |= AC_DIG1_EMPHASIS;
2889         } else {
2890                 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2891                     IEC958_AES0_CON_EMPHASIS_5015)
2892                         val |= AC_DIG1_EMPHASIS;
2893                 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2894                         val |= AC_DIG1_COPYRIGHT;
2895                 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2896                         val |= AC_DIG1_LEVEL;
2897                 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2898         }
2899         return val;
2900 }
2901
2902 /* convert to SPDIF status bits from HDA SPDIF bits
2903  */
2904 static unsigned int convert_to_spdif_status(unsigned short val)
2905 {
2906         unsigned int sbits = 0;
2907
2908         if (val & AC_DIG1_NONAUDIO)
2909                 sbits |= IEC958_AES0_NONAUDIO;
2910         if (val & AC_DIG1_PROFESSIONAL)
2911                 sbits |= IEC958_AES0_PROFESSIONAL;
2912         if (sbits & IEC958_AES0_PROFESSIONAL) {
2913                 if (sbits & AC_DIG1_EMPHASIS)
2914                         sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2915         } else {
2916                 if (val & AC_DIG1_EMPHASIS)
2917                         sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2918                 if (!(val & AC_DIG1_COPYRIGHT))
2919                         sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2920                 if (val & AC_DIG1_LEVEL)
2921                         sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2922                 sbits |= val & (0x7f << 8);
2923         }
2924         return sbits;
2925 }
2926
2927 /* set digital convert verbs both for the given NID and its slaves */
2928 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2929                         int verb, int val)
2930 {
2931         const hda_nid_t *d;
2932
2933         snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2934         d = codec->slave_dig_outs;
2935         if (!d)
2936                 return;
2937         for (; *d; d++)
2938                 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2939 }
2940
2941 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2942                                        int dig1, int dig2)
2943 {
2944         if (dig1 != -1)
2945                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2946         if (dig2 != -1)
2947                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2948 }
2949
2950 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2951                                      struct snd_ctl_elem_value *ucontrol)
2952 {
2953         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2954         int idx = kcontrol->private_value;
2955         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2956         hda_nid_t nid = spdif->nid;
2957         unsigned short val;
2958         int change;
2959
2960         mutex_lock(&codec->spdif_mutex);
2961         spdif->status = ucontrol->value.iec958.status[0] |
2962                 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2963                 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2964                 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2965         val = convert_from_spdif_status(spdif->status);
2966         val |= spdif->ctls & 1;
2967         change = spdif->ctls != val;
2968         spdif->ctls = val;
2969         if (change && nid != (u16)-1)
2970                 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2971         mutex_unlock(&codec->spdif_mutex);
2972         return change;
2973 }
2974
2975 #define snd_hda_spdif_out_switch_info   snd_ctl_boolean_mono_info
2976
2977 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2978                                         struct snd_ctl_elem_value *ucontrol)
2979 {
2980         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2981         int idx = kcontrol->private_value;
2982         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2983
2984         ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
2985         return 0;
2986 }
2987
2988 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2989                                   int dig1, int dig2)
2990 {
2991         set_dig_out_convert(codec, nid, dig1, dig2);
2992         /* unmute amp switch (if any) */
2993         if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2994             (dig1 & AC_DIG1_ENABLE))
2995                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2996                                             HDA_AMP_MUTE, 0);
2997 }
2998
2999 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3000                                         struct snd_ctl_elem_value *ucontrol)
3001 {
3002         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3003         int idx = kcontrol->private_value;
3004         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
3005         hda_nid_t nid = spdif->nid;
3006         unsigned short val;
3007         int change;
3008
3009         mutex_lock(&codec->spdif_mutex);
3010         val = spdif->ctls & ~AC_DIG1_ENABLE;
3011         if (ucontrol->value.integer.value[0])
3012                 val |= AC_DIG1_ENABLE;
3013         change = spdif->ctls != val;
3014         spdif->ctls = val;
3015         if (change && nid != (u16)-1)
3016                 set_spdif_ctls(codec, nid, val & 0xff, -1);
3017         mutex_unlock(&codec->spdif_mutex);
3018         return change;
3019 }
3020
3021 int snd_hda_max_pcm_ch_info(struct snd_kcontrol *kcontrol,
3022                 struct snd_ctl_elem_info *uinfo)
3023 {
3024         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3025         uinfo->count = 1;
3026         uinfo->value.integer.min = 0;
3027         uinfo->value.integer.max = 0xFFFFFFFF;
3028         return 0;
3029 }
3030
3031 int snd_hda_hdmi_decode_info(struct snd_kcontrol *kcontrol,
3032                                 struct snd_ctl_elem_info *uinfo)
3033 {
3034         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3035         uinfo->count = 1;
3036         uinfo->value.integer.min = 0;
3037         uinfo->value.integer.max = 0xFFFFFFFF;
3038         return 0;
3039 }
3040
3041 static int snd_hda_max_pcm_ch_get(struct snd_kcontrol *kcontrol,
3042                 struct snd_ctl_elem_value *ucontrol)
3043 {
3044         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3045
3046         ucontrol->value.integer.value[0] = codec->max_pcm_channels;
3047         return 0;
3048 }
3049
3050 static int snd_hda_hdmi_decode_get(struct snd_kcontrol *kcontrol,
3051                                         struct snd_ctl_elem_value *ucontrol)
3052 {
3053         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3054
3055         ucontrol->value.integer.value[0] = codec->recv_dec_cap;
3056         return 0;
3057 }
3058
3059 static struct snd_kcontrol_new dig_mixes[] = {
3060         {
3061                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3062                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3063                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3064                 .info = snd_hda_spdif_mask_info,
3065                 .get = snd_hda_spdif_cmask_get,
3066         },
3067         {
3068                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3069                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3070                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3071                 .info = snd_hda_spdif_mask_info,
3072                 .get = snd_hda_spdif_pmask_get,
3073         },
3074         {
3075                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3076                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3077                 .info = snd_hda_spdif_mask_info,
3078                 .get = snd_hda_spdif_default_get,
3079                 .put = snd_hda_spdif_default_put,
3080         },
3081         {
3082                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3083                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3084                 .info = snd_hda_spdif_out_switch_info,
3085                 .get = snd_hda_spdif_out_switch_get,
3086                 .put = snd_hda_spdif_out_switch_put,
3087         },
3088         {
3089                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3090                 .name = "HDA Decode Capability",
3091                 .info = snd_hda_hdmi_decode_info,
3092                 .get = snd_hda_hdmi_decode_get,
3093         },
3094         {
3095                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3096                 .name = "HDA Maximum PCM Channels",
3097                 .info = snd_hda_max_pcm_ch_info,
3098                 .get = snd_hda_max_pcm_ch_get,
3099         },
3100         { } /* end */
3101 };
3102
3103 /**
3104  * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
3105  * @codec: the HDA codec
3106  * @nid: audio out widget NID
3107  *
3108  * Creates controls related with the SPDIF output.
3109  * Called from each patch supporting the SPDIF out.
3110  *
3111  * Returns 0 if successful, or a negative error code.
3112  */
3113 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
3114                                   hda_nid_t associated_nid,
3115                                   hda_nid_t cvt_nid)
3116 {
3117         int err;
3118         struct snd_kcontrol *kctl;
3119         struct snd_kcontrol_new *dig_mix;
3120         int idx;
3121         struct hda_spdif_out *spdif;
3122
3123         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
3124         if (idx < 0) {
3125                 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3126                 return -EBUSY;
3127         }
3128         spdif = snd_array_new(&codec->spdif_out);
3129         for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3130                 kctl = snd_ctl_new1(dig_mix, codec);
3131                 if (!kctl)
3132                         return -ENOMEM;
3133                 kctl->id.index = idx;
3134                 kctl->private_value = codec->spdif_out.used - 1;
3135                 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3136                 if (err < 0)
3137                         return err;
3138         }
3139         spdif->nid = cvt_nid;
3140         spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3141                                          AC_VERB_GET_DIGI_CONVERT_1, 0);
3142         spdif->status = convert_to_spdif_status(spdif->ctls);
3143         return 0;
3144 }
3145 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
3146
3147 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3148                                                hda_nid_t nid)
3149 {
3150         int i;
3151         for (i = 0; i < codec->spdif_out.used; i++) {
3152                 struct hda_spdif_out *spdif =
3153                                 snd_array_elem(&codec->spdif_out, i);
3154                 if (spdif->nid == nid)
3155                         return spdif;
3156         }
3157         return NULL;
3158 }
3159 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3160
3161 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3162 {
3163         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
3164
3165         mutex_lock(&codec->spdif_mutex);
3166         spdif->nid = (u16)-1;
3167         mutex_unlock(&codec->spdif_mutex);
3168 }
3169 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3170
3171 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3172 {
3173         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
3174         unsigned short val;
3175
3176         mutex_lock(&codec->spdif_mutex);
3177         if (spdif->nid != nid) {
3178                 spdif->nid = nid;
3179                 val = spdif->ctls;
3180                 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3181         }
3182         mutex_unlock(&codec->spdif_mutex);
3183 }
3184 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3185
3186 /*
3187  * SPDIF sharing with analog output
3188  */
3189 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3190                               struct snd_ctl_elem_value *ucontrol)
3191 {
3192         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3193         ucontrol->value.integer.value[0] = mout->share_spdif;
3194         return 0;
3195 }
3196
3197 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3198                               struct snd_ctl_elem_value *ucontrol)
3199 {
3200         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3201         mout->share_spdif = !!ucontrol->value.integer.value[0];
3202         return 0;
3203 }
3204
3205 static struct snd_kcontrol_new spdif_share_sw = {
3206         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3207         .name = "IEC958 Default PCM Playback Switch",
3208         .info = snd_ctl_boolean_mono_info,
3209         .get = spdif_share_sw_get,
3210         .put = spdif_share_sw_put,
3211 };
3212
3213 /**
3214  * snd_hda_create_spdif_share_sw - create Default PCM switch
3215  * @codec: the HDA codec
3216  * @mout: multi-out instance
3217  */
3218 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3219                                   struct hda_multi_out *mout)
3220 {
3221         if (!mout->dig_out_nid)
3222                 return 0;
3223         /* ATTENTION: here mout is passed as private_data, instead of codec */
3224         return snd_hda_ctl_add(codec, mout->dig_out_nid,
3225                               snd_ctl_new1(&spdif_share_sw, mout));
3226 }
3227 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3228
3229 /*
3230  * SPDIF input
3231  */
3232
3233 #define snd_hda_spdif_in_switch_info    snd_hda_spdif_out_switch_info
3234
3235 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3236                                        struct snd_ctl_elem_value *ucontrol)
3237 {
3238         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3239
3240         ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3241         return 0;
3242 }
3243
3244 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3245                                        struct snd_ctl_elem_value *ucontrol)
3246 {
3247         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3248         hda_nid_t nid = kcontrol->private_value;
3249         unsigned int val = !!ucontrol->value.integer.value[0];
3250         int change;
3251
3252         mutex_lock(&codec->spdif_mutex);
3253         change = codec->spdif_in_enable != val;
3254         if (change) {
3255                 codec->spdif_in_enable = val;
3256                 snd_hda_codec_write_cache(codec, nid, 0,
3257                                           AC_VERB_SET_DIGI_CONVERT_1, val);
3258         }
3259         mutex_unlock(&codec->spdif_mutex);
3260         return change;
3261 }
3262
3263 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3264                                        struct snd_ctl_elem_value *ucontrol)
3265 {
3266         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3267         hda_nid_t nid = kcontrol->private_value;
3268         unsigned short val;
3269         unsigned int sbits;
3270
3271         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3272         sbits = convert_to_spdif_status(val);
3273         ucontrol->value.iec958.status[0] = sbits;
3274         ucontrol->value.iec958.status[1] = sbits >> 8;
3275         ucontrol->value.iec958.status[2] = sbits >> 16;
3276         ucontrol->value.iec958.status[3] = sbits >> 24;
3277         return 0;
3278 }
3279
3280 static struct snd_kcontrol_new dig_in_ctls[] = {
3281         {
3282                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3283                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3284                 .info = snd_hda_spdif_in_switch_info,
3285                 .get = snd_hda_spdif_in_switch_get,
3286                 .put = snd_hda_spdif_in_switch_put,
3287         },
3288         {
3289                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3290                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3291                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3292                 .info = snd_hda_spdif_mask_info,
3293                 .get = snd_hda_spdif_in_status_get,
3294         },
3295         { } /* end */
3296 };
3297
3298 /**
3299  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3300  * @codec: the HDA codec
3301  * @nid: audio in widget NID
3302  *
3303  * Creates controls related with the SPDIF input.
3304  * Called from each patch supporting the SPDIF in.
3305  *
3306  * Returns 0 if successful, or a negative error code.
3307  */
3308 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3309 {
3310         int err;
3311         struct snd_kcontrol *kctl;
3312         struct snd_kcontrol_new *dig_mix;
3313         int idx;
3314
3315         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3316         if (idx < 0) {
3317                 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3318                 return -EBUSY;
3319         }
3320         for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3321                 kctl = snd_ctl_new1(dig_mix, codec);
3322                 if (!kctl)
3323                         return -ENOMEM;
3324                 kctl->private_value = nid;
3325                 err = snd_hda_ctl_add(codec, nid, kctl);
3326                 if (err < 0)
3327                         return err;
3328         }
3329         codec->spdif_in_enable =
3330                 snd_hda_codec_read(codec, nid, 0,
3331                                    AC_VERB_GET_DIGI_CONVERT_1, 0) &
3332                 AC_DIG1_ENABLE;
3333         return 0;
3334 }
3335 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3336
3337 #ifdef CONFIG_PM
3338 /*
3339  * command cache
3340  */
3341
3342 /* build a 32bit cache key with the widget id and the command parameter */
3343 #define build_cmd_cache_key(nid, verb)  ((verb << 8) | nid)
3344 #define get_cmd_cache_nid(key)          ((key) & 0xff)
3345 #define get_cmd_cache_cmd(key)          (((key) >> 8) & 0xffff)
3346
3347 /**
3348  * snd_hda_codec_write_cache - send a single command with caching
3349  * @codec: the HDA codec
3350  * @nid: NID to send the command
3351  * @direct: direct flag
3352  * @verb: the verb to send
3353  * @parm: the parameter for the verb
3354  *
3355  * Send a single command without waiting for response.
3356  *
3357  * Returns 0 if successful, or a negative error code.
3358  */
3359 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3360                               int direct, unsigned int verb, unsigned int parm)
3361 {
3362         int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3363         struct hda_cache_head *c;
3364         u32 key;
3365
3366         if (err < 0)
3367                 return err;
3368         /* parm may contain the verb stuff for get/set amp */
3369         verb = verb | (parm >> 8);
3370         parm &= 0xff;
3371         key = build_cmd_cache_key(nid, verb);
3372         mutex_lock(&codec->bus->cmd_mutex);
3373         c = get_alloc_hash(&codec->cmd_cache, key);
3374         if (c)
3375                 c->val = parm;
3376         mutex_unlock(&codec->bus->cmd_mutex);
3377         return 0;
3378 }
3379 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3380
3381 /**
3382  * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3383  * @codec: the HDA codec
3384  * @nid: NID to send the command
3385  * @direct: direct flag
3386  * @verb: the verb to send
3387  * @parm: the parameter for the verb
3388  *
3389  * This function works like snd_hda_codec_write_cache(), but it doesn't send
3390  * command if the parameter is already identical with the cached value.
3391  * If not, it sends the command and refreshes the cache.
3392  *
3393  * Returns 0 if successful, or a negative error code.
3394  */
3395 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3396                                int direct, unsigned int verb, unsigned int parm)
3397 {
3398         struct hda_cache_head *c;
3399         u32 key;
3400
3401         /* parm may contain the verb stuff for get/set amp */
3402         verb = verb | (parm >> 8);
3403         parm &= 0xff;
3404         key = build_cmd_cache_key(nid, verb);
3405         mutex_lock(&codec->bus->cmd_mutex);
3406         c = get_hash(&codec->cmd_cache, key);
3407         if (c && c->val == parm) {
3408                 mutex_unlock(&codec->bus->cmd_mutex);
3409                 return 0;
3410         }
3411         mutex_unlock(&codec->bus->cmd_mutex);
3412         return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3413 }
3414 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3415
3416 /**
3417  * snd_hda_codec_resume_cache - Resume the all commands from the cache
3418  * @codec: HD-audio codec
3419  *
3420  * Execute all verbs recorded in the command caches to resume.
3421  */
3422 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3423 {
3424         struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
3425         int i;
3426
3427         for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
3428                 u32 key = buffer->key;
3429                 if (!key)
3430                         continue;
3431                 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3432                                     get_cmd_cache_cmd(key), buffer->val);
3433         }
3434 }
3435 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3436
3437 /**
3438  * snd_hda_sequence_write_cache - sequence writes with caching
3439  * @codec: the HDA codec
3440  * @seq: VERB array to send
3441  *
3442  * Send the commands sequentially from the given array.
3443  * Thte commands are recorded on cache for power-save and resume.
3444  * The array must be terminated with NID=0.
3445  */
3446 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3447                                   const struct hda_verb *seq)
3448 {
3449         for (; seq->nid; seq++)
3450                 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3451                                           seq->param);
3452 }
3453 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3454 #endif /* CONFIG_PM */
3455
3456 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3457                                     unsigned int power_state,
3458                                     bool eapd_workaround)
3459 {
3460         hda_nid_t nid = codec->start_nid;
3461         int i;
3462
3463         for (i = 0; i < codec->num_nodes; i++, nid++) {
3464                 unsigned int wcaps = get_wcaps(codec, nid);
3465                 if (!(wcaps & AC_WCAP_POWER))
3466                         continue;
3467                 /* don't power down the widget if it controls eapd and
3468                  * EAPD_BTLENABLE is set.
3469                  */
3470                 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3471                     get_wcaps_type(wcaps) == AC_WID_PIN &&
3472                     (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3473                         int eapd = snd_hda_codec_read(codec, nid, 0,
3474                                                 AC_VERB_GET_EAPD_BTLENABLE, 0);
3475                         if (eapd & 0x02)
3476                                 continue;
3477                 }
3478                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3479                                     power_state);
3480         }
3481
3482         if (power_state == AC_PWRST_D0) {
3483                 unsigned long end_time;
3484                 int state;
3485                 /* wait until the codec reachs to D0 */
3486                 end_time = jiffies + msecs_to_jiffies(500);
3487                 do {
3488                         state = snd_hda_codec_read(codec, fg, 0,
3489                                                    AC_VERB_GET_POWER_STATE, 0);
3490                         if (state == power_state)
3491                                 break;
3492                         mdelay(1);
3493                 } while (time_after_eq(end_time, jiffies));
3494         }
3495 }
3496 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3497
3498 /*
3499  * set power state of the codec
3500  */
3501 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3502                                 unsigned int power_state)
3503 {
3504         if (codec->patch_ops.set_power_state) {
3505                 codec->patch_ops.set_power_state(codec, fg, power_state);
3506                 return;
3507         }
3508
3509         /* this delay seems necessary to avoid click noise at power-down */
3510         if (power_state == AC_PWRST_D3)
3511                 msleep(100);
3512         snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3513                             power_state);
3514         snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3515 }
3516
3517 #ifdef CONFIG_SND_HDA_HWDEP
3518 /* execute additional init verbs */
3519 static void hda_exec_init_verbs(struct hda_codec *codec)
3520 {
3521         if (codec->init_verbs.list)
3522                 snd_hda_sequence_write(codec, codec->init_verbs.list);
3523 }
3524 #else
3525 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3526 #endif
3527
3528 #ifdef CONFIG_PM
3529 /*
3530  * call suspend and power-down; used both from PM and power-save
3531  */
3532 static void hda_call_codec_suspend(struct hda_codec *codec)
3533 {
3534         if (codec->patch_ops.suspend)
3535                 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
3536         hda_cleanup_all_streams(codec);
3537         hda_set_power_state(codec,
3538                             codec->afg ? codec->afg : codec->mfg,
3539                             AC_PWRST_D3);
3540 #ifdef CONFIG_SND_HDA_POWER_SAVE
3541         snd_hda_update_power_acct(codec);
3542         cancel_delayed_work(&codec->power_work);
3543         codec->power_on = 0;
3544         codec->power_transition = 0;
3545         codec->power_jiffies = jiffies;
3546 #endif
3547 }
3548
3549 /*
3550  * kick up codec; used both from PM and power-save
3551  */
3552 static void hda_call_codec_resume(struct hda_codec *codec)
3553 {
3554         hda_set_power_state(codec,
3555                             codec->afg ? codec->afg : codec->mfg,
3556                             AC_PWRST_D0);
3557         restore_pincfgs(codec); /* restore all current pin configs */
3558         restore_shutup_pins(codec);
3559         hda_exec_init_verbs(codec);
3560         snd_hda_jack_set_dirty_all(codec);
3561         if (codec->patch_ops.resume)
3562                 codec->patch_ops.resume(codec);
3563         else {
3564                 if (codec->patch_ops.init)
3565                         codec->patch_ops.init(codec);
3566                 snd_hda_codec_resume_amp(codec);
3567                 snd_hda_codec_resume_cache(codec);
3568         }
3569 }
3570 #endif /* CONFIG_PM */
3571
3572
3573 /**
3574  * snd_hda_build_controls - build mixer controls
3575  * @bus: the BUS
3576  *
3577  * Creates mixer controls for each codec included in the bus.
3578  *
3579  * Returns 0 if successful, otherwise a negative error code.
3580  */
3581 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
3582 {
3583         struct hda_codec *codec;
3584
3585         list_for_each_entry(codec, &bus->codec_list, list) {
3586                 int err = snd_hda_codec_build_controls(codec);
3587                 if (err < 0) {
3588                         printk(KERN_ERR "hda_codec: cannot build controls "
3589                                "for #%d (error %d)\n", codec->addr, err);
3590                         err = snd_hda_codec_reset(codec);
3591                         if (err < 0) {
3592                                 printk(KERN_ERR
3593                                        "hda_codec: cannot revert codec\n");
3594                                 return err;
3595                         }
3596                 }
3597         }
3598         return 0;
3599 }
3600 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3601
3602 int snd_hda_codec_build_controls(struct hda_codec *codec)
3603 {
3604         int err = 0;
3605         hda_exec_init_verbs(codec);
3606         /* continue to initialize... */
3607         if (codec->patch_ops.init)
3608                 err = codec->patch_ops.init(codec);
3609         if (!err && codec->patch_ops.build_controls)
3610                 err = codec->patch_ops.build_controls(codec);
3611         if (err < 0)
3612                 return err;
3613         return 0;
3614 }
3615
3616 /*
3617  * stream formats
3618  */
3619 struct hda_rate_tbl {
3620         unsigned int hz;
3621         unsigned int alsa_bits;
3622         unsigned int hda_fmt;
3623 };
3624
3625 /* rate = base * mult / div */
3626 #define HDA_RATE(base, mult, div) \
3627         (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3628          (((div) - 1) << AC_FMT_DIV_SHIFT))
3629
3630 static struct hda_rate_tbl rate_bits[] = {
3631         /* rate in Hz, ALSA rate bitmask, HDA format value */
3632
3633         /* autodetected value used in snd_hda_query_supported_pcm */
3634         { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3635         { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3636         { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3637         { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3638         { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3639         { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3640         { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3641         { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3642         { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3643         { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3644         { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3645 #define AC_PAR_PCM_RATE_BITS    11
3646         /* up to bits 10, 384kHZ isn't supported properly */
3647
3648         /* not autodetected value */
3649         { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3650
3651         { 0 } /* terminator */
3652 };
3653
3654 /**
3655  * snd_hda_calc_stream_format - calculate format bitset
3656  * @rate: the sample rate
3657  * @channels: the number of channels
3658  * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3659  * @maxbps: the max. bps
3660  *
3661  * Calculate the format bitset from the given rate, channels and th PCM format.
3662  *
3663  * Return zero if invalid.
3664  */
3665 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3666                                         unsigned int channels,
3667                                         unsigned int format,
3668                                         unsigned int maxbps,
3669                                         unsigned short spdif_ctls)
3670 {
3671         int i;
3672         unsigned int val = 0;
3673
3674         for (i = 0; rate_bits[i].hz; i++)
3675                 if (rate_bits[i].hz == rate) {
3676                         val = rate_bits[i].hda_fmt;
3677                         break;
3678                 }
3679         if (!rate_bits[i].hz) {
3680                 snd_printdd("invalid rate %d\n", rate);
3681                 return 0;
3682         }
3683
3684         if (channels == 0 || channels > 8) {
3685                 snd_printdd("invalid channels %d\n", channels);
3686                 return 0;
3687         }
3688         val |= channels - 1;
3689
3690         switch (snd_pcm_format_width(format)) {
3691         case 8:
3692                 val |= AC_FMT_BITS_8;
3693                 break;
3694         case 16:
3695                 val |= AC_FMT_BITS_16;
3696                 break;
3697         case 20:
3698         case 24:
3699         case 32:
3700                 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3701                         val |= AC_FMT_BITS_32;
3702                 else if (maxbps >= 24)
3703                         val |= AC_FMT_BITS_24;
3704                 else
3705                         val |= AC_FMT_BITS_20;
3706                 break;
3707         default:
3708                 snd_printdd("invalid format width %d\n",
3709                             snd_pcm_format_width(format));
3710                 return 0;
3711         }
3712
3713         if (spdif_ctls & AC_DIG1_NONAUDIO)
3714                 val |= AC_FMT_TYPE_NON_PCM;
3715
3716         return val;
3717 }
3718 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3719
3720 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3721 {
3722         unsigned int val = 0;
3723         if (nid != codec->afg &&
3724             (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3725                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3726         if (!val || val == -1)
3727                 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3728         if (!val || val == -1)
3729                 return 0;
3730         return val;
3731 }
3732
3733 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3734 {
3735         return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3736                                get_pcm_param);
3737 }
3738
3739 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3740 {
3741         unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3742         if (!streams || streams == -1)
3743                 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3744         if (!streams || streams == -1)
3745                 return 0;
3746         return streams;
3747 }
3748
3749 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3750 {
3751         return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3752                                get_stream_param);
3753 }
3754
3755 /**
3756  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3757  * @codec: the HDA codec
3758  * @nid: NID to query
3759  * @ratesp: the pointer to store the detected rate bitflags
3760  * @formatsp: the pointer to store the detected formats
3761  * @bpsp: the pointer to store the detected format widths
3762  *
3763  * Queries the supported PCM rates and formats.  The NULL @ratesp, @formatsp
3764  * or @bsps argument is ignored.
3765  *
3766  * Returns 0 if successful, otherwise a negative error code.
3767  */
3768 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3769                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3770 {
3771         unsigned int i, val, wcaps;
3772
3773         wcaps = get_wcaps(codec, nid);
3774         val = query_pcm_param(codec, nid);
3775
3776         if (ratesp) {
3777                 u32 rates = 0;
3778                 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3779                         if (val & (1 << i))
3780                                 rates |= rate_bits[i].alsa_bits;
3781                 }
3782                 if (rates == 0) {
3783                         snd_printk(KERN_ERR "hda_codec: rates == 0 "
3784                                    "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3785                                         nid, val,
3786                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3787                         return -EIO;
3788                 }
3789                 *ratesp = rates;
3790         }
3791
3792         if (formatsp || bpsp) {
3793                 u64 formats = 0;
3794                 unsigned int streams, bps;
3795
3796                 streams = query_stream_param(codec, nid);
3797                 if (!streams)
3798                         return -EIO;
3799
3800                 bps = 0;
3801                 if (streams & AC_SUPFMT_PCM) {
3802                         if (val & AC_SUPPCM_BITS_8) {
3803                                 formats |= SNDRV_PCM_FMTBIT_U8;
3804                                 bps = 8;
3805                         }
3806                         if (val & AC_SUPPCM_BITS_16) {
3807                                 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3808                                 bps = 16;
3809                         }
3810                         if (wcaps & AC_WCAP_DIGITAL) {
3811                                 if (val & AC_SUPPCM_BITS_32)
3812                                         formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3813                                 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3814                                         formats |= SNDRV_PCM_FMTBIT_S32_LE;
3815                                 if (val & AC_SUPPCM_BITS_24)
3816                                         bps = 24;
3817                                 else if (val & AC_SUPPCM_BITS_20)
3818                                         bps = 20;
3819                         } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3820                                           AC_SUPPCM_BITS_32)) {
3821                                 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3822                                 if (val & AC_SUPPCM_BITS_32)
3823                                         bps = 32;
3824                                 else if (val & AC_SUPPCM_BITS_24)
3825                                         bps = 24;
3826                                 else if (val & AC_SUPPCM_BITS_20)
3827                                         bps = 20;
3828                         }
3829                 }
3830                 if (streams & AC_SUPFMT_FLOAT32) {
3831                         formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3832                         if (!bps)
3833                                 bps = 32;
3834                 }
3835                 if (streams == AC_SUPFMT_AC3) {
3836                         /* should be exclusive */
3837                         /* temporary hack: we have still no proper support
3838                          * for the direct AC3 stream...
3839                          */
3840                         formats |= SNDRV_PCM_FMTBIT_U8;
3841                         bps = 8;
3842                 }
3843                 if (formats == 0) {
3844                         snd_printk(KERN_ERR "hda_codec: formats == 0 "
3845                                    "(nid=0x%x, val=0x%x, ovrd=%i, "
3846                                    "streams=0x%x)\n",
3847                                         nid, val,
3848                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3849                                         streams);
3850                         return -EIO;
3851                 }
3852                 if (formatsp)
3853                         *formatsp = formats;
3854                 if (bpsp)
3855                         *bpsp = bps;
3856         }
3857
3858         return 0;
3859 }
3860 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
3861
3862 /**
3863  * snd_hda_is_supported_format - Check the validity of the format
3864  * @codec: HD-audio codec
3865  * @nid: NID to check
3866  * @format: the HD-audio format value to check
3867  *
3868  * Check whether the given node supports the format value.
3869  *
3870  * Returns 1 if supported, 0 if not.
3871  */
3872 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3873                                 unsigned int format)
3874 {
3875         int i;
3876         unsigned int val = 0, rate, stream;
3877
3878         val = query_pcm_param(codec, nid);
3879         if (!val)
3880                 return 0;
3881
3882         rate = format & 0xff00;
3883         for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3884                 if (rate_bits[i].hda_fmt == rate) {
3885                         if (val & (1 << i))
3886                                 break;
3887                         return 0;
3888                 }
3889         if (i >= AC_PAR_PCM_RATE_BITS)
3890                 return 0;
3891
3892         stream = query_stream_param(codec, nid);
3893         if (!stream)
3894                 return 0;
3895
3896         if (stream & AC_SUPFMT_PCM) {
3897                 switch (format & 0xf0) {
3898                 case 0x00:
3899                         if (!(val & AC_SUPPCM_BITS_8))
3900                                 return 0;
3901                         break;
3902                 case 0x10:
3903                         if (!(val & AC_SUPPCM_BITS_16))
3904                                 return 0;
3905                         break;
3906                 case 0x20:
3907                         if (!(val & AC_SUPPCM_BITS_20))
3908                                 return 0;
3909                         break;
3910                 case 0x30:
3911                         if (!(val & AC_SUPPCM_BITS_24))
3912                                 return 0;
3913                         break;
3914                 case 0x40:
3915                         if (!(val & AC_SUPPCM_BITS_32))
3916                                 return 0;
3917                         break;
3918                 default:
3919                         return 0;
3920                 }
3921         } else {
3922                 /* FIXME: check for float32 and AC3? */
3923         }
3924
3925         return 1;
3926 }
3927 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3928
3929 /*
3930  * PCM stuff
3931  */
3932 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3933                                       struct hda_codec *codec,
3934                                       struct snd_pcm_substream *substream)
3935 {
3936         return 0;
3937 }
3938
3939 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3940                                    struct hda_codec *codec,
3941                                    unsigned int stream_tag,
3942                                    unsigned int format,
3943                                    struct snd_pcm_substream *substream)
3944 {
3945         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3946         return 0;
3947 }
3948
3949 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3950                                    struct hda_codec *codec,
3951                                    struct snd_pcm_substream *substream)
3952 {
3953         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3954         return 0;
3955 }
3956
3957 static int set_pcm_default_values(struct hda_codec *codec,
3958                                   struct hda_pcm_stream *info)
3959 {
3960         int err;
3961
3962         /* query support PCM information from the given NID */
3963         if (info->nid && (!info->rates || !info->formats)) {
3964                 err = snd_hda_query_supported_pcm(codec, info->nid,
3965                                 info->rates ? NULL : &info->rates,
3966                                 info->formats ? NULL : &info->formats,
3967                                 info->maxbps ? NULL : &info->maxbps);
3968                 if (err < 0)
3969                         return err;
3970         }
3971         if (info->ops.open == NULL)
3972                 info->ops.open = hda_pcm_default_open_close;
3973         if (info->ops.close == NULL)
3974                 info->ops.close = hda_pcm_default_open_close;
3975         if (info->ops.prepare == NULL) {
3976                 if (snd_BUG_ON(!info->nid))
3977                         return -EINVAL;
3978                 info->ops.prepare = hda_pcm_default_prepare;
3979         }
3980         if (info->ops.cleanup == NULL) {
3981                 if (snd_BUG_ON(!info->nid))
3982                         return -EINVAL;
3983                 info->ops.cleanup = hda_pcm_default_cleanup;
3984         }
3985         return 0;
3986 }
3987
3988 /*
3989  * codec prepare/cleanup entries
3990  */
3991 int snd_hda_codec_prepare(struct hda_codec *codec,
3992                           struct hda_pcm_stream *hinfo,
3993                           unsigned int stream,
3994                           unsigned int format,
3995                           struct snd_pcm_substream *substream)
3996 {
3997         int ret;
3998         mutex_lock(&codec->bus->prepare_mutex);
3999         ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4000         if (ret >= 0)
4001                 purify_inactive_streams(codec);
4002         mutex_unlock(&codec->bus->prepare_mutex);
4003         return ret;
4004 }
4005 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
4006
4007 void snd_hda_codec_cleanup(struct hda_codec *codec,
4008                            struct hda_pcm_stream *hinfo,
4009                            struct snd_pcm_substream *substream)
4010 {
4011         mutex_lock(&codec->bus->prepare_mutex);
4012         hinfo->ops.cleanup(hinfo, codec, substream);
4013         mutex_unlock(&codec->bus->prepare_mutex);
4014 }
4015 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
4016
4017 /* global */
4018 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4019         "Audio", "SPDIF", "HDMI", "Modem"
4020 };
4021
4022 /*
4023  * get the empty PCM device number to assign
4024  *
4025  * note the max device number is limited by HDA_MAX_PCMS, currently 10
4026  */
4027 static int get_empty_pcm_device(struct hda_bus *bus, int type)
4028 {
4029         /* audio device indices; not linear to keep compatibility */
4030         static int audio_idx[HDA_PCM_NTYPES][5] = {
4031                 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4032                 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
4033                 [HDA_PCM_TYPE_HDMI]  = { 3, 7, 8, 9, -1 },
4034                 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
4035         };
4036         int i;
4037
4038         if (type >= HDA_PCM_NTYPES) {
4039                 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4040                 return -EINVAL;
4041         }
4042
4043         for (i = 0; audio_idx[type][i] >= 0 ; i++)
4044                 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4045                         return audio_idx[type][i];
4046
4047         /* non-fixed slots starting from 10 */
4048         for (i = 10; i < 32; i++) {
4049                 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4050                         return i;
4051         }
4052
4053         snd_printk(KERN_WARNING "Too many %s devices\n",
4054                 snd_hda_pcm_type_name[type]);
4055         return -EAGAIN;
4056 }
4057
4058 /*
4059  * attach a new PCM stream
4060  */
4061 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4062 {
4063         struct hda_bus *bus = codec->bus;
4064         struct hda_pcm_stream *info;
4065         int stream, err;
4066
4067         if (snd_BUG_ON(!pcm->name))
4068                 return -EINVAL;
4069         for (stream = 0; stream < 2; stream++) {
4070                 info = &pcm->stream[stream];
4071                 if (info->substreams) {
4072                         err = set_pcm_default_values(codec, info);
4073                         if (err < 0)
4074                                 return err;
4075                 }
4076         }
4077         return bus->ops.attach_pcm(bus, codec, pcm);
4078 }
4079
4080 /* assign all PCMs of the given codec */
4081 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4082 {
4083         unsigned int pcm;
4084         int err;
4085
4086         if (!codec->num_pcms) {
4087                 if (!codec->patch_ops.build_pcms)
4088                         return 0;
4089                 err = codec->patch_ops.build_pcms(codec);
4090                 if (err < 0) {
4091                         printk(KERN_ERR "hda_codec: cannot build PCMs"
4092                                "for #%d (error %d)\n", codec->addr, err);
4093                         err = snd_hda_codec_reset(codec);
4094                         if (err < 0) {
4095                                 printk(KERN_ERR
4096                                        "hda_codec: cannot revert codec\n");
4097                                 return err;
4098                         }
4099                 }
4100         }
4101         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4102                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4103                 int dev;
4104
4105                 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4106                         continue; /* no substreams assigned */
4107
4108                 if (!cpcm->pcm) {
4109                         dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4110                         if (dev < 0)
4111                                 continue; /* no fatal error */
4112                         cpcm->device = dev;
4113                         err = snd_hda_attach_pcm(codec, cpcm);
4114                         if (err < 0) {
4115                                 printk(KERN_ERR "hda_codec: cannot attach "
4116                                        "PCM stream %d for codec #%d\n",
4117                                        dev, codec->addr);
4118                                 continue; /* no fatal error */
4119                         }
4120                 }
4121         }
4122         return 0;
4123 }
4124
4125 /**
4126  * snd_hda_build_pcms - build PCM information
4127  * @bus: the BUS
4128  *
4129  * Create PCM information for each codec included in the bus.
4130  *
4131  * The build_pcms codec patch is requested to set up codec->num_pcms and
4132  * codec->pcm_info properly.  The array is referred by the top-level driver
4133  * to create its PCM instances.
4134  * The allocated codec->pcm_info should be released in codec->patch_ops.free
4135  * callback.
4136  *
4137  * At least, substreams, channels_min and channels_max must be filled for
4138  * each stream.  substreams = 0 indicates that the stream doesn't exist.
4139  * When rates and/or formats are zero, the supported values are queried
4140  * from the given nid.  The nid is used also by the default ops.prepare
4141  * and ops.cleanup callbacks.
4142  *
4143  * The driver needs to call ops.open in its open callback.  Similarly,
4144  * ops.close is supposed to be called in the close callback.
4145  * ops.prepare should be called in the prepare or hw_params callback
4146  * with the proper parameters for set up.
4147  * ops.cleanup should be called in hw_free for clean up of streams.
4148  *
4149  * This function returns 0 if successful, or a negative error code.
4150  */
4151 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
4152 {
4153         struct hda_codec *codec;
4154
4155         list_for_each_entry(codec, &bus->codec_list, list) {
4156                 int err = snd_hda_codec_build_pcms(codec);
4157                 if (err < 0)
4158                         return err;
4159         }
4160         return 0;
4161 }
4162 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
4163
4164 /**
4165  * snd_hda_check_board_config - compare the current codec with the config table
4166  * @codec: the HDA codec
4167  * @num_configs: number of config enums
4168  * @models: array of model name strings
4169  * @tbl: configuration table, terminated by null entries
4170  *
4171  * Compares the modelname or PCI subsystem id of the current codec with the
4172  * given configuration table.  If a matching entry is found, returns its
4173  * config value (supposed to be 0 or positive).
4174  *
4175  * If no entries are matching, the function returns a negative value.
4176  */
4177 int snd_hda_check_board_config(struct hda_codec *codec,
4178                                int num_configs, const char * const *models,
4179                                const struct snd_pci_quirk *tbl)
4180 {
4181         if (codec->modelname && models) {
4182                 int i;
4183                 for (i = 0; i < num_configs; i++) {
4184                         if (models[i] &&
4185                             !strcmp(codec->modelname, models[i])) {
4186                                 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4187                                            "selected\n", models[i]);
4188                                 return i;
4189                         }
4190                 }
4191         }
4192
4193         if (!codec->bus->pci || !tbl)
4194                 return -1;
4195
4196         tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4197         if (!tbl)
4198                 return -1;
4199         if (tbl->value >= 0 && tbl->value < num_configs) {
4200 #ifdef CONFIG_SND_DEBUG_VERBOSE
4201                 char tmp[10];
4202                 const char *model = NULL;
4203                 if (models)
4204                         model = models[tbl->value];
4205                 if (!model) {
4206                         sprintf(tmp, "#%d", tbl->value);
4207                         model = tmp;
4208                 }
4209                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4210                             "for config %x:%x (%s)\n",
4211                             model, tbl->subvendor, tbl->subdevice,
4212                             (tbl->name ? tbl->name : "Unknown device"));
4213 #endif
4214                 return tbl->value;
4215         }
4216         return -1;
4217 }
4218 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
4219
4220 /**
4221  * snd_hda_check_board_codec_sid_config - compare the current codec
4222                                         subsystem ID with the
4223                                         config table
4224
4225            This is important for Gateway notebooks with SB450 HDA Audio
4226            where the vendor ID of the PCI device is:
4227                 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4228            and the vendor/subvendor are found only at the codec.
4229
4230  * @codec: the HDA codec
4231  * @num_configs: number of config enums
4232  * @models: array of model name strings
4233  * @tbl: configuration table, terminated by null entries
4234  *
4235  * Compares the modelname or PCI subsystem id of the current codec with the
4236  * given configuration table.  If a matching entry is found, returns its
4237  * config value (supposed to be 0 or positive).
4238  *
4239  * If no entries are matching, the function returns a negative value.
4240  */
4241 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4242                                int num_configs, const char * const *models,
4243                                const struct snd_pci_quirk *tbl)
4244 {
4245         const struct snd_pci_quirk *q;
4246
4247         /* Search for codec ID */
4248         for (q = tbl; q->subvendor; q++) {
4249                 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4250                 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4251                 if ((codec->subsystem_id & mask) == id)
4252                         break;
4253         }
4254
4255         if (!q->subvendor)
4256                 return -1;
4257
4258         tbl = q;
4259
4260         if (tbl->value >= 0 && tbl->value < num_configs) {
4261 #ifdef CONFIG_SND_DEBUG_VERBOSE
4262                 char tmp[10];
4263                 const char *model = NULL;
4264                 if (models)
4265                         model = models[tbl->value];
4266                 if (!model) {
4267                         sprintf(tmp, "#%d", tbl->value);
4268                         model = tmp;
4269                 }
4270                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4271                             "for config %x:%x (%s)\n",
4272                             model, tbl->subvendor, tbl->subdevice,
4273                             (tbl->name ? tbl->name : "Unknown device"));
4274 #endif
4275                 return tbl->value;
4276         }
4277         return -1;
4278 }
4279 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4280
4281 /**
4282  * snd_hda_add_new_ctls - create controls from the array
4283  * @codec: the HDA codec
4284  * @knew: the array of struct snd_kcontrol_new
4285  *
4286  * This helper function creates and add new controls in the given array.
4287  * The array must be terminated with an empty entry as terminator.
4288  *
4289  * Returns 0 if successful, or a negative error code.
4290  */
4291 int snd_hda_add_new_ctls(struct hda_codec *codec,
4292                          const struct snd_kcontrol_new *knew)
4293 {
4294         int err;
4295
4296         for (; knew->name; knew++) {
4297                 struct snd_kcontrol *kctl;
4298                 int addr = 0, idx = 0;
4299                 if (knew->iface == -1)  /* skip this codec private value */
4300                         continue;
4301                 for (;;) {
4302                         kctl = snd_ctl_new1(knew, codec);
4303                         if (!kctl)
4304                                 return -ENOMEM;
4305                         if (addr > 0)
4306                                 kctl->id.device = addr;
4307                         if (idx > 0)
4308                                 kctl->id.index = idx;
4309                         err = snd_hda_ctl_add(codec, 0, kctl);
4310                         if (!err)
4311                                 break;
4312                         /* try first with another device index corresponding to
4313                          * the codec addr; if it still fails (or it's the
4314                          * primary codec), then try another control index
4315                          */
4316                         if (!addr && codec->addr)
4317                                 addr = codec->addr;
4318                         else if (!idx && !knew->index) {
4319                                 idx = find_empty_mixer_ctl_idx(codec,
4320                                                                knew->name);
4321                                 if (idx <= 0)
4322                                         return err;
4323                         } else
4324                                 return err;
4325                 }
4326         }
4327         return 0;
4328 }
4329 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4330
4331 #ifdef CONFIG_SND_HDA_POWER_SAVE
4332 static void hda_power_work(struct work_struct *work)
4333 {
4334         struct hda_codec *codec =
4335                 container_of(work, struct hda_codec, power_work.work);
4336         struct hda_bus *bus = codec->bus;
4337
4338         if (!codec->power_on || codec->power_count) {
4339                 codec->power_transition = 0;
4340                 return;
4341         }
4342
4343         trace_hda_power_down(codec);
4344         hda_call_codec_suspend(codec);
4345         if (bus->ops.pm_notify)
4346                 bus->ops.pm_notify(bus);
4347 }
4348
4349 static void hda_keep_power_on(struct hda_codec *codec)
4350 {
4351         codec->power_count++;
4352         codec->power_on = 1;
4353         codec->power_jiffies = jiffies;
4354 }
4355
4356 /* update the power on/off account with the current jiffies */
4357 void snd_hda_update_power_acct(struct hda_codec *codec)
4358 {
4359         unsigned long delta = jiffies - codec->power_jiffies;
4360         if (codec->power_on)
4361                 codec->power_on_acct += delta;
4362         else
4363                 codec->power_off_acct += delta;
4364         codec->power_jiffies += delta;
4365 }
4366
4367 /**
4368  * snd_hda_power_up - Power-up the codec
4369  * @codec: HD-audio codec
4370  *
4371  * Increment the power-up counter and power up the hardware really when
4372  * not turned on yet.
4373  */
4374 void snd_hda_power_up(struct hda_codec *codec)
4375 {
4376         struct hda_bus *bus = codec->bus;
4377
4378         codec->power_count++;
4379         if (codec->power_on || codec->power_transition)
4380                 return;
4381
4382         trace_hda_power_up(codec);
4383         snd_hda_update_power_acct(codec);
4384         codec->power_on = 1;
4385         codec->power_jiffies = jiffies;
4386         if (bus->ops.pm_notify)
4387                 bus->ops.pm_notify(bus);
4388         hda_call_codec_resume(codec);
4389         cancel_delayed_work(&codec->power_work);
4390         codec->power_transition = 0;
4391 }
4392 EXPORT_SYMBOL_HDA(snd_hda_power_up);
4393
4394 #define power_save(codec)       \
4395         ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4396
4397 /**
4398  * snd_hda_power_down - Power-down the codec
4399  * @codec: HD-audio codec
4400  *
4401  * Decrement the power-up counter and schedules the power-off work if
4402  * the counter rearches to zero.
4403  */
4404 void snd_hda_power_down(struct hda_codec *codec)
4405 {
4406         --codec->power_count;
4407         if (!codec->power_on || codec->power_count || codec->power_transition)
4408                 return;
4409         if (power_save(codec)) {
4410                 codec->power_transition = 1; /* avoid reentrance */
4411                 queue_delayed_work(codec->bus->workq, &codec->power_work,
4412                                 msecs_to_jiffies(power_save(codec) * 1000));
4413         }
4414 }
4415 EXPORT_SYMBOL_HDA(snd_hda_power_down);
4416
4417 /**
4418  * snd_hda_check_amp_list_power - Check the amp list and update the power
4419  * @codec: HD-audio codec
4420  * @check: the object containing an AMP list and the status
4421  * @nid: NID to check / update
4422  *
4423  * Check whether the given NID is in the amp list.  If it's in the list,
4424  * check the current AMP status, and update the the power-status according
4425  * to the mute status.
4426  *
4427  * This function is supposed to be set or called from the check_power_status
4428  * patch ops.
4429  */
4430 int snd_hda_check_amp_list_power(struct hda_codec *codec,
4431                                  struct hda_loopback_check *check,
4432                                  hda_nid_t nid)
4433 {
4434         const struct hda_amp_list *p;
4435         int ch, v;
4436
4437         if (!check->amplist)
4438                 return 0;
4439         for (p = check->amplist; p->nid; p++) {
4440                 if (p->nid == nid)
4441                         break;
4442         }
4443         if (!p->nid)
4444                 return 0; /* nothing changed */
4445
4446         for (p = check->amplist; p->nid; p++) {
4447                 for (ch = 0; ch < 2; ch++) {
4448                         v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4449                                                    p->idx);
4450                         if (!(v & HDA_AMP_MUTE) && v > 0) {
4451                                 if (!check->power_on) {
4452                                         check->power_on = 1;
4453                                         snd_hda_power_up(codec);
4454                                 }
4455                                 return 1;
4456                         }
4457                 }
4458         }
4459         if (check->power_on) {
4460                 check->power_on = 0;
4461                 snd_hda_power_down(codec);
4462         }
4463         return 0;
4464 }
4465 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
4466 #endif
4467
4468 /*
4469  * Channel mode helper
4470  */
4471
4472 /**
4473  * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4474  */
4475 int snd_hda_ch_mode_info(struct hda_codec *codec,
4476                          struct snd_ctl_elem_info *uinfo,
4477                          const struct hda_channel_mode *chmode,
4478                          int num_chmodes)
4479 {
4480         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4481         uinfo->count = 1;
4482         uinfo->value.enumerated.items = num_chmodes;
4483         if (uinfo->value.enumerated.item >= num_chmodes)
4484                 uinfo->value.enumerated.item = num_chmodes - 1;
4485         sprintf(uinfo->value.enumerated.name, "%dch",
4486                 chmode[uinfo->value.enumerated.item].channels);
4487         return 0;
4488 }
4489 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4490
4491 /**
4492  * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4493  */
4494 int snd_hda_ch_mode_get(struct hda_codec *codec,
4495                         struct snd_ctl_elem_value *ucontrol,
4496                         const struct hda_channel_mode *chmode,
4497                         int num_chmodes,
4498                         int max_channels)
4499 {
4500         int i;
4501
4502         for (i = 0; i < num_chmodes; i++) {
4503                 if (max_channels == chmode[i].channels) {
4504                         ucontrol->value.enumerated.item[0] = i;
4505                         break;
4506                 }
4507         }
4508         return 0;
4509 }
4510 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4511
4512 /**
4513  * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4514  */
4515 int snd_hda_ch_mode_put(struct hda_codec *codec,
4516                         struct snd_ctl_elem_value *ucontrol,
4517                         const struct hda_channel_mode *chmode,
4518                         int num_chmodes,
4519                         int *max_channelsp)
4520 {
4521         unsigned int mode;
4522
4523         mode = ucontrol->value.enumerated.item[0];
4524         if (mode >= num_chmodes)
4525                 return -EINVAL;
4526         if (*max_channelsp == chmode[mode].channels)
4527                 return 0;
4528         /* change the current channel setting */
4529         *max_channelsp = chmode[mode].channels;
4530         if (chmode[mode].sequence)
4531                 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4532         return 1;
4533 }
4534 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4535
4536 /*
4537  * input MUX helper
4538  */
4539
4540 /**
4541  * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4542  */
4543 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4544                            struct snd_ctl_elem_info *uinfo)
4545 {
4546         unsigned int index;
4547
4548         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4549         uinfo->count = 1;
4550         uinfo->value.enumerated.items = imux->num_items;
4551         if (!imux->num_items)
4552                 return 0;
4553         index = uinfo->value.enumerated.item;
4554         if (index >= imux->num_items)
4555                 index = imux->num_items - 1;
4556         strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4557         return 0;
4558 }
4559 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4560
4561 /**
4562  * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4563  */
4564 int snd_hda_input_mux_put(struct hda_codec *codec,
4565                           const struct hda_input_mux *imux,
4566                           struct snd_ctl_elem_value *ucontrol,
4567                           hda_nid_t nid,
4568                           unsigned int *cur_val)
4569 {
4570         unsigned int idx;
4571
4572         if (!imux->num_items)
4573                 return 0;
4574         idx = ucontrol->value.enumerated.item[0];
4575         if (idx >= imux->num_items)
4576                 idx = imux->num_items - 1;
4577         if (*cur_val == idx)
4578                 return 0;
4579         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4580                                   imux->items[idx].index);
4581         *cur_val = idx;
4582         return 1;
4583 }
4584 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4585
4586
4587 /*
4588  * Multi-channel / digital-out PCM helper functions
4589  */
4590
4591 /* setup SPDIF output stream */
4592 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4593                                  unsigned int stream_tag, unsigned int format)
4594 {
4595         struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4596
4597         /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4598         if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4599                 set_dig_out_convert(codec, nid,
4600                                     spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
4601                                     -1);
4602         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4603         if (codec->slave_dig_outs) {
4604                 const hda_nid_t *d;
4605                 for (d = codec->slave_dig_outs; *d; d++)
4606                         snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4607                                                    format);
4608         }
4609         /* turn on again (if needed) */
4610         if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4611                 set_dig_out_convert(codec, nid,
4612                                     spdif->ctls & 0xff, -1);
4613 }
4614
4615 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4616 {
4617         snd_hda_codec_cleanup_stream(codec, nid);
4618         if (codec->slave_dig_outs) {
4619                 const hda_nid_t *d;
4620                 for (d = codec->slave_dig_outs; *d; d++)
4621                         snd_hda_codec_cleanup_stream(codec, *d);
4622         }
4623 }
4624
4625 /**
4626  * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4627  * @bus: HD-audio bus
4628  */
4629 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4630 {
4631         struct hda_codec *codec;
4632
4633         if (!bus)
4634                 return;
4635         list_for_each_entry(codec, &bus->codec_list, list) {
4636                 if (hda_codec_is_power_on(codec) &&
4637                     codec->patch_ops.reboot_notify)
4638                         codec->patch_ops.reboot_notify(codec);
4639         }
4640 }
4641 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
4642
4643 /**
4644  * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4645  */
4646 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4647                                struct hda_multi_out *mout)
4648 {
4649         mutex_lock(&codec->spdif_mutex);
4650         if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4651                 /* already opened as analog dup; reset it once */
4652                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4653         mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4654         mutex_unlock(&codec->spdif_mutex);
4655         return 0;
4656 }
4657 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
4658
4659 /**
4660  * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4661  */
4662 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4663                                   struct hda_multi_out *mout,
4664                                   unsigned int stream_tag,
4665                                   unsigned int format,
4666                                   struct snd_pcm_substream *substream)
4667 {
4668         mutex_lock(&codec->spdif_mutex);
4669         setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4670         mutex_unlock(&codec->spdif_mutex);
4671         return 0;
4672 }
4673 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
4674
4675 /**
4676  * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4677  */
4678 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4679                                   struct hda_multi_out *mout)
4680 {
4681         mutex_lock(&codec->spdif_mutex);
4682         cleanup_dig_out_stream(codec, mout->dig_out_nid);
4683         mutex_unlock(&codec->spdif_mutex);
4684         return 0;
4685 }
4686 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4687
4688 /**
4689  * snd_hda_multi_out_dig_close - release the digital out stream
4690  */
4691 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4692                                 struct hda_multi_out *mout)
4693 {
4694         mutex_lock(&codec->spdif_mutex);
4695         mout->dig_out_used = 0;
4696         mutex_unlock(&codec->spdif_mutex);
4697         return 0;
4698 }
4699 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
4700
4701 /**
4702  * snd_hda_multi_out_analog_open - open analog outputs
4703  *
4704  * Open analog outputs and set up the hw-constraints.
4705  * If the digital outputs can be opened as slave, open the digital
4706  * outputs, too.
4707  */
4708 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4709                                   struct hda_multi_out *mout,
4710                                   struct snd_pcm_substream *substream,
4711                                   struct hda_pcm_stream *hinfo)
4712 {
4713         struct snd_pcm_runtime *runtime = substream->runtime;
4714         runtime->hw.channels_max = mout->max_channels;
4715         if (mout->dig_out_nid) {
4716                 if (!mout->analog_rates) {
4717                         mout->analog_rates = hinfo->rates;
4718                         mout->analog_formats = hinfo->formats;
4719                         mout->analog_maxbps = hinfo->maxbps;
4720                 } else {
4721                         runtime->hw.rates = mout->analog_rates;
4722                         runtime->hw.formats = mout->analog_formats;
4723                         hinfo->maxbps = mout->analog_maxbps;
4724                 }
4725                 if (!mout->spdif_rates) {
4726                         snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4727                                                     &mout->spdif_rates,
4728                                                     &mout->spdif_formats,
4729                                                     &mout->spdif_maxbps);
4730                 }
4731                 mutex_lock(&codec->spdif_mutex);
4732                 if (mout->share_spdif) {
4733                         if ((runtime->hw.rates & mout->spdif_rates) &&
4734                             (runtime->hw.formats & mout->spdif_formats)) {
4735                                 runtime->hw.rates &= mout->spdif_rates;
4736                                 runtime->hw.formats &= mout->spdif_formats;
4737                                 if (mout->spdif_maxbps < hinfo->maxbps)
4738                                         hinfo->maxbps = mout->spdif_maxbps;
4739                         } else {
4740                                 mout->share_spdif = 0;
4741                                 /* FIXME: need notify? */
4742                         }
4743                 }
4744                 mutex_unlock(&codec->spdif_mutex);
4745         }
4746         return snd_pcm_hw_constraint_step(substream->runtime, 0,
4747                                           SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4748 }
4749 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
4750
4751 /**
4752  * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4753  *
4754  * Set up the i/o for analog out.
4755  * When the digital out is available, copy the front out to digital out, too.
4756  */
4757 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4758                                      struct hda_multi_out *mout,
4759                                      unsigned int stream_tag,
4760                                      unsigned int format,
4761                                      struct snd_pcm_substream *substream)
4762 {
4763         const hda_nid_t *nids = mout->dac_nids;
4764         int chs = substream->runtime->channels;
4765         struct hda_spdif_out *spdif =
4766                         snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
4767         int i;
4768
4769         mutex_lock(&codec->spdif_mutex);
4770         if (mout->dig_out_nid && mout->share_spdif &&
4771             mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4772                 if (chs == 2 &&
4773                     snd_hda_is_supported_format(codec, mout->dig_out_nid,
4774                                                 format) &&
4775                     !(spdif->status & IEC958_AES0_NONAUDIO)) {
4776                         mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4777                         setup_dig_out_stream(codec, mout->dig_out_nid,
4778                                              stream_tag, format);
4779                 } else {
4780                         mout->dig_out_used = 0;
4781                         cleanup_dig_out_stream(codec, mout->dig_out_nid);
4782                 }
4783         }
4784         mutex_unlock(&codec->spdif_mutex);
4785
4786         /* front */
4787         snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4788                                    0, format);
4789         if (!mout->no_share_stream &&
4790             mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4791                 /* headphone out will just decode front left/right (stereo) */
4792                 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4793                                            0, format);
4794         /* extra outputs copied from front */
4795         for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4796                 if (!mout->no_share_stream && mout->hp_out_nid[i])
4797                         snd_hda_codec_setup_stream(codec,
4798                                                    mout->hp_out_nid[i],
4799                                                    stream_tag, 0, format);
4800         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4801                 if (!mout->no_share_stream && mout->extra_out_nid[i])
4802                         snd_hda_codec_setup_stream(codec,
4803                                                    mout->extra_out_nid[i],
4804                                                    stream_tag, 0, format);
4805
4806         /* surrounds */
4807         for (i = 1; i < mout->num_dacs; i++) {
4808                 if (chs >= (i + 1) * 2) /* independent out */
4809                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4810                                                    i * 2, format);
4811                 else if (!mout->no_share_stream) /* copy front */
4812                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4813                                                    0, format);
4814         }
4815         return 0;
4816 }
4817 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
4818
4819 /**
4820  * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4821  */
4822 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4823                                      struct hda_multi_out *mout)
4824 {
4825         const hda_nid_t *nids = mout->dac_nids;
4826         int i;
4827
4828         for (i = 0; i < mout->num_dacs; i++)
4829                 snd_hda_codec_cleanup_stream(codec, nids[i]);
4830         if (mout->hp_nid)
4831                 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4832         for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4833                 if (mout->hp_out_nid[i])
4834                         snd_hda_codec_cleanup_stream(codec,
4835                                                      mout->hp_out_nid[i]);
4836         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4837                 if (mout->extra_out_nid[i])
4838                         snd_hda_codec_cleanup_stream(codec,
4839                                                      mout->extra_out_nid[i]);
4840         mutex_lock(&codec->spdif_mutex);
4841         if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4842                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4843                 mout->dig_out_used = 0;
4844         }
4845         mutex_unlock(&codec->spdif_mutex);
4846         return 0;
4847 }
4848 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4849
4850 /*
4851  * Helper for automatic pin configuration
4852  */
4853
4854 static int is_in_nid_list(hda_nid_t nid, const hda_nid_t *list)
4855 {
4856         for (; *list; list++)
4857                 if (*list == nid)
4858                         return 1;
4859         return 0;
4860 }
4861
4862
4863 /*
4864  * Sort an associated group of pins according to their sequence numbers.
4865  */
4866 static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences,
4867                                   int num_pins)
4868 {
4869         int i, j;
4870         short seq;
4871         hda_nid_t nid;
4872
4873         for (i = 0; i < num_pins; i++) {
4874                 for (j = i + 1; j < num_pins; j++) {
4875                         if (sequences[i] > sequences[j]) {
4876                                 seq = sequences[i];
4877                                 sequences[i] = sequences[j];
4878                                 sequences[j] = seq;
4879                                 nid = pins[i];
4880                                 pins[i] = pins[j];
4881                                 pins[j] = nid;
4882                         }
4883                 }
4884         }
4885 }
4886
4887
4888 /* add the found input-pin to the cfg->inputs[] table */
4889 static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid,
4890                                    int type)
4891 {
4892         if (cfg->num_inputs < AUTO_CFG_MAX_INS) {
4893                 cfg->inputs[cfg->num_inputs].pin = nid;
4894                 cfg->inputs[cfg->num_inputs].type = type;
4895                 cfg->num_inputs++;
4896         }
4897 }
4898
4899 /* sort inputs in the order of AUTO_PIN_* type */
4900 static void sort_autocfg_input_pins(struct auto_pin_cfg *cfg)
4901 {
4902         int i, j;
4903
4904         for (i = 0; i < cfg->num_inputs; i++) {
4905                 for (j = i + 1; j < cfg->num_inputs; j++) {
4906                         if (cfg->inputs[i].type > cfg->inputs[j].type) {
4907                                 struct auto_pin_cfg_item tmp;
4908                                 tmp = cfg->inputs[i];
4909                                 cfg->inputs[i] = cfg->inputs[j];
4910                                 cfg->inputs[j] = tmp;
4911                         }
4912                 }
4913         }
4914 }
4915
4916 /* Reorder the surround channels
4917  * ALSA sequence is front/surr/clfe/side
4918  * HDA sequence is:
4919  *    4-ch: front/surr  =>  OK as it is
4920  *    6-ch: front/clfe/surr
4921  *    8-ch: front/clfe/rear/side|fc
4922  */
4923 static void reorder_outputs(unsigned int nums, hda_nid_t *pins)
4924 {
4925         hda_nid_t nid;
4926
4927         switch (nums) {
4928         case 3:
4929         case 4:
4930                 nid = pins[1];
4931                 pins[1] = pins[2];
4932                 pins[2] = nid;
4933                 break;
4934         }
4935 }
4936
4937 /*
4938  * Parse all pin widgets and store the useful pin nids to cfg
4939  *
4940  * The number of line-outs or any primary output is stored in line_outs,
4941  * and the corresponding output pins are assigned to line_out_pins[],
4942  * in the order of front, rear, CLFE, side, ...
4943  *
4944  * If more extra outputs (speaker and headphone) are found, the pins are
4945  * assisnged to hp_pins[] and speaker_pins[], respectively.  If no line-out jack
4946  * is detected, one of speaker of HP pins is assigned as the primary
4947  * output, i.e. to line_out_pins[0].  So, line_outs is always positive
4948  * if any analog output exists.
4949  *
4950  * The analog input pins are assigned to inputs array.
4951  * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4952  * respectively.
4953  */
4954 int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
4955                              struct auto_pin_cfg *cfg,
4956                              const hda_nid_t *ignore_nids,
4957                              unsigned int cond_flags)
4958 {
4959         hda_nid_t nid, end_nid;
4960         short seq, assoc_line_out;
4961         short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4962         short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
4963         short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
4964         int i;
4965
4966         memset(cfg, 0, sizeof(*cfg));
4967
4968         memset(sequences_line_out, 0, sizeof(sequences_line_out));
4969         memset(sequences_speaker, 0, sizeof(sequences_speaker));
4970         memset(sequences_hp, 0, sizeof(sequences_hp));
4971         assoc_line_out = 0;
4972
4973         codec->ignore_misc_bit = true;
4974         end_nid = codec->start_nid + codec->num_nodes;
4975         for (nid = codec->start_nid; nid < end_nid; nid++) {
4976                 unsigned int wid_caps = get_wcaps(codec, nid);
4977                 unsigned int wid_type = get_wcaps_type(wid_caps);
4978                 unsigned int def_conf;
4979                 short assoc, loc, conn, dev;
4980
4981                 /* read all default configuration for pin complex */
4982                 if (wid_type != AC_WID_PIN)
4983                         continue;
4984                 /* ignore the given nids (e.g. pc-beep returns error) */
4985                 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4986                         continue;
4987
4988                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4989                 if (!(get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
4990                       AC_DEFCFG_MISC_NO_PRESENCE))
4991                         codec->ignore_misc_bit = false;
4992                 conn = get_defcfg_connect(def_conf);
4993                 if (conn == AC_JACK_PORT_NONE)
4994                         continue;
4995                 loc = get_defcfg_location(def_conf);
4996                 dev = get_defcfg_device(def_conf);
4997
4998                 /* workaround for buggy BIOS setups */
4999                 if (dev == AC_JACK_LINE_OUT) {
5000                         if (conn == AC_JACK_PORT_FIXED)
5001                                 dev = AC_JACK_SPEAKER;
5002                 }
5003
5004                 switch (dev) {
5005                 case AC_JACK_LINE_OUT:
5006                         seq = get_defcfg_sequence(def_conf);
5007                         assoc = get_defcfg_association(def_conf);
5008
5009                         if (!(wid_caps & AC_WCAP_STEREO))
5010                                 if (!cfg->mono_out_pin)
5011                                         cfg->mono_out_pin = nid;
5012                         if (!assoc)
5013                                 continue;
5014                         if (!assoc_line_out)
5015                                 assoc_line_out = assoc;
5016                         else if (assoc_line_out != assoc)
5017                                 continue;
5018                         if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
5019                                 continue;
5020                         cfg->line_out_pins[cfg->line_outs] = nid;
5021                         sequences_line_out[cfg->line_outs] = seq;
5022                         cfg->line_outs++;
5023                         break;
5024                 case AC_JACK_SPEAKER:
5025                         seq = get_defcfg_sequence(def_conf);
5026                         assoc = get_defcfg_association(def_conf);
5027                         if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
5028                                 continue;
5029                         cfg->speaker_pins[cfg->speaker_outs] = nid;
5030                         sequences_speaker[cfg->speaker_outs] = (assoc << 4) | seq;
5031                         cfg->speaker_outs++;
5032                         break;
5033                 case AC_JACK_HP_OUT:
5034                         seq = get_defcfg_sequence(def_conf);
5035                         assoc = get_defcfg_association(def_conf);
5036                         if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
5037                                 continue;
5038                         cfg->hp_pins[cfg->hp_outs] = nid;
5039                         sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
5040                         cfg->hp_outs++;
5041                         break;
5042                 case AC_JACK_MIC_IN:
5043                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_MIC);
5044                         break;
5045                 case AC_JACK_LINE_IN:
5046                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_LINE_IN);
5047                         break;
5048                 case AC_JACK_CD:
5049                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD);
5050                         break;
5051                 case AC_JACK_AUX:
5052                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX);
5053                         break;
5054                 case AC_JACK_SPDIF_OUT:
5055                 case AC_JACK_DIG_OTHER_OUT:
5056                         if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
5057                                 continue;
5058                         cfg->dig_out_pins[cfg->dig_outs] = nid;
5059                         cfg->dig_out_type[cfg->dig_outs] =
5060                                 (loc == AC_JACK_LOC_HDMI) ?
5061                                 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
5062                         cfg->dig_outs++;
5063                         break;
5064                 case AC_JACK_SPDIF_IN:
5065                 case AC_JACK_DIG_OTHER_IN:
5066                         cfg->dig_in_pin = nid;
5067                         if (loc == AC_JACK_LOC_HDMI)
5068                                 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
5069                         else
5070                                 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
5071                         break;
5072                 }
5073         }
5074
5075         /* FIX-UP:
5076          * If no line-out is defined but multiple HPs are found,
5077          * some of them might be the real line-outs.
5078          */
5079         if (!cfg->line_outs && cfg->hp_outs > 1 &&
5080             !(cond_flags & HDA_PINCFG_NO_HP_FIXUP)) {
5081                 int i = 0;
5082                 while (i < cfg->hp_outs) {
5083                         /* The real HPs should have the sequence 0x0f */
5084                         if ((sequences_hp[i] & 0x0f) == 0x0f) {
5085                                 i++;
5086                                 continue;
5087                         }
5088                         /* Move it to the line-out table */
5089                         cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
5090                         sequences_line_out[cfg->line_outs] = sequences_hp[i];
5091                         cfg->line_outs++;
5092                         cfg->hp_outs--;
5093                         memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
5094                                 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
5095                         memmove(sequences_hp + i, sequences_hp + i + 1,
5096                                 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
5097                 }
5098                 memset(cfg->hp_pins + cfg->hp_outs, 0,
5099                        sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs));
5100                 if (!cfg->hp_outs)
5101                         cfg->line_out_type = AUTO_PIN_HP_OUT;
5102
5103         }
5104
5105         /* sort by sequence */
5106         sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
5107                               cfg->line_outs);
5108         sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
5109                               cfg->speaker_outs);
5110         sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
5111                               cfg->hp_outs);
5112
5113         /*
5114          * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
5115          * as a primary output
5116          */
5117         if (!cfg->line_outs &&
5118             !(cond_flags & HDA_PINCFG_NO_LO_FIXUP)) {
5119                 if (cfg->speaker_outs) {
5120                         cfg->line_outs = cfg->speaker_outs;
5121                         memcpy(cfg->line_out_pins, cfg->speaker_pins,
5122                                sizeof(cfg->speaker_pins));
5123                         cfg->speaker_outs = 0;
5124                         memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
5125                         cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
5126                 } else if (cfg->hp_outs) {
5127                         cfg->line_outs = cfg->hp_outs;
5128                         memcpy(cfg->line_out_pins, cfg->hp_pins,
5129                                sizeof(cfg->hp_pins));
5130                         cfg->hp_outs = 0;
5131                         memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
5132                         cfg->line_out_type = AUTO_PIN_HP_OUT;
5133                 }
5134         }
5135
5136         reorder_outputs(cfg->line_outs, cfg->line_out_pins);
5137         reorder_outputs(cfg->hp_outs, cfg->hp_pins);
5138         reorder_outputs(cfg->speaker_outs, cfg->speaker_pins);
5139
5140         sort_autocfg_input_pins(cfg);
5141
5142         /*
5143          * debug prints of the parsed results
5144          */
5145         snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
5146                    cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
5147                    cfg->line_out_pins[2], cfg->line_out_pins[3],
5148                    cfg->line_out_pins[4],
5149                    cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
5150                    (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT ?
5151                     "speaker" : "line"));
5152         snd_printd("   speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
5153                    cfg->speaker_outs, cfg->speaker_pins[0],
5154                    cfg->speaker_pins[1], cfg->speaker_pins[2],
5155                    cfg->speaker_pins[3], cfg->speaker_pins[4]);
5156         snd_printd("   hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
5157                    cfg->hp_outs, cfg->hp_pins[0],
5158                    cfg->hp_pins[1], cfg->hp_pins[2],
5159                    cfg->hp_pins[3], cfg->hp_pins[4]);
5160         snd_printd("   mono: mono_out=0x%x\n", cfg->mono_out_pin);
5161         if (cfg->dig_outs)
5162                 snd_printd("   dig-out=0x%x/0x%x\n",
5163                            cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
5164         snd_printd("   inputs:");
5165         for (i = 0; i < cfg->num_inputs; i++) {
5166                 snd_printd(" %s=0x%x",
5167                             hda_get_autocfg_input_label(codec, cfg, i),
5168                             cfg->inputs[i].pin);
5169         }
5170         snd_printd("\n");
5171         if (cfg->dig_in_pin)
5172                 snd_printd("   dig-in=0x%x\n", cfg->dig_in_pin);
5173
5174         return 0;
5175 }
5176 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_defcfg);
5177
5178 int snd_hda_get_input_pin_attr(unsigned int def_conf)
5179 {
5180         unsigned int loc = get_defcfg_location(def_conf);
5181         unsigned int conn = get_defcfg_connect(def_conf);
5182         if (conn == AC_JACK_PORT_NONE)
5183                 return INPUT_PIN_ATTR_UNUSED;
5184         /* Windows may claim the internal mic to be BOTH, too */
5185         if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH)
5186                 return INPUT_PIN_ATTR_INT;
5187         if ((loc & 0x30) == AC_JACK_LOC_INTERNAL)
5188                 return INPUT_PIN_ATTR_INT;
5189         if ((loc & 0x30) == AC_JACK_LOC_SEPARATE)
5190                 return INPUT_PIN_ATTR_DOCK;
5191         if (loc == AC_JACK_LOC_REAR)
5192                 return INPUT_PIN_ATTR_REAR;
5193         if (loc == AC_JACK_LOC_FRONT)
5194                 return INPUT_PIN_ATTR_FRONT;
5195         return INPUT_PIN_ATTR_NORMAL;
5196 }
5197 EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
5198
5199 /**
5200  * hda_get_input_pin_label - Give a label for the given input pin
5201  *
5202  * When check_location is true, the function checks the pin location
5203  * for mic and line-in pins, and set an appropriate prefix like "Front",
5204  * "Rear", "Internal".
5205  */
5206
5207 static const char *hda_get_input_pin_label(struct hda_codec *codec,
5208                                            hda_nid_t pin, bool check_location)
5209 {
5210         unsigned int def_conf;
5211         static const char * const mic_names[] = {
5212                 "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic",
5213         };
5214         int attr;
5215
5216         def_conf = snd_hda_codec_get_pincfg(codec, pin);
5217
5218         switch (get_defcfg_device(def_conf)) {
5219         case AC_JACK_MIC_IN:
5220                 if (!check_location)
5221                         return "Mic";
5222                 attr = snd_hda_get_input_pin_attr(def_conf);
5223                 if (!attr)
5224                         return "None";
5225                 return mic_names[attr - 1];
5226         case AC_JACK_LINE_IN:
5227                 if (!check_location)
5228                         return "Line";
5229                 attr = snd_hda_get_input_pin_attr(def_conf);
5230                 if (!attr)
5231                         return "None";
5232                 if (attr == INPUT_PIN_ATTR_DOCK)
5233                         return "Dock Line";
5234                 return "Line";
5235         case AC_JACK_AUX:
5236                 return "Aux";
5237         case AC_JACK_CD:
5238                 return "CD";
5239         case AC_JACK_SPDIF_IN:
5240                 return "SPDIF In";
5241         case AC_JACK_DIG_OTHER_IN:
5242                 return "Digital In";
5243         default:
5244                 return "Misc";
5245         }
5246 }
5247
5248 /* Check whether the location prefix needs to be added to the label.
5249  * If all mic-jacks are in the same location (e.g. rear panel), we don't
5250  * have to put "Front" prefix to each label.  In such a case, returns false.
5251  */
5252 static int check_mic_location_need(struct hda_codec *codec,
5253                                    const struct auto_pin_cfg *cfg,
5254                                    int input)
5255 {
5256         unsigned int defc;
5257         int i, attr, attr2;
5258
5259         defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin);
5260         attr = snd_hda_get_input_pin_attr(defc);
5261         /* for internal or docking mics, we need locations */
5262         if (attr <= INPUT_PIN_ATTR_NORMAL)
5263                 return 1;
5264
5265         attr = 0;
5266         for (i = 0; i < cfg->num_inputs; i++) {
5267                 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin);
5268                 attr2 = snd_hda_get_input_pin_attr(defc);
5269                 if (attr2 >= INPUT_PIN_ATTR_NORMAL) {
5270                         if (attr && attr != attr2)
5271                                 return 1; /* different locations found */
5272                         attr = attr2;
5273                 }
5274         }
5275         return 0;
5276 }
5277
5278 /**
5279  * hda_get_autocfg_input_label - Get a label for the given input
5280  *
5281  * Get a label for the given input pin defined by the autocfg item.
5282  * Unlike hda_get_input_pin_label(), this function checks all inputs
5283  * defined in autocfg and avoids the redundant mic/line prefix as much as
5284  * possible.
5285  */
5286 const char *hda_get_autocfg_input_label(struct hda_codec *codec,
5287                                         const struct auto_pin_cfg *cfg,
5288                                         int input)
5289 {
5290         int type = cfg->inputs[input].type;
5291         int has_multiple_pins = 0;
5292
5293         if ((input > 0 && cfg->inputs[input - 1].type == type) ||
5294             (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type))
5295                 has_multiple_pins = 1;
5296         if (has_multiple_pins && type == AUTO_PIN_MIC)
5297                 has_multiple_pins &= check_mic_location_need(codec, cfg, input);
5298         return hda_get_input_pin_label(codec, cfg->inputs[input].pin,
5299                                        has_multiple_pins);
5300 }
5301 EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
5302
5303 /* return the position of NID in the list, or -1 if not found */
5304 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
5305 {
5306         int i;
5307         for (i = 0; i < nums; i++)
5308                 if (list[i] == nid)
5309                         return i;
5310         return -1;
5311 }
5312
5313 /* get a unique suffix or an index number */
5314 static const char *check_output_sfx(hda_nid_t nid, const hda_nid_t *pins,
5315                                     int num_pins, int *indexp)
5316 {
5317         static const char * const channel_sfx[] = {
5318                 " Front", " Surround", " CLFE", " Side"
5319         };
5320         int i;
5321
5322         i = find_idx_in_nid_list(nid, pins, num_pins);
5323         if (i < 0)
5324                 return NULL;
5325         if (num_pins == 1)
5326                 return "";
5327         if (num_pins > ARRAY_SIZE(channel_sfx)) {
5328                 if (indexp)
5329                         *indexp = i;
5330                 return "";
5331         }
5332         return channel_sfx[i];
5333 }
5334
5335 static int fill_audio_out_name(struct hda_codec *codec, hda_nid_t nid,
5336                                const struct auto_pin_cfg *cfg,
5337                                const char *name, char *label, int maxlen,
5338                                int *indexp)
5339 {
5340         unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5341         int attr = snd_hda_get_input_pin_attr(def_conf);
5342         const char *pfx = "", *sfx = "";
5343
5344         /* handle as a speaker if it's a fixed line-out */
5345         if (!strcmp(name, "Line Out") && attr == INPUT_PIN_ATTR_INT)
5346                 name = "Speaker";
5347         /* check the location */
5348         switch (attr) {
5349         case INPUT_PIN_ATTR_DOCK:
5350                 pfx = "Dock ";
5351                 break;
5352         case INPUT_PIN_ATTR_FRONT:
5353                 pfx = "Front ";
5354                 break;
5355         }
5356         if (cfg) {
5357                 /* try to give a unique suffix if needed */
5358                 sfx = check_output_sfx(nid, cfg->line_out_pins, cfg->line_outs,
5359                                        indexp);
5360                 if (!sfx)
5361                         sfx = check_output_sfx(nid, cfg->speaker_pins, cfg->speaker_outs,
5362                                                indexp);
5363                 if (!sfx) {
5364                         /* don't add channel suffix for Headphone controls */
5365                         int idx = find_idx_in_nid_list(nid, cfg->hp_pins,
5366                                                        cfg->hp_outs);
5367                         if (idx >= 0)
5368                                 *indexp = idx;
5369                         sfx = "";
5370                 }
5371         }
5372         snprintf(label, maxlen, "%s%s%s", pfx, name, sfx);
5373         return 1;
5374 }
5375
5376 /**
5377  * snd_hda_get_pin_label - Get a label for the given I/O pin
5378  *
5379  * Get a label for the given pin.  This function works for both input and
5380  * output pins.  When @cfg is given as non-NULL, the function tries to get
5381  * an optimized label using hda_get_autocfg_input_label().
5382  *
5383  * This function tries to give a unique label string for the pin as much as
5384  * possible.  For example, when the multiple line-outs are present, it adds
5385  * the channel suffix like "Front", "Surround", etc (only when @cfg is given).
5386  * If no unique name with a suffix is available and @indexp is non-NULL, the
5387  * index number is stored in the pointer.
5388  */
5389 int snd_hda_get_pin_label(struct hda_codec *codec, hda_nid_t nid,
5390                           const struct auto_pin_cfg *cfg,
5391                           char *label, int maxlen, int *indexp)
5392 {
5393         unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5394         const char *name = NULL;
5395         int i;
5396
5397         if (indexp)
5398                 *indexp = 0;
5399         if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
5400                 return 0;
5401
5402         switch (get_defcfg_device(def_conf)) {
5403         case AC_JACK_LINE_OUT:
5404                 return fill_audio_out_name(codec, nid, cfg, "Line Out",
5405                                            label, maxlen, indexp);
5406         case AC_JACK_SPEAKER:
5407                 return fill_audio_out_name(codec, nid, cfg, "Speaker",
5408                                            label, maxlen, indexp);
5409         case AC_JACK_HP_OUT:
5410                 return fill_audio_out_name(codec, nid, cfg, "Headphone",
5411                                            label, maxlen, indexp);
5412         case AC_JACK_SPDIF_OUT:
5413         case AC_JACK_DIG_OTHER_OUT:
5414                 if (get_defcfg_location(def_conf) == AC_JACK_LOC_HDMI)
5415                         name = "HDMI";
5416                 else
5417                         name = "SPDIF";
5418                 if (cfg && indexp) {
5419                         i = find_idx_in_nid_list(nid, cfg->dig_out_pins,
5420                                                  cfg->dig_outs);
5421                         if (i >= 0)
5422                                 *indexp = i;
5423                 }
5424                 break;
5425         default:
5426                 if (cfg) {
5427                         for (i = 0; i < cfg->num_inputs; i++) {
5428                                 if (cfg->inputs[i].pin != nid)
5429                                         continue;
5430                                 name = hda_get_autocfg_input_label(codec, cfg, i);
5431                                 if (name)
5432                                         break;
5433                         }
5434                 }
5435                 if (!name)
5436                         name = hda_get_input_pin_label(codec, nid, true);
5437                 break;
5438         }
5439         if (!name)
5440                 return 0;
5441         strlcpy(label, name, maxlen);
5442         return 1;
5443 }
5444 EXPORT_SYMBOL_HDA(snd_hda_get_pin_label);
5445
5446 /**
5447  * snd_hda_add_imux_item - Add an item to input_mux
5448  *
5449  * When the same label is used already in the existing items, the number
5450  * suffix is appended to the label.  This label index number is stored
5451  * to type_idx when non-NULL pointer is given.
5452  */
5453 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5454                           int index, int *type_idx)
5455 {
5456         int i, label_idx = 0;
5457         if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5458                 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5459                 return -EINVAL;
5460         }
5461         for (i = 0; i < imux->num_items; i++) {
5462                 if (!strncmp(label, imux->items[i].label, strlen(label)))
5463                         label_idx++;
5464         }
5465         if (type_idx)
5466                 *type_idx = label_idx;
5467         if (label_idx > 0)
5468                 snprintf(imux->items[imux->num_items].label,
5469                          sizeof(imux->items[imux->num_items].label),
5470                          "%s %d", label, label_idx);
5471         else
5472                 strlcpy(imux->items[imux->num_items].label, label,
5473                         sizeof(imux->items[imux->num_items].label));
5474         imux->items[imux->num_items].index = index;
5475         imux->num_items++;
5476         return 0;
5477 }
5478 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5479
5480
5481 #ifdef CONFIG_PM
5482 /*
5483  * power management
5484  */
5485
5486 /**
5487  * snd_hda_suspend - suspend the codecs
5488  * @bus: the HDA bus
5489  *
5490  * Returns 0 if successful.
5491  */
5492 int snd_hda_suspend(struct hda_bus *bus)
5493 {
5494         struct hda_codec *codec;
5495
5496         list_for_each_entry(codec, &bus->codec_list, list) {
5497                 if (hda_codec_is_power_on(codec))
5498                         hda_call_codec_suspend(codec);
5499                 if (codec->patch_ops.post_suspend)
5500                         codec->patch_ops.post_suspend(codec);
5501         }
5502         return 0;
5503 }
5504 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5505
5506 /**
5507  * snd_hda_resume - resume the codecs
5508  * @bus: the HDA bus
5509  *
5510  * Returns 0 if successful.
5511  *
5512  * This function is defined only when POWER_SAVE isn't set.
5513  * In the power-save mode, the codec is resumed dynamically.
5514  */
5515 int snd_hda_resume(struct hda_bus *bus)
5516 {
5517         struct hda_codec *codec;
5518
5519         list_for_each_entry(codec, &bus->codec_list, list) {
5520                 if (codec->patch_ops.pre_resume)
5521                         codec->patch_ops.pre_resume(codec);
5522                 if (snd_hda_codec_needs_resume(codec))
5523                         hda_call_codec_resume(codec);
5524         }
5525         return 0;
5526 }
5527 EXPORT_SYMBOL_HDA(snd_hda_resume);
5528 #endif /* CONFIG_PM */
5529
5530 /*
5531  * generic arrays
5532  */
5533
5534 /**
5535  * snd_array_new - get a new element from the given array
5536  * @array: the array object
5537  *
5538  * Get a new element from the given array.  If it exceeds the
5539  * pre-allocated array size, re-allocate the array.
5540  *
5541  * Returns NULL if allocation failed.
5542  */
5543 void *snd_array_new(struct snd_array *array)
5544 {
5545         if (array->used >= array->alloced) {
5546                 int num = array->alloced + array->alloc_align;
5547                 int size = (num + 1) * array->elem_size;
5548                 int oldsize = array->alloced * array->elem_size;
5549                 void *nlist;
5550                 if (snd_BUG_ON(num >= 4096))
5551                         return NULL;
5552                 nlist = krealloc(array->list, size, GFP_KERNEL);
5553                 if (!nlist)
5554                         return NULL;
5555                 memset(nlist + oldsize, 0, size - oldsize);
5556                 array->list = nlist;
5557                 array->alloced = num;
5558         }
5559         return snd_array_elem(array, array->used++);
5560 }
5561 EXPORT_SYMBOL_HDA(snd_array_new);
5562
5563 /**
5564  * snd_array_free - free the given array elements
5565  * @array: the array object
5566  */
5567 void snd_array_free(struct snd_array *array)
5568 {
5569         kfree(array->list);
5570         array->used = 0;
5571         array->alloced = 0;
5572         array->list = NULL;
5573 }
5574 EXPORT_SYMBOL_HDA(snd_array_free);
5575
5576 /**
5577  * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5578  * @pcm: PCM caps bits
5579  * @buf: the string buffer to write
5580  * @buflen: the max buffer length
5581  *
5582  * used by hda_proc.c and hda_eld.c
5583  */
5584 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5585 {
5586         static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5587         int i, j;
5588
5589         for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5590                 if (pcm & (AC_SUPPCM_BITS_8 << i))
5591                         j += snprintf(buf + j, buflen - j,  " %d", bits[i]);
5592
5593         buf[j] = '\0'; /* necessary when j == 0 */
5594 }
5595 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5596
5597 MODULE_DESCRIPTION("HDA codec core");
5598 MODULE_LICENSE("GPL");