6f3a85740e59fed71d7e668e035b75673c5d0026
[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_hdmi_decode_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 static int snd_hda_hdmi_decode_get(struct snd_kcontrol *kcontrol,
3032                                         struct snd_ctl_elem_value *ucontrol)
3033 {
3034         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3035
3036         ucontrol->value.integer.value[0] = codec->recv_dec_cap;
3037         return 0;
3038 }
3039
3040 static struct snd_kcontrol_new dig_mixes[] = {
3041         {
3042                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3043                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3044                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3045                 .info = snd_hda_spdif_mask_info,
3046                 .get = snd_hda_spdif_cmask_get,
3047         },
3048         {
3049                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3050                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3051                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3052                 .info = snd_hda_spdif_mask_info,
3053                 .get = snd_hda_spdif_pmask_get,
3054         },
3055         {
3056                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3057                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3058                 .info = snd_hda_spdif_mask_info,
3059                 .get = snd_hda_spdif_default_get,
3060                 .put = snd_hda_spdif_default_put,
3061         },
3062         {
3063                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3064                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3065                 .info = snd_hda_spdif_out_switch_info,
3066                 .get = snd_hda_spdif_out_switch_get,
3067                 .put = snd_hda_spdif_out_switch_put,
3068         },
3069         {
3070                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3071                 .name = "HDA Decode Capability",
3072                 .info = snd_hda_hdmi_decode_info,
3073                 .get = snd_hda_hdmi_decode_get,
3074         },
3075         { } /* end */
3076 };
3077
3078 /**
3079  * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
3080  * @codec: the HDA codec
3081  * @nid: audio out widget NID
3082  *
3083  * Creates controls related with the SPDIF output.
3084  * Called from each patch supporting the SPDIF out.
3085  *
3086  * Returns 0 if successful, or a negative error code.
3087  */
3088 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
3089                                   hda_nid_t associated_nid,
3090                                   hda_nid_t cvt_nid)
3091 {
3092         int err;
3093         struct snd_kcontrol *kctl;
3094         struct snd_kcontrol_new *dig_mix;
3095         int idx;
3096         struct hda_spdif_out *spdif;
3097
3098         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
3099         if (idx < 0) {
3100                 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3101                 return -EBUSY;
3102         }
3103         spdif = snd_array_new(&codec->spdif_out);
3104         for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3105                 kctl = snd_ctl_new1(dig_mix, codec);
3106                 if (!kctl)
3107                         return -ENOMEM;
3108                 kctl->id.index = idx;
3109                 kctl->private_value = codec->spdif_out.used - 1;
3110                 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3111                 if (err < 0)
3112                         return err;
3113         }
3114         spdif->nid = cvt_nid;
3115         spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3116                                          AC_VERB_GET_DIGI_CONVERT_1, 0);
3117         spdif->status = convert_to_spdif_status(spdif->ctls);
3118         return 0;
3119 }
3120 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
3121
3122 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3123                                                hda_nid_t nid)
3124 {
3125         int i;
3126         for (i = 0; i < codec->spdif_out.used; i++) {
3127                 struct hda_spdif_out *spdif =
3128                                 snd_array_elem(&codec->spdif_out, i);
3129                 if (spdif->nid == nid)
3130                         return spdif;
3131         }
3132         return NULL;
3133 }
3134 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3135
3136 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3137 {
3138         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
3139
3140         mutex_lock(&codec->spdif_mutex);
3141         spdif->nid = (u16)-1;
3142         mutex_unlock(&codec->spdif_mutex);
3143 }
3144 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3145
3146 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3147 {
3148         struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
3149         unsigned short val;
3150
3151         mutex_lock(&codec->spdif_mutex);
3152         if (spdif->nid != nid) {
3153                 spdif->nid = nid;
3154                 val = spdif->ctls;
3155                 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3156         }
3157         mutex_unlock(&codec->spdif_mutex);
3158 }
3159 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3160
3161 /*
3162  * SPDIF sharing with analog output
3163  */
3164 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3165                               struct snd_ctl_elem_value *ucontrol)
3166 {
3167         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3168         ucontrol->value.integer.value[0] = mout->share_spdif;
3169         return 0;
3170 }
3171
3172 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3173                               struct snd_ctl_elem_value *ucontrol)
3174 {
3175         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3176         mout->share_spdif = !!ucontrol->value.integer.value[0];
3177         return 0;
3178 }
3179
3180 static struct snd_kcontrol_new spdif_share_sw = {
3181         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3182         .name = "IEC958 Default PCM Playback Switch",
3183         .info = snd_ctl_boolean_mono_info,
3184         .get = spdif_share_sw_get,
3185         .put = spdif_share_sw_put,
3186 };
3187
3188 /**
3189  * snd_hda_create_spdif_share_sw - create Default PCM switch
3190  * @codec: the HDA codec
3191  * @mout: multi-out instance
3192  */
3193 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3194                                   struct hda_multi_out *mout)
3195 {
3196         if (!mout->dig_out_nid)
3197                 return 0;
3198         /* ATTENTION: here mout is passed as private_data, instead of codec */
3199         return snd_hda_ctl_add(codec, mout->dig_out_nid,
3200                               snd_ctl_new1(&spdif_share_sw, mout));
3201 }
3202 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3203
3204 /*
3205  * SPDIF input
3206  */
3207
3208 #define snd_hda_spdif_in_switch_info    snd_hda_spdif_out_switch_info
3209
3210 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3211                                        struct snd_ctl_elem_value *ucontrol)
3212 {
3213         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3214
3215         ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3216         return 0;
3217 }
3218
3219 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3220                                        struct snd_ctl_elem_value *ucontrol)
3221 {
3222         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3223         hda_nid_t nid = kcontrol->private_value;
3224         unsigned int val = !!ucontrol->value.integer.value[0];
3225         int change;
3226
3227         mutex_lock(&codec->spdif_mutex);
3228         change = codec->spdif_in_enable != val;
3229         if (change) {
3230                 codec->spdif_in_enable = val;
3231                 snd_hda_codec_write_cache(codec, nid, 0,
3232                                           AC_VERB_SET_DIGI_CONVERT_1, val);
3233         }
3234         mutex_unlock(&codec->spdif_mutex);
3235         return change;
3236 }
3237
3238 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3239                                        struct snd_ctl_elem_value *ucontrol)
3240 {
3241         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3242         hda_nid_t nid = kcontrol->private_value;
3243         unsigned short val;
3244         unsigned int sbits;
3245
3246         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3247         sbits = convert_to_spdif_status(val);
3248         ucontrol->value.iec958.status[0] = sbits;
3249         ucontrol->value.iec958.status[1] = sbits >> 8;
3250         ucontrol->value.iec958.status[2] = sbits >> 16;
3251         ucontrol->value.iec958.status[3] = sbits >> 24;
3252         return 0;
3253 }
3254
3255 static struct snd_kcontrol_new dig_in_ctls[] = {
3256         {
3257                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3258                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3259                 .info = snd_hda_spdif_in_switch_info,
3260                 .get = snd_hda_spdif_in_switch_get,
3261                 .put = snd_hda_spdif_in_switch_put,
3262         },
3263         {
3264                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3265                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3266                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3267                 .info = snd_hda_spdif_mask_info,
3268                 .get = snd_hda_spdif_in_status_get,
3269         },
3270         { } /* end */
3271 };
3272
3273 /**
3274  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3275  * @codec: the HDA codec
3276  * @nid: audio in widget NID
3277  *
3278  * Creates controls related with the SPDIF input.
3279  * Called from each patch supporting the SPDIF in.
3280  *
3281  * Returns 0 if successful, or a negative error code.
3282  */
3283 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3284 {
3285         int err;
3286         struct snd_kcontrol *kctl;
3287         struct snd_kcontrol_new *dig_mix;
3288         int idx;
3289
3290         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3291         if (idx < 0) {
3292                 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3293                 return -EBUSY;
3294         }
3295         for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3296                 kctl = snd_ctl_new1(dig_mix, codec);
3297                 if (!kctl)
3298                         return -ENOMEM;
3299                 kctl->private_value = nid;
3300                 err = snd_hda_ctl_add(codec, nid, kctl);
3301                 if (err < 0)
3302                         return err;
3303         }
3304         codec->spdif_in_enable =
3305                 snd_hda_codec_read(codec, nid, 0,
3306                                    AC_VERB_GET_DIGI_CONVERT_1, 0) &
3307                 AC_DIG1_ENABLE;
3308         return 0;
3309 }
3310 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3311
3312 #ifdef CONFIG_PM
3313 /*
3314  * command cache
3315  */
3316
3317 /* build a 32bit cache key with the widget id and the command parameter */
3318 #define build_cmd_cache_key(nid, verb)  ((verb << 8) | nid)
3319 #define get_cmd_cache_nid(key)          ((key) & 0xff)
3320 #define get_cmd_cache_cmd(key)          (((key) >> 8) & 0xffff)
3321
3322 /**
3323  * snd_hda_codec_write_cache - send a single command with caching
3324  * @codec: the HDA codec
3325  * @nid: NID to send the command
3326  * @direct: direct flag
3327  * @verb: the verb to send
3328  * @parm: the parameter for the verb
3329  *
3330  * Send a single command without waiting for response.
3331  *
3332  * Returns 0 if successful, or a negative error code.
3333  */
3334 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3335                               int direct, unsigned int verb, unsigned int parm)
3336 {
3337         int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3338         struct hda_cache_head *c;
3339         u32 key;
3340
3341         if (err < 0)
3342                 return err;
3343         /* parm may contain the verb stuff for get/set amp */
3344         verb = verb | (parm >> 8);
3345         parm &= 0xff;
3346         key = build_cmd_cache_key(nid, verb);
3347         mutex_lock(&codec->bus->cmd_mutex);
3348         c = get_alloc_hash(&codec->cmd_cache, key);
3349         if (c)
3350                 c->val = parm;
3351         mutex_unlock(&codec->bus->cmd_mutex);
3352         return 0;
3353 }
3354 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3355
3356 /**
3357  * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3358  * @codec: the HDA codec
3359  * @nid: NID to send the command
3360  * @direct: direct flag
3361  * @verb: the verb to send
3362  * @parm: the parameter for the verb
3363  *
3364  * This function works like snd_hda_codec_write_cache(), but it doesn't send
3365  * command if the parameter is already identical with the cached value.
3366  * If not, it sends the command and refreshes the cache.
3367  *
3368  * Returns 0 if successful, or a negative error code.
3369  */
3370 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3371                                int direct, unsigned int verb, unsigned int parm)
3372 {
3373         struct hda_cache_head *c;
3374         u32 key;
3375
3376         /* parm may contain the verb stuff for get/set amp */
3377         verb = verb | (parm >> 8);
3378         parm &= 0xff;
3379         key = build_cmd_cache_key(nid, verb);
3380         mutex_lock(&codec->bus->cmd_mutex);
3381         c = get_hash(&codec->cmd_cache, key);
3382         if (c && c->val == parm) {
3383                 mutex_unlock(&codec->bus->cmd_mutex);
3384                 return 0;
3385         }
3386         mutex_unlock(&codec->bus->cmd_mutex);
3387         return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3388 }
3389 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3390
3391 /**
3392  * snd_hda_codec_resume_cache - Resume the all commands from the cache
3393  * @codec: HD-audio codec
3394  *
3395  * Execute all verbs recorded in the command caches to resume.
3396  */
3397 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3398 {
3399         struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
3400         int i;
3401
3402         for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
3403                 u32 key = buffer->key;
3404                 if (!key)
3405                         continue;
3406                 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3407                                     get_cmd_cache_cmd(key), buffer->val);
3408         }
3409 }
3410 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3411
3412 /**
3413  * snd_hda_sequence_write_cache - sequence writes with caching
3414  * @codec: the HDA codec
3415  * @seq: VERB array to send
3416  *
3417  * Send the commands sequentially from the given array.
3418  * Thte commands are recorded on cache for power-save and resume.
3419  * The array must be terminated with NID=0.
3420  */
3421 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3422                                   const struct hda_verb *seq)
3423 {
3424         for (; seq->nid; seq++)
3425                 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3426                                           seq->param);
3427 }
3428 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3429 #endif /* CONFIG_PM */
3430
3431 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3432                                     unsigned int power_state,
3433                                     bool eapd_workaround)
3434 {
3435         hda_nid_t nid = codec->start_nid;
3436         int i;
3437
3438         for (i = 0; i < codec->num_nodes; i++, nid++) {
3439                 unsigned int wcaps = get_wcaps(codec, nid);
3440                 if (!(wcaps & AC_WCAP_POWER))
3441                         continue;
3442                 /* don't power down the widget if it controls eapd and
3443                  * EAPD_BTLENABLE is set.
3444                  */
3445                 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3446                     get_wcaps_type(wcaps) == AC_WID_PIN &&
3447                     (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3448                         int eapd = snd_hda_codec_read(codec, nid, 0,
3449                                                 AC_VERB_GET_EAPD_BTLENABLE, 0);
3450                         if (eapd & 0x02)
3451                                 continue;
3452                 }
3453                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3454                                     power_state);
3455         }
3456
3457         if (power_state == AC_PWRST_D0) {
3458                 unsigned long end_time;
3459                 int state;
3460                 /* wait until the codec reachs to D0 */
3461                 end_time = jiffies + msecs_to_jiffies(500);
3462                 do {
3463                         state = snd_hda_codec_read(codec, fg, 0,
3464                                                    AC_VERB_GET_POWER_STATE, 0);
3465                         if (state == power_state)
3466                                 break;
3467                         mdelay(1);
3468                 } while (time_after_eq(end_time, jiffies));
3469         }
3470 }
3471 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3472
3473 /*
3474  * set power state of the codec
3475  */
3476 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3477                                 unsigned int power_state)
3478 {
3479         if (codec->patch_ops.set_power_state) {
3480                 codec->patch_ops.set_power_state(codec, fg, power_state);
3481                 return;
3482         }
3483
3484         /* this delay seems necessary to avoid click noise at power-down */
3485         if (power_state == AC_PWRST_D3)
3486                 msleep(100);
3487         snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3488                             power_state);
3489         snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3490 }
3491
3492 #ifdef CONFIG_SND_HDA_HWDEP
3493 /* execute additional init verbs */
3494 static void hda_exec_init_verbs(struct hda_codec *codec)
3495 {
3496         if (codec->init_verbs.list)
3497                 snd_hda_sequence_write(codec, codec->init_verbs.list);
3498 }
3499 #else
3500 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3501 #endif
3502
3503 #ifdef CONFIG_PM
3504 /*
3505  * call suspend and power-down; used both from PM and power-save
3506  */
3507 static void hda_call_codec_suspend(struct hda_codec *codec)
3508 {
3509         if (codec->patch_ops.suspend)
3510                 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
3511         hda_cleanup_all_streams(codec);
3512         hda_set_power_state(codec,
3513                             codec->afg ? codec->afg : codec->mfg,
3514                             AC_PWRST_D3);
3515 #ifdef CONFIG_SND_HDA_POWER_SAVE
3516         snd_hda_update_power_acct(codec);
3517         cancel_delayed_work(&codec->power_work);
3518         codec->power_on = 0;
3519         codec->power_transition = 0;
3520         codec->power_jiffies = jiffies;
3521 #endif
3522 }
3523
3524 /*
3525  * kick up codec; used both from PM and power-save
3526  */
3527 static void hda_call_codec_resume(struct hda_codec *codec)
3528 {
3529         hda_set_power_state(codec,
3530                             codec->afg ? codec->afg : codec->mfg,
3531                             AC_PWRST_D0);
3532         restore_pincfgs(codec); /* restore all current pin configs */
3533         restore_shutup_pins(codec);
3534         hda_exec_init_verbs(codec);
3535         snd_hda_jack_set_dirty_all(codec);
3536         if (codec->patch_ops.resume)
3537                 codec->patch_ops.resume(codec);
3538         else {
3539                 if (codec->patch_ops.init)
3540                         codec->patch_ops.init(codec);
3541                 snd_hda_codec_resume_amp(codec);
3542                 snd_hda_codec_resume_cache(codec);
3543         }
3544 }
3545 #endif /* CONFIG_PM */
3546
3547
3548 /**
3549  * snd_hda_build_controls - build mixer controls
3550  * @bus: the BUS
3551  *
3552  * Creates mixer controls for each codec included in the bus.
3553  *
3554  * Returns 0 if successful, otherwise a negative error code.
3555  */
3556 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
3557 {
3558         struct hda_codec *codec;
3559
3560         list_for_each_entry(codec, &bus->codec_list, list) {
3561                 int err = snd_hda_codec_build_controls(codec);
3562                 if (err < 0) {
3563                         printk(KERN_ERR "hda_codec: cannot build controls "
3564                                "for #%d (error %d)\n", codec->addr, err);
3565                         err = snd_hda_codec_reset(codec);
3566                         if (err < 0) {
3567                                 printk(KERN_ERR
3568                                        "hda_codec: cannot revert codec\n");
3569                                 return err;
3570                         }
3571                 }
3572         }
3573         return 0;
3574 }
3575 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3576
3577 int snd_hda_codec_build_controls(struct hda_codec *codec)
3578 {
3579         int err = 0;
3580         hda_exec_init_verbs(codec);
3581         /* continue to initialize... */
3582         if (codec->patch_ops.init)
3583                 err = codec->patch_ops.init(codec);
3584         if (!err && codec->patch_ops.build_controls)
3585                 err = codec->patch_ops.build_controls(codec);
3586         if (err < 0)
3587                 return err;
3588         return 0;
3589 }
3590
3591 /*
3592  * stream formats
3593  */
3594 struct hda_rate_tbl {
3595         unsigned int hz;
3596         unsigned int alsa_bits;
3597         unsigned int hda_fmt;
3598 };
3599
3600 /* rate = base * mult / div */
3601 #define HDA_RATE(base, mult, div) \
3602         (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3603          (((div) - 1) << AC_FMT_DIV_SHIFT))
3604
3605 static struct hda_rate_tbl rate_bits[] = {
3606         /* rate in Hz, ALSA rate bitmask, HDA format value */
3607
3608         /* autodetected value used in snd_hda_query_supported_pcm */
3609         { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3610         { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3611         { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3612         { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3613         { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3614         { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3615         { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3616         { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3617         { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3618         { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3619         { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3620 #define AC_PAR_PCM_RATE_BITS    11
3621         /* up to bits 10, 384kHZ isn't supported properly */
3622
3623         /* not autodetected value */
3624         { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3625
3626         { 0 } /* terminator */
3627 };
3628
3629 /**
3630  * snd_hda_calc_stream_format - calculate format bitset
3631  * @rate: the sample rate
3632  * @channels: the number of channels
3633  * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3634  * @maxbps: the max. bps
3635  *
3636  * Calculate the format bitset from the given rate, channels and th PCM format.
3637  *
3638  * Return zero if invalid.
3639  */
3640 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3641                                         unsigned int channels,
3642                                         unsigned int format,
3643                                         unsigned int maxbps,
3644                                         unsigned short spdif_ctls)
3645 {
3646         int i;
3647         unsigned int val = 0;
3648
3649         for (i = 0; rate_bits[i].hz; i++)
3650                 if (rate_bits[i].hz == rate) {
3651                         val = rate_bits[i].hda_fmt;
3652                         break;
3653                 }
3654         if (!rate_bits[i].hz) {
3655                 snd_printdd("invalid rate %d\n", rate);
3656                 return 0;
3657         }
3658
3659         if (channels == 0 || channels > 8) {
3660                 snd_printdd("invalid channels %d\n", channels);
3661                 return 0;
3662         }
3663         val |= channels - 1;
3664
3665         switch (snd_pcm_format_width(format)) {
3666         case 8:
3667                 val |= AC_FMT_BITS_8;
3668                 break;
3669         case 16:
3670                 val |= AC_FMT_BITS_16;
3671                 break;
3672         case 20:
3673         case 24:
3674         case 32:
3675                 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3676                         val |= AC_FMT_BITS_32;
3677                 else if (maxbps >= 24)
3678                         val |= AC_FMT_BITS_24;
3679                 else
3680                         val |= AC_FMT_BITS_20;
3681                 break;
3682         default:
3683                 snd_printdd("invalid format width %d\n",
3684                             snd_pcm_format_width(format));
3685                 return 0;
3686         }
3687
3688         if (spdif_ctls & AC_DIG1_NONAUDIO)
3689                 val |= AC_FMT_TYPE_NON_PCM;
3690
3691         return val;
3692 }
3693 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3694
3695 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3696 {
3697         unsigned int val = 0;
3698         if (nid != codec->afg &&
3699             (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3700                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3701         if (!val || val == -1)
3702                 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3703         if (!val || val == -1)
3704                 return 0;
3705         return val;
3706 }
3707
3708 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3709 {
3710         return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3711                                get_pcm_param);
3712 }
3713
3714 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3715 {
3716         unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3717         if (!streams || streams == -1)
3718                 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3719         if (!streams || streams == -1)
3720                 return 0;
3721         return streams;
3722 }
3723
3724 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3725 {
3726         return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3727                                get_stream_param);
3728 }
3729
3730 /**
3731  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3732  * @codec: the HDA codec
3733  * @nid: NID to query
3734  * @ratesp: the pointer to store the detected rate bitflags
3735  * @formatsp: the pointer to store the detected formats
3736  * @bpsp: the pointer to store the detected format widths
3737  *
3738  * Queries the supported PCM rates and formats.  The NULL @ratesp, @formatsp
3739  * or @bsps argument is ignored.
3740  *
3741  * Returns 0 if successful, otherwise a negative error code.
3742  */
3743 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3744                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3745 {
3746         unsigned int i, val, wcaps;
3747
3748         wcaps = get_wcaps(codec, nid);
3749         val = query_pcm_param(codec, nid);
3750
3751         if (ratesp) {
3752                 u32 rates = 0;
3753                 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3754                         if (val & (1 << i))
3755                                 rates |= rate_bits[i].alsa_bits;
3756                 }
3757                 if (rates == 0) {
3758                         snd_printk(KERN_ERR "hda_codec: rates == 0 "
3759                                    "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3760                                         nid, val,
3761                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3762                         return -EIO;
3763                 }
3764                 *ratesp = rates;
3765         }
3766
3767         if (formatsp || bpsp) {
3768                 u64 formats = 0;
3769                 unsigned int streams, bps;
3770
3771                 streams = query_stream_param(codec, nid);
3772                 if (!streams)
3773                         return -EIO;
3774
3775                 bps = 0;
3776                 if (streams & AC_SUPFMT_PCM) {
3777                         if (val & AC_SUPPCM_BITS_8) {
3778                                 formats |= SNDRV_PCM_FMTBIT_U8;
3779                                 bps = 8;
3780                         }
3781                         if (val & AC_SUPPCM_BITS_16) {
3782                                 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3783                                 bps = 16;
3784                         }
3785                         if (wcaps & AC_WCAP_DIGITAL) {
3786                                 if (val & AC_SUPPCM_BITS_32)
3787                                         formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3788                                 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3789                                         formats |= SNDRV_PCM_FMTBIT_S32_LE;
3790                                 if (val & AC_SUPPCM_BITS_24)
3791                                         bps = 24;
3792                                 else if (val & AC_SUPPCM_BITS_20)
3793                                         bps = 20;
3794                         } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3795                                           AC_SUPPCM_BITS_32)) {
3796                                 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3797                                 if (val & AC_SUPPCM_BITS_32)
3798                                         bps = 32;
3799                                 else if (val & AC_SUPPCM_BITS_24)
3800                                         bps = 24;
3801                                 else if (val & AC_SUPPCM_BITS_20)
3802                                         bps = 20;
3803                         }
3804                 }
3805                 if (streams & AC_SUPFMT_FLOAT32) {
3806                         formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3807                         if (!bps)
3808                                 bps = 32;
3809                 }
3810                 if (streams == AC_SUPFMT_AC3) {
3811                         /* should be exclusive */
3812                         /* temporary hack: we have still no proper support
3813                          * for the direct AC3 stream...
3814                          */
3815                         formats |= SNDRV_PCM_FMTBIT_U8;
3816                         bps = 8;
3817                 }
3818                 if (formats == 0) {
3819                         snd_printk(KERN_ERR "hda_codec: formats == 0 "
3820                                    "(nid=0x%x, val=0x%x, ovrd=%i, "
3821                                    "streams=0x%x)\n",
3822                                         nid, val,
3823                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3824                                         streams);
3825                         return -EIO;
3826                 }
3827                 if (formatsp)
3828                         *formatsp = formats;
3829                 if (bpsp)
3830                         *bpsp = bps;
3831         }
3832
3833         return 0;
3834 }
3835 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
3836
3837 /**
3838  * snd_hda_is_supported_format - Check the validity of the format
3839  * @codec: HD-audio codec
3840  * @nid: NID to check
3841  * @format: the HD-audio format value to check
3842  *
3843  * Check whether the given node supports the format value.
3844  *
3845  * Returns 1 if supported, 0 if not.
3846  */
3847 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3848                                 unsigned int format)
3849 {
3850         int i;
3851         unsigned int val = 0, rate, stream;
3852
3853         val = query_pcm_param(codec, nid);
3854         if (!val)
3855                 return 0;
3856
3857         rate = format & 0xff00;
3858         for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3859                 if (rate_bits[i].hda_fmt == rate) {
3860                         if (val & (1 << i))
3861                                 break;
3862                         return 0;
3863                 }
3864         if (i >= AC_PAR_PCM_RATE_BITS)
3865                 return 0;
3866
3867         stream = query_stream_param(codec, nid);
3868         if (!stream)
3869                 return 0;
3870
3871         if (stream & AC_SUPFMT_PCM) {
3872                 switch (format & 0xf0) {
3873                 case 0x00:
3874                         if (!(val & AC_SUPPCM_BITS_8))
3875                                 return 0;
3876                         break;
3877                 case 0x10:
3878                         if (!(val & AC_SUPPCM_BITS_16))
3879                                 return 0;
3880                         break;
3881                 case 0x20:
3882                         if (!(val & AC_SUPPCM_BITS_20))
3883                                 return 0;
3884                         break;
3885                 case 0x30:
3886                         if (!(val & AC_SUPPCM_BITS_24))
3887                                 return 0;
3888                         break;
3889                 case 0x40:
3890                         if (!(val & AC_SUPPCM_BITS_32))
3891                                 return 0;
3892                         break;
3893                 default:
3894                         return 0;
3895                 }
3896         } else {
3897                 /* FIXME: check for float32 and AC3? */
3898         }
3899
3900         return 1;
3901 }
3902 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3903
3904 /*
3905  * PCM stuff
3906  */
3907 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3908                                       struct hda_codec *codec,
3909                                       struct snd_pcm_substream *substream)
3910 {
3911         return 0;
3912 }
3913
3914 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3915                                    struct hda_codec *codec,
3916                                    unsigned int stream_tag,
3917                                    unsigned int format,
3918                                    struct snd_pcm_substream *substream)
3919 {
3920         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3921         return 0;
3922 }
3923
3924 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3925                                    struct hda_codec *codec,
3926                                    struct snd_pcm_substream *substream)
3927 {
3928         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3929         return 0;
3930 }
3931
3932 static int set_pcm_default_values(struct hda_codec *codec,
3933                                   struct hda_pcm_stream *info)
3934 {
3935         int err;
3936
3937         /* query support PCM information from the given NID */
3938         if (info->nid && (!info->rates || !info->formats)) {
3939                 err = snd_hda_query_supported_pcm(codec, info->nid,
3940                                 info->rates ? NULL : &info->rates,
3941                                 info->formats ? NULL : &info->formats,
3942                                 info->maxbps ? NULL : &info->maxbps);
3943                 if (err < 0)
3944                         return err;
3945         }
3946         if (info->ops.open == NULL)
3947                 info->ops.open = hda_pcm_default_open_close;
3948         if (info->ops.close == NULL)
3949                 info->ops.close = hda_pcm_default_open_close;
3950         if (info->ops.prepare == NULL) {
3951                 if (snd_BUG_ON(!info->nid))
3952                         return -EINVAL;
3953                 info->ops.prepare = hda_pcm_default_prepare;
3954         }
3955         if (info->ops.cleanup == NULL) {
3956                 if (snd_BUG_ON(!info->nid))
3957                         return -EINVAL;
3958                 info->ops.cleanup = hda_pcm_default_cleanup;
3959         }
3960         return 0;
3961 }
3962
3963 /*
3964  * codec prepare/cleanup entries
3965  */
3966 int snd_hda_codec_prepare(struct hda_codec *codec,
3967                           struct hda_pcm_stream *hinfo,
3968                           unsigned int stream,
3969                           unsigned int format,
3970                           struct snd_pcm_substream *substream)
3971 {
3972         int ret;
3973         mutex_lock(&codec->bus->prepare_mutex);
3974         ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
3975         if (ret >= 0)
3976                 purify_inactive_streams(codec);
3977         mutex_unlock(&codec->bus->prepare_mutex);
3978         return ret;
3979 }
3980 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
3981
3982 void snd_hda_codec_cleanup(struct hda_codec *codec,
3983                            struct hda_pcm_stream *hinfo,
3984                            struct snd_pcm_substream *substream)
3985 {
3986         mutex_lock(&codec->bus->prepare_mutex);
3987         hinfo->ops.cleanup(hinfo, codec, substream);
3988         mutex_unlock(&codec->bus->prepare_mutex);
3989 }
3990 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
3991
3992 /* global */
3993 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3994         "Audio", "SPDIF", "HDMI", "Modem"
3995 };
3996
3997 /*
3998  * get the empty PCM device number to assign
3999  *
4000  * note the max device number is limited by HDA_MAX_PCMS, currently 10
4001  */
4002 static int get_empty_pcm_device(struct hda_bus *bus, int type)
4003 {
4004         /* audio device indices; not linear to keep compatibility */
4005         static int audio_idx[HDA_PCM_NTYPES][5] = {
4006                 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4007                 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
4008                 [HDA_PCM_TYPE_HDMI]  = { 3, 7, 8, 9, -1 },
4009                 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
4010         };
4011         int i;
4012
4013         if (type >= HDA_PCM_NTYPES) {
4014                 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4015                 return -EINVAL;
4016         }
4017
4018         for (i = 0; audio_idx[type][i] >= 0 ; i++)
4019                 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4020                         return audio_idx[type][i];
4021
4022         /* non-fixed slots starting from 10 */
4023         for (i = 10; i < 32; i++) {
4024                 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4025                         return i;
4026         }
4027
4028         snd_printk(KERN_WARNING "Too many %s devices\n",
4029                 snd_hda_pcm_type_name[type]);
4030         return -EAGAIN;
4031 }
4032
4033 /*
4034  * attach a new PCM stream
4035  */
4036 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4037 {
4038         struct hda_bus *bus = codec->bus;
4039         struct hda_pcm_stream *info;
4040         int stream, err;
4041
4042         if (snd_BUG_ON(!pcm->name))
4043                 return -EINVAL;
4044         for (stream = 0; stream < 2; stream++) {
4045                 info = &pcm->stream[stream];
4046                 if (info->substreams) {
4047                         err = set_pcm_default_values(codec, info);
4048                         if (err < 0)
4049                                 return err;
4050                 }
4051         }
4052         return bus->ops.attach_pcm(bus, codec, pcm);
4053 }
4054
4055 /* assign all PCMs of the given codec */
4056 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4057 {
4058         unsigned int pcm;
4059         int err;
4060
4061         if (!codec->num_pcms) {
4062                 if (!codec->patch_ops.build_pcms)
4063                         return 0;
4064                 err = codec->patch_ops.build_pcms(codec);
4065                 if (err < 0) {
4066                         printk(KERN_ERR "hda_codec: cannot build PCMs"
4067                                "for #%d (error %d)\n", codec->addr, err);
4068                         err = snd_hda_codec_reset(codec);
4069                         if (err < 0) {
4070                                 printk(KERN_ERR
4071                                        "hda_codec: cannot revert codec\n");
4072                                 return err;
4073                         }
4074                 }
4075         }
4076         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4077                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4078                 int dev;
4079
4080                 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4081                         continue; /* no substreams assigned */
4082
4083                 if (!cpcm->pcm) {
4084                         dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4085                         if (dev < 0)
4086                                 continue; /* no fatal error */
4087                         cpcm->device = dev;
4088                         err = snd_hda_attach_pcm(codec, cpcm);
4089                         if (err < 0) {
4090                                 printk(KERN_ERR "hda_codec: cannot attach "
4091                                        "PCM stream %d for codec #%d\n",
4092                                        dev, codec->addr);
4093                                 continue; /* no fatal error */
4094                         }
4095                 }
4096         }
4097         return 0;
4098 }
4099
4100 /**
4101  * snd_hda_build_pcms - build PCM information
4102  * @bus: the BUS
4103  *
4104  * Create PCM information for each codec included in the bus.
4105  *
4106  * The build_pcms codec patch is requested to set up codec->num_pcms and
4107  * codec->pcm_info properly.  The array is referred by the top-level driver
4108  * to create its PCM instances.
4109  * The allocated codec->pcm_info should be released in codec->patch_ops.free
4110  * callback.
4111  *
4112  * At least, substreams, channels_min and channels_max must be filled for
4113  * each stream.  substreams = 0 indicates that the stream doesn't exist.
4114  * When rates and/or formats are zero, the supported values are queried
4115  * from the given nid.  The nid is used also by the default ops.prepare
4116  * and ops.cleanup callbacks.
4117  *
4118  * The driver needs to call ops.open in its open callback.  Similarly,
4119  * ops.close is supposed to be called in the close callback.
4120  * ops.prepare should be called in the prepare or hw_params callback
4121  * with the proper parameters for set up.
4122  * ops.cleanup should be called in hw_free for clean up of streams.
4123  *
4124  * This function returns 0 if successful, or a negative error code.
4125  */
4126 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
4127 {
4128         struct hda_codec *codec;
4129
4130         list_for_each_entry(codec, &bus->codec_list, list) {
4131                 int err = snd_hda_codec_build_pcms(codec);
4132                 if (err < 0)
4133                         return err;
4134         }
4135         return 0;
4136 }
4137 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
4138
4139 /**
4140  * snd_hda_check_board_config - compare the current codec with the config table
4141  * @codec: the HDA codec
4142  * @num_configs: number of config enums
4143  * @models: array of model name strings
4144  * @tbl: configuration table, terminated by null entries
4145  *
4146  * Compares the modelname or PCI subsystem id of the current codec with the
4147  * given configuration table.  If a matching entry is found, returns its
4148  * config value (supposed to be 0 or positive).
4149  *
4150  * If no entries are matching, the function returns a negative value.
4151  */
4152 int snd_hda_check_board_config(struct hda_codec *codec,
4153                                int num_configs, const char * const *models,
4154                                const struct snd_pci_quirk *tbl)
4155 {
4156         if (codec->modelname && models) {
4157                 int i;
4158                 for (i = 0; i < num_configs; i++) {
4159                         if (models[i] &&
4160                             !strcmp(codec->modelname, models[i])) {
4161                                 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4162                                            "selected\n", models[i]);
4163                                 return i;
4164                         }
4165                 }
4166         }
4167
4168         if (!codec->bus->pci || !tbl)
4169                 return -1;
4170
4171         tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4172         if (!tbl)
4173                 return -1;
4174         if (tbl->value >= 0 && tbl->value < num_configs) {
4175 #ifdef CONFIG_SND_DEBUG_VERBOSE
4176                 char tmp[10];
4177                 const char *model = NULL;
4178                 if (models)
4179                         model = models[tbl->value];
4180                 if (!model) {
4181                         sprintf(tmp, "#%d", tbl->value);
4182                         model = tmp;
4183                 }
4184                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4185                             "for config %x:%x (%s)\n",
4186                             model, tbl->subvendor, tbl->subdevice,
4187                             (tbl->name ? tbl->name : "Unknown device"));
4188 #endif
4189                 return tbl->value;
4190         }
4191         return -1;
4192 }
4193 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
4194
4195 /**
4196  * snd_hda_check_board_codec_sid_config - compare the current codec
4197                                         subsystem ID with the
4198                                         config table
4199
4200            This is important for Gateway notebooks with SB450 HDA Audio
4201            where the vendor ID of the PCI device is:
4202                 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4203            and the vendor/subvendor are found only at the codec.
4204
4205  * @codec: the HDA codec
4206  * @num_configs: number of config enums
4207  * @models: array of model name strings
4208  * @tbl: configuration table, terminated by null entries
4209  *
4210  * Compares the modelname or PCI subsystem id of the current codec with the
4211  * given configuration table.  If a matching entry is found, returns its
4212  * config value (supposed to be 0 or positive).
4213  *
4214  * If no entries are matching, the function returns a negative value.
4215  */
4216 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4217                                int num_configs, const char * const *models,
4218                                const struct snd_pci_quirk *tbl)
4219 {
4220         const struct snd_pci_quirk *q;
4221
4222         /* Search for codec ID */
4223         for (q = tbl; q->subvendor; q++) {
4224                 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4225                 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4226                 if ((codec->subsystem_id & mask) == id)
4227                         break;
4228         }
4229
4230         if (!q->subvendor)
4231                 return -1;
4232
4233         tbl = q;
4234
4235         if (tbl->value >= 0 && tbl->value < num_configs) {
4236 #ifdef CONFIG_SND_DEBUG_VERBOSE
4237                 char tmp[10];
4238                 const char *model = NULL;
4239                 if (models)
4240                         model = models[tbl->value];
4241                 if (!model) {
4242                         sprintf(tmp, "#%d", tbl->value);
4243                         model = tmp;
4244                 }
4245                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4246                             "for config %x:%x (%s)\n",
4247                             model, tbl->subvendor, tbl->subdevice,
4248                             (tbl->name ? tbl->name : "Unknown device"));
4249 #endif
4250                 return tbl->value;
4251         }
4252         return -1;
4253 }
4254 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4255
4256 /**
4257  * snd_hda_add_new_ctls - create controls from the array
4258  * @codec: the HDA codec
4259  * @knew: the array of struct snd_kcontrol_new
4260  *
4261  * This helper function creates and add new controls in the given array.
4262  * The array must be terminated with an empty entry as terminator.
4263  *
4264  * Returns 0 if successful, or a negative error code.
4265  */
4266 int snd_hda_add_new_ctls(struct hda_codec *codec,
4267                          const struct snd_kcontrol_new *knew)
4268 {
4269         int err;
4270
4271         for (; knew->name; knew++) {
4272                 struct snd_kcontrol *kctl;
4273                 int addr = 0, idx = 0;
4274                 if (knew->iface == -1)  /* skip this codec private value */
4275                         continue;
4276                 for (;;) {
4277                         kctl = snd_ctl_new1(knew, codec);
4278                         if (!kctl)
4279                                 return -ENOMEM;
4280                         if (addr > 0)
4281                                 kctl->id.device = addr;
4282                         if (idx > 0)
4283                                 kctl->id.index = idx;
4284                         err = snd_hda_ctl_add(codec, 0, kctl);
4285                         if (!err)
4286                                 break;
4287                         /* try first with another device index corresponding to
4288                          * the codec addr; if it still fails (or it's the
4289                          * primary codec), then try another control index
4290                          */
4291                         if (!addr && codec->addr)
4292                                 addr = codec->addr;
4293                         else if (!idx && !knew->index) {
4294                                 idx = find_empty_mixer_ctl_idx(codec,
4295                                                                knew->name);
4296                                 if (idx <= 0)
4297                                         return err;
4298                         } else
4299                                 return err;
4300                 }
4301         }
4302         return 0;
4303 }
4304 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4305
4306 #ifdef CONFIG_SND_HDA_POWER_SAVE
4307 static void hda_power_work(struct work_struct *work)
4308 {
4309         struct hda_codec *codec =
4310                 container_of(work, struct hda_codec, power_work.work);
4311         struct hda_bus *bus = codec->bus;
4312
4313         if (!codec->power_on || codec->power_count) {
4314                 codec->power_transition = 0;
4315                 return;
4316         }
4317
4318         trace_hda_power_down(codec);
4319         hda_call_codec_suspend(codec);
4320         if (bus->ops.pm_notify)
4321                 bus->ops.pm_notify(bus);
4322 }
4323
4324 static void hda_keep_power_on(struct hda_codec *codec)
4325 {
4326         codec->power_count++;
4327         codec->power_on = 1;
4328         codec->power_jiffies = jiffies;
4329 }
4330
4331 /* update the power on/off account with the current jiffies */
4332 void snd_hda_update_power_acct(struct hda_codec *codec)
4333 {
4334         unsigned long delta = jiffies - codec->power_jiffies;
4335         if (codec->power_on)
4336                 codec->power_on_acct += delta;
4337         else
4338                 codec->power_off_acct += delta;
4339         codec->power_jiffies += delta;
4340 }
4341
4342 /**
4343  * snd_hda_power_up - Power-up the codec
4344  * @codec: HD-audio codec
4345  *
4346  * Increment the power-up counter and power up the hardware really when
4347  * not turned on yet.
4348  */
4349 void snd_hda_power_up(struct hda_codec *codec)
4350 {
4351         struct hda_bus *bus = codec->bus;
4352
4353         codec->power_count++;
4354         if (codec->power_on || codec->power_transition)
4355                 return;
4356
4357         trace_hda_power_up(codec);
4358         snd_hda_update_power_acct(codec);
4359         codec->power_on = 1;
4360         codec->power_jiffies = jiffies;
4361         if (bus->ops.pm_notify)
4362                 bus->ops.pm_notify(bus);
4363         hda_call_codec_resume(codec);
4364         cancel_delayed_work(&codec->power_work);
4365         codec->power_transition = 0;
4366 }
4367 EXPORT_SYMBOL_HDA(snd_hda_power_up);
4368
4369 #define power_save(codec)       \
4370         ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4371
4372 /**
4373  * snd_hda_power_down - Power-down the codec
4374  * @codec: HD-audio codec
4375  *
4376  * Decrement the power-up counter and schedules the power-off work if
4377  * the counter rearches to zero.
4378  */
4379 void snd_hda_power_down(struct hda_codec *codec)
4380 {
4381         --codec->power_count;
4382         if (!codec->power_on || codec->power_count || codec->power_transition)
4383                 return;
4384         if (power_save(codec)) {
4385                 codec->power_transition = 1; /* avoid reentrance */
4386                 queue_delayed_work(codec->bus->workq, &codec->power_work,
4387                                 msecs_to_jiffies(power_save(codec) * 1000));
4388         }
4389 }
4390 EXPORT_SYMBOL_HDA(snd_hda_power_down);
4391
4392 /**
4393  * snd_hda_check_amp_list_power - Check the amp list and update the power
4394  * @codec: HD-audio codec
4395  * @check: the object containing an AMP list and the status
4396  * @nid: NID to check / update
4397  *
4398  * Check whether the given NID is in the amp list.  If it's in the list,
4399  * check the current AMP status, and update the the power-status according
4400  * to the mute status.
4401  *
4402  * This function is supposed to be set or called from the check_power_status
4403  * patch ops.
4404  */
4405 int snd_hda_check_amp_list_power(struct hda_codec *codec,
4406                                  struct hda_loopback_check *check,
4407                                  hda_nid_t nid)
4408 {
4409         const struct hda_amp_list *p;
4410         int ch, v;
4411
4412         if (!check->amplist)
4413                 return 0;
4414         for (p = check->amplist; p->nid; p++) {
4415                 if (p->nid == nid)
4416                         break;
4417         }
4418         if (!p->nid)
4419                 return 0; /* nothing changed */
4420
4421         for (p = check->amplist; p->nid; p++) {
4422                 for (ch = 0; ch < 2; ch++) {
4423                         v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4424                                                    p->idx);
4425                         if (!(v & HDA_AMP_MUTE) && v > 0) {
4426                                 if (!check->power_on) {
4427                                         check->power_on = 1;
4428                                         snd_hda_power_up(codec);
4429                                 }
4430                                 return 1;
4431                         }
4432                 }
4433         }
4434         if (check->power_on) {
4435                 check->power_on = 0;
4436                 snd_hda_power_down(codec);
4437         }
4438         return 0;
4439 }
4440 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
4441 #endif
4442
4443 /*
4444  * Channel mode helper
4445  */
4446
4447 /**
4448  * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4449  */
4450 int snd_hda_ch_mode_info(struct hda_codec *codec,
4451                          struct snd_ctl_elem_info *uinfo,
4452                          const struct hda_channel_mode *chmode,
4453                          int num_chmodes)
4454 {
4455         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4456         uinfo->count = 1;
4457         uinfo->value.enumerated.items = num_chmodes;
4458         if (uinfo->value.enumerated.item >= num_chmodes)
4459                 uinfo->value.enumerated.item = num_chmodes - 1;
4460         sprintf(uinfo->value.enumerated.name, "%dch",
4461                 chmode[uinfo->value.enumerated.item].channels);
4462         return 0;
4463 }
4464 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4465
4466 /**
4467  * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4468  */
4469 int snd_hda_ch_mode_get(struct hda_codec *codec,
4470                         struct snd_ctl_elem_value *ucontrol,
4471                         const struct hda_channel_mode *chmode,
4472                         int num_chmodes,
4473                         int max_channels)
4474 {
4475         int i;
4476
4477         for (i = 0; i < num_chmodes; i++) {
4478                 if (max_channels == chmode[i].channels) {
4479                         ucontrol->value.enumerated.item[0] = i;
4480                         break;
4481                 }
4482         }
4483         return 0;
4484 }
4485 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4486
4487 /**
4488  * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4489  */
4490 int snd_hda_ch_mode_put(struct hda_codec *codec,
4491                         struct snd_ctl_elem_value *ucontrol,
4492                         const struct hda_channel_mode *chmode,
4493                         int num_chmodes,
4494                         int *max_channelsp)
4495 {
4496         unsigned int mode;
4497
4498         mode = ucontrol->value.enumerated.item[0];
4499         if (mode >= num_chmodes)
4500                 return -EINVAL;
4501         if (*max_channelsp == chmode[mode].channels)
4502                 return 0;
4503         /* change the current channel setting */
4504         *max_channelsp = chmode[mode].channels;
4505         if (chmode[mode].sequence)
4506                 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4507         return 1;
4508 }
4509 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4510
4511 /*
4512  * input MUX helper
4513  */
4514
4515 /**
4516  * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4517  */
4518 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4519                            struct snd_ctl_elem_info *uinfo)
4520 {
4521         unsigned int index;
4522
4523         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4524         uinfo->count = 1;
4525         uinfo->value.enumerated.items = imux->num_items;
4526         if (!imux->num_items)
4527                 return 0;
4528         index = uinfo->value.enumerated.item;
4529         if (index >= imux->num_items)
4530                 index = imux->num_items - 1;
4531         strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4532         return 0;
4533 }
4534 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4535
4536 /**
4537  * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4538  */
4539 int snd_hda_input_mux_put(struct hda_codec *codec,
4540                           const struct hda_input_mux *imux,
4541                           struct snd_ctl_elem_value *ucontrol,
4542                           hda_nid_t nid,
4543                           unsigned int *cur_val)
4544 {
4545         unsigned int idx;
4546
4547         if (!imux->num_items)
4548                 return 0;
4549         idx = ucontrol->value.enumerated.item[0];
4550         if (idx >= imux->num_items)
4551                 idx = imux->num_items - 1;
4552         if (*cur_val == idx)
4553                 return 0;
4554         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4555                                   imux->items[idx].index);
4556         *cur_val = idx;
4557         return 1;
4558 }
4559 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4560
4561
4562 /*
4563  * Multi-channel / digital-out PCM helper functions
4564  */
4565
4566 /* setup SPDIF output stream */
4567 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4568                                  unsigned int stream_tag, unsigned int format)
4569 {
4570         struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4571
4572         /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4573         if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4574                 set_dig_out_convert(codec, nid,
4575                                     spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
4576                                     -1);
4577         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4578         if (codec->slave_dig_outs) {
4579                 const hda_nid_t *d;
4580                 for (d = codec->slave_dig_outs; *d; d++)
4581                         snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4582                                                    format);
4583         }
4584         /* turn on again (if needed) */
4585         if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4586                 set_dig_out_convert(codec, nid,
4587                                     spdif->ctls & 0xff, -1);
4588 }
4589
4590 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4591 {
4592         snd_hda_codec_cleanup_stream(codec, nid);
4593         if (codec->slave_dig_outs) {
4594                 const hda_nid_t *d;
4595                 for (d = codec->slave_dig_outs; *d; d++)
4596                         snd_hda_codec_cleanup_stream(codec, *d);
4597         }
4598 }
4599
4600 /**
4601  * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4602  * @bus: HD-audio bus
4603  */
4604 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4605 {
4606         struct hda_codec *codec;
4607
4608         if (!bus)
4609                 return;
4610         list_for_each_entry(codec, &bus->codec_list, list) {
4611                 if (hda_codec_is_power_on(codec) &&
4612                     codec->patch_ops.reboot_notify)
4613                         codec->patch_ops.reboot_notify(codec);
4614         }
4615 }
4616 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
4617
4618 /**
4619  * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4620  */
4621 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4622                                struct hda_multi_out *mout)
4623 {
4624         mutex_lock(&codec->spdif_mutex);
4625         if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4626                 /* already opened as analog dup; reset it once */
4627                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4628         mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4629         mutex_unlock(&codec->spdif_mutex);
4630         return 0;
4631 }
4632 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
4633
4634 /**
4635  * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4636  */
4637 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4638                                   struct hda_multi_out *mout,
4639                                   unsigned int stream_tag,
4640                                   unsigned int format,
4641                                   struct snd_pcm_substream *substream)
4642 {
4643         mutex_lock(&codec->spdif_mutex);
4644         setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4645         mutex_unlock(&codec->spdif_mutex);
4646         return 0;
4647 }
4648 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
4649
4650 /**
4651  * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4652  */
4653 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4654                                   struct hda_multi_out *mout)
4655 {
4656         mutex_lock(&codec->spdif_mutex);
4657         cleanup_dig_out_stream(codec, mout->dig_out_nid);
4658         mutex_unlock(&codec->spdif_mutex);
4659         return 0;
4660 }
4661 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4662
4663 /**
4664  * snd_hda_multi_out_dig_close - release the digital out stream
4665  */
4666 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4667                                 struct hda_multi_out *mout)
4668 {
4669         mutex_lock(&codec->spdif_mutex);
4670         mout->dig_out_used = 0;
4671         mutex_unlock(&codec->spdif_mutex);
4672         return 0;
4673 }
4674 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
4675
4676 /**
4677  * snd_hda_multi_out_analog_open - open analog outputs
4678  *
4679  * Open analog outputs and set up the hw-constraints.
4680  * If the digital outputs can be opened as slave, open the digital
4681  * outputs, too.
4682  */
4683 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4684                                   struct hda_multi_out *mout,
4685                                   struct snd_pcm_substream *substream,
4686                                   struct hda_pcm_stream *hinfo)
4687 {
4688         struct snd_pcm_runtime *runtime = substream->runtime;
4689         runtime->hw.channels_max = mout->max_channels;
4690         if (mout->dig_out_nid) {
4691                 if (!mout->analog_rates) {
4692                         mout->analog_rates = hinfo->rates;
4693                         mout->analog_formats = hinfo->formats;
4694                         mout->analog_maxbps = hinfo->maxbps;
4695                 } else {
4696                         runtime->hw.rates = mout->analog_rates;
4697                         runtime->hw.formats = mout->analog_formats;
4698                         hinfo->maxbps = mout->analog_maxbps;
4699                 }
4700                 if (!mout->spdif_rates) {
4701                         snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4702                                                     &mout->spdif_rates,
4703                                                     &mout->spdif_formats,
4704                                                     &mout->spdif_maxbps);
4705                 }
4706                 mutex_lock(&codec->spdif_mutex);
4707                 if (mout->share_spdif) {
4708                         if ((runtime->hw.rates & mout->spdif_rates) &&
4709                             (runtime->hw.formats & mout->spdif_formats)) {
4710                                 runtime->hw.rates &= mout->spdif_rates;
4711                                 runtime->hw.formats &= mout->spdif_formats;
4712                                 if (mout->spdif_maxbps < hinfo->maxbps)
4713                                         hinfo->maxbps = mout->spdif_maxbps;
4714                         } else {
4715                                 mout->share_spdif = 0;
4716                                 /* FIXME: need notify? */
4717                         }
4718                 }
4719                 mutex_unlock(&codec->spdif_mutex);
4720         }
4721         return snd_pcm_hw_constraint_step(substream->runtime, 0,
4722                                           SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4723 }
4724 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
4725
4726 /**
4727  * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4728  *
4729  * Set up the i/o for analog out.
4730  * When the digital out is available, copy the front out to digital out, too.
4731  */
4732 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4733                                      struct hda_multi_out *mout,
4734                                      unsigned int stream_tag,
4735                                      unsigned int format,
4736                                      struct snd_pcm_substream *substream)
4737 {
4738         const hda_nid_t *nids = mout->dac_nids;
4739         int chs = substream->runtime->channels;
4740         struct hda_spdif_out *spdif =
4741                         snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
4742         int i;
4743
4744         mutex_lock(&codec->spdif_mutex);
4745         if (mout->dig_out_nid && mout->share_spdif &&
4746             mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4747                 if (chs == 2 &&
4748                     snd_hda_is_supported_format(codec, mout->dig_out_nid,
4749                                                 format) &&
4750                     !(spdif->status & IEC958_AES0_NONAUDIO)) {
4751                         mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4752                         setup_dig_out_stream(codec, mout->dig_out_nid,
4753                                              stream_tag, format);
4754                 } else {
4755                         mout->dig_out_used = 0;
4756                         cleanup_dig_out_stream(codec, mout->dig_out_nid);
4757                 }
4758         }
4759         mutex_unlock(&codec->spdif_mutex);
4760
4761         /* front */
4762         snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4763                                    0, format);
4764         if (!mout->no_share_stream &&
4765             mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4766                 /* headphone out will just decode front left/right (stereo) */
4767                 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4768                                            0, format);
4769         /* extra outputs copied from front */
4770         for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4771                 if (!mout->no_share_stream && mout->hp_out_nid[i])
4772                         snd_hda_codec_setup_stream(codec,
4773                                                    mout->hp_out_nid[i],
4774                                                    stream_tag, 0, format);
4775         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4776                 if (!mout->no_share_stream && mout->extra_out_nid[i])
4777                         snd_hda_codec_setup_stream(codec,
4778                                                    mout->extra_out_nid[i],
4779                                                    stream_tag, 0, format);
4780
4781         /* surrounds */
4782         for (i = 1; i < mout->num_dacs; i++) {
4783                 if (chs >= (i + 1) * 2) /* independent out */
4784                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4785                                                    i * 2, format);
4786                 else if (!mout->no_share_stream) /* copy front */
4787                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4788                                                    0, format);
4789         }
4790         return 0;
4791 }
4792 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
4793
4794 /**
4795  * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4796  */
4797 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4798                                      struct hda_multi_out *mout)
4799 {
4800         const hda_nid_t *nids = mout->dac_nids;
4801         int i;
4802
4803         for (i = 0; i < mout->num_dacs; i++)
4804                 snd_hda_codec_cleanup_stream(codec, nids[i]);
4805         if (mout->hp_nid)
4806                 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4807         for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4808                 if (mout->hp_out_nid[i])
4809                         snd_hda_codec_cleanup_stream(codec,
4810                                                      mout->hp_out_nid[i]);
4811         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4812                 if (mout->extra_out_nid[i])
4813                         snd_hda_codec_cleanup_stream(codec,
4814                                                      mout->extra_out_nid[i]);
4815         mutex_lock(&codec->spdif_mutex);
4816         if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4817                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4818                 mout->dig_out_used = 0;
4819         }
4820         mutex_unlock(&codec->spdif_mutex);
4821         return 0;
4822 }
4823 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4824
4825 /*
4826  * Helper for automatic pin configuration
4827  */
4828
4829 static int is_in_nid_list(hda_nid_t nid, const hda_nid_t *list)
4830 {
4831         for (; *list; list++)
4832                 if (*list == nid)
4833                         return 1;
4834         return 0;
4835 }
4836
4837
4838 /*
4839  * Sort an associated group of pins according to their sequence numbers.
4840  */
4841 static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences,
4842                                   int num_pins)
4843 {
4844         int i, j;
4845         short seq;
4846         hda_nid_t nid;
4847
4848         for (i = 0; i < num_pins; i++) {
4849                 for (j = i + 1; j < num_pins; j++) {
4850                         if (sequences[i] > sequences[j]) {
4851                                 seq = sequences[i];
4852                                 sequences[i] = sequences[j];
4853                                 sequences[j] = seq;
4854                                 nid = pins[i];
4855                                 pins[i] = pins[j];
4856                                 pins[j] = nid;
4857                         }
4858                 }
4859         }
4860 }
4861
4862
4863 /* add the found input-pin to the cfg->inputs[] table */
4864 static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid,
4865                                    int type)
4866 {
4867         if (cfg->num_inputs < AUTO_CFG_MAX_INS) {
4868                 cfg->inputs[cfg->num_inputs].pin = nid;
4869                 cfg->inputs[cfg->num_inputs].type = type;
4870                 cfg->num_inputs++;
4871         }
4872 }
4873
4874 /* sort inputs in the order of AUTO_PIN_* type */
4875 static void sort_autocfg_input_pins(struct auto_pin_cfg *cfg)
4876 {
4877         int i, j;
4878
4879         for (i = 0; i < cfg->num_inputs; i++) {
4880                 for (j = i + 1; j < cfg->num_inputs; j++) {
4881                         if (cfg->inputs[i].type > cfg->inputs[j].type) {
4882                                 struct auto_pin_cfg_item tmp;
4883                                 tmp = cfg->inputs[i];
4884                                 cfg->inputs[i] = cfg->inputs[j];
4885                                 cfg->inputs[j] = tmp;
4886                         }
4887                 }
4888         }
4889 }
4890
4891 /* Reorder the surround channels
4892  * ALSA sequence is front/surr/clfe/side
4893  * HDA sequence is:
4894  *    4-ch: front/surr  =>  OK as it is
4895  *    6-ch: front/clfe/surr
4896  *    8-ch: front/clfe/rear/side|fc
4897  */
4898 static void reorder_outputs(unsigned int nums, hda_nid_t *pins)
4899 {
4900         hda_nid_t nid;
4901
4902         switch (nums) {
4903         case 3:
4904         case 4:
4905                 nid = pins[1];
4906                 pins[1] = pins[2];
4907                 pins[2] = nid;
4908                 break;
4909         }
4910 }
4911
4912 /*
4913  * Parse all pin widgets and store the useful pin nids to cfg
4914  *
4915  * The number of line-outs or any primary output is stored in line_outs,
4916  * and the corresponding output pins are assigned to line_out_pins[],
4917  * in the order of front, rear, CLFE, side, ...
4918  *
4919  * If more extra outputs (speaker and headphone) are found, the pins are
4920  * assisnged to hp_pins[] and speaker_pins[], respectively.  If no line-out jack
4921  * is detected, one of speaker of HP pins is assigned as the primary
4922  * output, i.e. to line_out_pins[0].  So, line_outs is always positive
4923  * if any analog output exists.
4924  *
4925  * The analog input pins are assigned to inputs array.
4926  * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4927  * respectively.
4928  */
4929 int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
4930                              struct auto_pin_cfg *cfg,
4931                              const hda_nid_t *ignore_nids,
4932                              unsigned int cond_flags)
4933 {
4934         hda_nid_t nid, end_nid;
4935         short seq, assoc_line_out;
4936         short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4937         short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
4938         short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
4939         int i;
4940
4941         memset(cfg, 0, sizeof(*cfg));
4942
4943         memset(sequences_line_out, 0, sizeof(sequences_line_out));
4944         memset(sequences_speaker, 0, sizeof(sequences_speaker));
4945         memset(sequences_hp, 0, sizeof(sequences_hp));
4946         assoc_line_out = 0;
4947
4948         codec->ignore_misc_bit = true;
4949         end_nid = codec->start_nid + codec->num_nodes;
4950         for (nid = codec->start_nid; nid < end_nid; nid++) {
4951                 unsigned int wid_caps = get_wcaps(codec, nid);
4952                 unsigned int wid_type = get_wcaps_type(wid_caps);
4953                 unsigned int def_conf;
4954                 short assoc, loc, conn, dev;
4955
4956                 /* read all default configuration for pin complex */
4957                 if (wid_type != AC_WID_PIN)
4958                         continue;
4959                 /* ignore the given nids (e.g. pc-beep returns error) */
4960                 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4961                         continue;
4962
4963                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4964                 if (!(get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
4965                       AC_DEFCFG_MISC_NO_PRESENCE))
4966                         codec->ignore_misc_bit = false;
4967                 conn = get_defcfg_connect(def_conf);
4968                 if (conn == AC_JACK_PORT_NONE)
4969                         continue;
4970                 loc = get_defcfg_location(def_conf);
4971                 dev = get_defcfg_device(def_conf);
4972
4973                 /* workaround for buggy BIOS setups */
4974                 if (dev == AC_JACK_LINE_OUT) {
4975                         if (conn == AC_JACK_PORT_FIXED)
4976                                 dev = AC_JACK_SPEAKER;
4977                 }
4978
4979                 switch (dev) {
4980                 case AC_JACK_LINE_OUT:
4981                         seq = get_defcfg_sequence(def_conf);
4982                         assoc = get_defcfg_association(def_conf);
4983
4984                         if (!(wid_caps & AC_WCAP_STEREO))
4985                                 if (!cfg->mono_out_pin)
4986                                         cfg->mono_out_pin = nid;
4987                         if (!assoc)
4988                                 continue;
4989                         if (!assoc_line_out)
4990                                 assoc_line_out = assoc;
4991                         else if (assoc_line_out != assoc)
4992                                 continue;
4993                         if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4994                                 continue;
4995                         cfg->line_out_pins[cfg->line_outs] = nid;
4996                         sequences_line_out[cfg->line_outs] = seq;
4997                         cfg->line_outs++;
4998                         break;
4999                 case AC_JACK_SPEAKER:
5000                         seq = get_defcfg_sequence(def_conf);
5001                         assoc = get_defcfg_association(def_conf);
5002                         if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
5003                                 continue;
5004                         cfg->speaker_pins[cfg->speaker_outs] = nid;
5005                         sequences_speaker[cfg->speaker_outs] = (assoc << 4) | seq;
5006                         cfg->speaker_outs++;
5007                         break;
5008                 case AC_JACK_HP_OUT:
5009                         seq = get_defcfg_sequence(def_conf);
5010                         assoc = get_defcfg_association(def_conf);
5011                         if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
5012                                 continue;
5013                         cfg->hp_pins[cfg->hp_outs] = nid;
5014                         sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
5015                         cfg->hp_outs++;
5016                         break;
5017                 case AC_JACK_MIC_IN:
5018                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_MIC);
5019                         break;
5020                 case AC_JACK_LINE_IN:
5021                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_LINE_IN);
5022                         break;
5023                 case AC_JACK_CD:
5024                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD);
5025                         break;
5026                 case AC_JACK_AUX:
5027                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX);
5028                         break;
5029                 case AC_JACK_SPDIF_OUT:
5030                 case AC_JACK_DIG_OTHER_OUT:
5031                         if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
5032                                 continue;
5033                         cfg->dig_out_pins[cfg->dig_outs] = nid;
5034                         cfg->dig_out_type[cfg->dig_outs] =
5035                                 (loc == AC_JACK_LOC_HDMI) ?
5036                                 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
5037                         cfg->dig_outs++;
5038                         break;
5039                 case AC_JACK_SPDIF_IN:
5040                 case AC_JACK_DIG_OTHER_IN:
5041                         cfg->dig_in_pin = nid;
5042                         if (loc == AC_JACK_LOC_HDMI)
5043                                 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
5044                         else
5045                                 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
5046                         break;
5047                 }
5048         }
5049
5050         /* FIX-UP:
5051          * If no line-out is defined but multiple HPs are found,
5052          * some of them might be the real line-outs.
5053          */
5054         if (!cfg->line_outs && cfg->hp_outs > 1 &&
5055             !(cond_flags & HDA_PINCFG_NO_HP_FIXUP)) {
5056                 int i = 0;
5057                 while (i < cfg->hp_outs) {
5058                         /* The real HPs should have the sequence 0x0f */
5059                         if ((sequences_hp[i] & 0x0f) == 0x0f) {
5060                                 i++;
5061                                 continue;
5062                         }
5063                         /* Move it to the line-out table */
5064                         cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
5065                         sequences_line_out[cfg->line_outs] = sequences_hp[i];
5066                         cfg->line_outs++;
5067                         cfg->hp_outs--;
5068                         memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
5069                                 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
5070                         memmove(sequences_hp + i, sequences_hp + i + 1,
5071                                 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
5072                 }
5073                 memset(cfg->hp_pins + cfg->hp_outs, 0,
5074                        sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs));
5075                 if (!cfg->hp_outs)
5076                         cfg->line_out_type = AUTO_PIN_HP_OUT;
5077
5078         }
5079
5080         /* sort by sequence */
5081         sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
5082                               cfg->line_outs);
5083         sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
5084                               cfg->speaker_outs);
5085         sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
5086                               cfg->hp_outs);
5087
5088         /*
5089          * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
5090          * as a primary output
5091          */
5092         if (!cfg->line_outs &&
5093             !(cond_flags & HDA_PINCFG_NO_LO_FIXUP)) {
5094                 if (cfg->speaker_outs) {
5095                         cfg->line_outs = cfg->speaker_outs;
5096                         memcpy(cfg->line_out_pins, cfg->speaker_pins,
5097                                sizeof(cfg->speaker_pins));
5098                         cfg->speaker_outs = 0;
5099                         memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
5100                         cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
5101                 } else if (cfg->hp_outs) {
5102                         cfg->line_outs = cfg->hp_outs;
5103                         memcpy(cfg->line_out_pins, cfg->hp_pins,
5104                                sizeof(cfg->hp_pins));
5105                         cfg->hp_outs = 0;
5106                         memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
5107                         cfg->line_out_type = AUTO_PIN_HP_OUT;
5108                 }
5109         }
5110
5111         reorder_outputs(cfg->line_outs, cfg->line_out_pins);
5112         reorder_outputs(cfg->hp_outs, cfg->hp_pins);
5113         reorder_outputs(cfg->speaker_outs, cfg->speaker_pins);
5114
5115         sort_autocfg_input_pins(cfg);
5116
5117         /*
5118          * debug prints of the parsed results
5119          */
5120         snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
5121                    cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
5122                    cfg->line_out_pins[2], cfg->line_out_pins[3],
5123                    cfg->line_out_pins[4],
5124                    cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
5125                    (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT ?
5126                     "speaker" : "line"));
5127         snd_printd("   speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
5128                    cfg->speaker_outs, cfg->speaker_pins[0],
5129                    cfg->speaker_pins[1], cfg->speaker_pins[2],
5130                    cfg->speaker_pins[3], cfg->speaker_pins[4]);
5131         snd_printd("   hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
5132                    cfg->hp_outs, cfg->hp_pins[0],
5133                    cfg->hp_pins[1], cfg->hp_pins[2],
5134                    cfg->hp_pins[3], cfg->hp_pins[4]);
5135         snd_printd("   mono: mono_out=0x%x\n", cfg->mono_out_pin);
5136         if (cfg->dig_outs)
5137                 snd_printd("   dig-out=0x%x/0x%x\n",
5138                            cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
5139         snd_printd("   inputs:");
5140         for (i = 0; i < cfg->num_inputs; i++) {
5141                 snd_printd(" %s=0x%x",
5142                             hda_get_autocfg_input_label(codec, cfg, i),
5143                             cfg->inputs[i].pin);
5144         }
5145         snd_printd("\n");
5146         if (cfg->dig_in_pin)
5147                 snd_printd("   dig-in=0x%x\n", cfg->dig_in_pin);
5148
5149         return 0;
5150 }
5151 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_defcfg);
5152
5153 int snd_hda_get_input_pin_attr(unsigned int def_conf)
5154 {
5155         unsigned int loc = get_defcfg_location(def_conf);
5156         unsigned int conn = get_defcfg_connect(def_conf);
5157         if (conn == AC_JACK_PORT_NONE)
5158                 return INPUT_PIN_ATTR_UNUSED;
5159         /* Windows may claim the internal mic to be BOTH, too */
5160         if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH)
5161                 return INPUT_PIN_ATTR_INT;
5162         if ((loc & 0x30) == AC_JACK_LOC_INTERNAL)
5163                 return INPUT_PIN_ATTR_INT;
5164         if ((loc & 0x30) == AC_JACK_LOC_SEPARATE)
5165                 return INPUT_PIN_ATTR_DOCK;
5166         if (loc == AC_JACK_LOC_REAR)
5167                 return INPUT_PIN_ATTR_REAR;
5168         if (loc == AC_JACK_LOC_FRONT)
5169                 return INPUT_PIN_ATTR_FRONT;
5170         return INPUT_PIN_ATTR_NORMAL;
5171 }
5172 EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
5173
5174 /**
5175  * hda_get_input_pin_label - Give a label for the given input pin
5176  *
5177  * When check_location is true, the function checks the pin location
5178  * for mic and line-in pins, and set an appropriate prefix like "Front",
5179  * "Rear", "Internal".
5180  */
5181
5182 static const char *hda_get_input_pin_label(struct hda_codec *codec,
5183                                            hda_nid_t pin, bool check_location)
5184 {
5185         unsigned int def_conf;
5186         static const char * const mic_names[] = {
5187                 "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic",
5188         };
5189         int attr;
5190
5191         def_conf = snd_hda_codec_get_pincfg(codec, pin);
5192
5193         switch (get_defcfg_device(def_conf)) {
5194         case AC_JACK_MIC_IN:
5195                 if (!check_location)
5196                         return "Mic";
5197                 attr = snd_hda_get_input_pin_attr(def_conf);
5198                 if (!attr)
5199                         return "None";
5200                 return mic_names[attr - 1];
5201         case AC_JACK_LINE_IN:
5202                 if (!check_location)
5203                         return "Line";
5204                 attr = snd_hda_get_input_pin_attr(def_conf);
5205                 if (!attr)
5206                         return "None";
5207                 if (attr == INPUT_PIN_ATTR_DOCK)
5208                         return "Dock Line";
5209                 return "Line";
5210         case AC_JACK_AUX:
5211                 return "Aux";
5212         case AC_JACK_CD:
5213                 return "CD";
5214         case AC_JACK_SPDIF_IN:
5215                 return "SPDIF In";
5216         case AC_JACK_DIG_OTHER_IN:
5217                 return "Digital In";
5218         default:
5219                 return "Misc";
5220         }
5221 }
5222
5223 /* Check whether the location prefix needs to be added to the label.
5224  * If all mic-jacks are in the same location (e.g. rear panel), we don't
5225  * have to put "Front" prefix to each label.  In such a case, returns false.
5226  */
5227 static int check_mic_location_need(struct hda_codec *codec,
5228                                    const struct auto_pin_cfg *cfg,
5229                                    int input)
5230 {
5231         unsigned int defc;
5232         int i, attr, attr2;
5233
5234         defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin);
5235         attr = snd_hda_get_input_pin_attr(defc);
5236         /* for internal or docking mics, we need locations */
5237         if (attr <= INPUT_PIN_ATTR_NORMAL)
5238                 return 1;
5239
5240         attr = 0;
5241         for (i = 0; i < cfg->num_inputs; i++) {
5242                 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin);
5243                 attr2 = snd_hda_get_input_pin_attr(defc);
5244                 if (attr2 >= INPUT_PIN_ATTR_NORMAL) {
5245                         if (attr && attr != attr2)
5246                                 return 1; /* different locations found */
5247                         attr = attr2;
5248                 }
5249         }
5250         return 0;
5251 }
5252
5253 /**
5254  * hda_get_autocfg_input_label - Get a label for the given input
5255  *
5256  * Get a label for the given input pin defined by the autocfg item.
5257  * Unlike hda_get_input_pin_label(), this function checks all inputs
5258  * defined in autocfg and avoids the redundant mic/line prefix as much as
5259  * possible.
5260  */
5261 const char *hda_get_autocfg_input_label(struct hda_codec *codec,
5262                                         const struct auto_pin_cfg *cfg,
5263                                         int input)
5264 {
5265         int type = cfg->inputs[input].type;
5266         int has_multiple_pins = 0;
5267
5268         if ((input > 0 && cfg->inputs[input - 1].type == type) ||
5269             (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type))
5270                 has_multiple_pins = 1;
5271         if (has_multiple_pins && type == AUTO_PIN_MIC)
5272                 has_multiple_pins &= check_mic_location_need(codec, cfg, input);
5273         return hda_get_input_pin_label(codec, cfg->inputs[input].pin,
5274                                        has_multiple_pins);
5275 }
5276 EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
5277
5278 /* return the position of NID in the list, or -1 if not found */
5279 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
5280 {
5281         int i;
5282         for (i = 0; i < nums; i++)
5283                 if (list[i] == nid)
5284                         return i;
5285         return -1;
5286 }
5287
5288 /* get a unique suffix or an index number */
5289 static const char *check_output_sfx(hda_nid_t nid, const hda_nid_t *pins,
5290                                     int num_pins, int *indexp)
5291 {
5292         static const char * const channel_sfx[] = {
5293                 " Front", " Surround", " CLFE", " Side"
5294         };
5295         int i;
5296
5297         i = find_idx_in_nid_list(nid, pins, num_pins);
5298         if (i < 0)
5299                 return NULL;
5300         if (num_pins == 1)
5301                 return "";
5302         if (num_pins > ARRAY_SIZE(channel_sfx)) {
5303                 if (indexp)
5304                         *indexp = i;
5305                 return "";
5306         }
5307         return channel_sfx[i];
5308 }
5309
5310 static int fill_audio_out_name(struct hda_codec *codec, hda_nid_t nid,
5311                                const struct auto_pin_cfg *cfg,
5312                                const char *name, char *label, int maxlen,
5313                                int *indexp)
5314 {
5315         unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5316         int attr = snd_hda_get_input_pin_attr(def_conf);
5317         const char *pfx = "", *sfx = "";
5318
5319         /* handle as a speaker if it's a fixed line-out */
5320         if (!strcmp(name, "Line Out") && attr == INPUT_PIN_ATTR_INT)
5321                 name = "Speaker";
5322         /* check the location */
5323         switch (attr) {
5324         case INPUT_PIN_ATTR_DOCK:
5325                 pfx = "Dock ";
5326                 break;
5327         case INPUT_PIN_ATTR_FRONT:
5328                 pfx = "Front ";
5329                 break;
5330         }
5331         if (cfg) {
5332                 /* try to give a unique suffix if needed */
5333                 sfx = check_output_sfx(nid, cfg->line_out_pins, cfg->line_outs,
5334                                        indexp);
5335                 if (!sfx)
5336                         sfx = check_output_sfx(nid, cfg->speaker_pins, cfg->speaker_outs,
5337                                                indexp);
5338                 if (!sfx) {
5339                         /* don't add channel suffix for Headphone controls */
5340                         int idx = find_idx_in_nid_list(nid, cfg->hp_pins,
5341                                                        cfg->hp_outs);
5342                         if (idx >= 0)
5343                                 *indexp = idx;
5344                         sfx = "";
5345                 }
5346         }
5347         snprintf(label, maxlen, "%s%s%s", pfx, name, sfx);
5348         return 1;
5349 }
5350
5351 /**
5352  * snd_hda_get_pin_label - Get a label for the given I/O pin
5353  *
5354  * Get a label for the given pin.  This function works for both input and
5355  * output pins.  When @cfg is given as non-NULL, the function tries to get
5356  * an optimized label using hda_get_autocfg_input_label().
5357  *
5358  * This function tries to give a unique label string for the pin as much as
5359  * possible.  For example, when the multiple line-outs are present, it adds
5360  * the channel suffix like "Front", "Surround", etc (only when @cfg is given).
5361  * If no unique name with a suffix is available and @indexp is non-NULL, the
5362  * index number is stored in the pointer.
5363  */
5364 int snd_hda_get_pin_label(struct hda_codec *codec, hda_nid_t nid,
5365                           const struct auto_pin_cfg *cfg,
5366                           char *label, int maxlen, int *indexp)
5367 {
5368         unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5369         const char *name = NULL;
5370         int i;
5371
5372         if (indexp)
5373                 *indexp = 0;
5374         if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
5375                 return 0;
5376
5377         switch (get_defcfg_device(def_conf)) {
5378         case AC_JACK_LINE_OUT:
5379                 return fill_audio_out_name(codec, nid, cfg, "Line Out",
5380                                            label, maxlen, indexp);
5381         case AC_JACK_SPEAKER:
5382                 return fill_audio_out_name(codec, nid, cfg, "Speaker",
5383                                            label, maxlen, indexp);
5384         case AC_JACK_HP_OUT:
5385                 return fill_audio_out_name(codec, nid, cfg, "Headphone",
5386                                            label, maxlen, indexp);
5387         case AC_JACK_SPDIF_OUT:
5388         case AC_JACK_DIG_OTHER_OUT:
5389                 if (get_defcfg_location(def_conf) == AC_JACK_LOC_HDMI)
5390                         name = "HDMI";
5391                 else
5392                         name = "SPDIF";
5393                 if (cfg && indexp) {
5394                         i = find_idx_in_nid_list(nid, cfg->dig_out_pins,
5395                                                  cfg->dig_outs);
5396                         if (i >= 0)
5397                                 *indexp = i;
5398                 }
5399                 break;
5400         default:
5401                 if (cfg) {
5402                         for (i = 0; i < cfg->num_inputs; i++) {
5403                                 if (cfg->inputs[i].pin != nid)
5404                                         continue;
5405                                 name = hda_get_autocfg_input_label(codec, cfg, i);
5406                                 if (name)
5407                                         break;
5408                         }
5409                 }
5410                 if (!name)
5411                         name = hda_get_input_pin_label(codec, nid, true);
5412                 break;
5413         }
5414         if (!name)
5415                 return 0;
5416         strlcpy(label, name, maxlen);
5417         return 1;
5418 }
5419 EXPORT_SYMBOL_HDA(snd_hda_get_pin_label);
5420
5421 /**
5422  * snd_hda_add_imux_item - Add an item to input_mux
5423  *
5424  * When the same label is used already in the existing items, the number
5425  * suffix is appended to the label.  This label index number is stored
5426  * to type_idx when non-NULL pointer is given.
5427  */
5428 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5429                           int index, int *type_idx)
5430 {
5431         int i, label_idx = 0;
5432         if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5433                 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5434                 return -EINVAL;
5435         }
5436         for (i = 0; i < imux->num_items; i++) {
5437                 if (!strncmp(label, imux->items[i].label, strlen(label)))
5438                         label_idx++;
5439         }
5440         if (type_idx)
5441                 *type_idx = label_idx;
5442         if (label_idx > 0)
5443                 snprintf(imux->items[imux->num_items].label,
5444                          sizeof(imux->items[imux->num_items].label),
5445                          "%s %d", label, label_idx);
5446         else
5447                 strlcpy(imux->items[imux->num_items].label, label,
5448                         sizeof(imux->items[imux->num_items].label));
5449         imux->items[imux->num_items].index = index;
5450         imux->num_items++;
5451         return 0;
5452 }
5453 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5454
5455
5456 #ifdef CONFIG_PM
5457 /*
5458  * power management
5459  */
5460
5461 /**
5462  * snd_hda_suspend - suspend the codecs
5463  * @bus: the HDA bus
5464  *
5465  * Returns 0 if successful.
5466  */
5467 int snd_hda_suspend(struct hda_bus *bus)
5468 {
5469         struct hda_codec *codec;
5470
5471         list_for_each_entry(codec, &bus->codec_list, list) {
5472                 if (hda_codec_is_power_on(codec))
5473                         hda_call_codec_suspend(codec);
5474                 if (codec->patch_ops.post_suspend)
5475                         codec->patch_ops.post_suspend(codec);
5476         }
5477         return 0;
5478 }
5479 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5480
5481 /**
5482  * snd_hda_resume - resume the codecs
5483  * @bus: the HDA bus
5484  *
5485  * Returns 0 if successful.
5486  *
5487  * This function is defined only when POWER_SAVE isn't set.
5488  * In the power-save mode, the codec is resumed dynamically.
5489  */
5490 int snd_hda_resume(struct hda_bus *bus)
5491 {
5492         struct hda_codec *codec;
5493
5494         list_for_each_entry(codec, &bus->codec_list, list) {
5495                 if (codec->patch_ops.pre_resume)
5496                         codec->patch_ops.pre_resume(codec);
5497                 if (snd_hda_codec_needs_resume(codec))
5498                         hda_call_codec_resume(codec);
5499         }
5500         return 0;
5501 }
5502 EXPORT_SYMBOL_HDA(snd_hda_resume);
5503 #endif /* CONFIG_PM */
5504
5505 /*
5506  * generic arrays
5507  */
5508
5509 /**
5510  * snd_array_new - get a new element from the given array
5511  * @array: the array object
5512  *
5513  * Get a new element from the given array.  If it exceeds the
5514  * pre-allocated array size, re-allocate the array.
5515  *
5516  * Returns NULL if allocation failed.
5517  */
5518 void *snd_array_new(struct snd_array *array)
5519 {
5520         if (array->used >= array->alloced) {
5521                 int num = array->alloced + array->alloc_align;
5522                 int size = (num + 1) * array->elem_size;
5523                 int oldsize = array->alloced * array->elem_size;
5524                 void *nlist;
5525                 if (snd_BUG_ON(num >= 4096))
5526                         return NULL;
5527                 nlist = krealloc(array->list, size, GFP_KERNEL);
5528                 if (!nlist)
5529                         return NULL;
5530                 memset(nlist + oldsize, 0, size - oldsize);
5531                 array->list = nlist;
5532                 array->alloced = num;
5533         }
5534         return snd_array_elem(array, array->used++);
5535 }
5536 EXPORT_SYMBOL_HDA(snd_array_new);
5537
5538 /**
5539  * snd_array_free - free the given array elements
5540  * @array: the array object
5541  */
5542 void snd_array_free(struct snd_array *array)
5543 {
5544         kfree(array->list);
5545         array->used = 0;
5546         array->alloced = 0;
5547         array->list = NULL;
5548 }
5549 EXPORT_SYMBOL_HDA(snd_array_free);
5550
5551 /**
5552  * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5553  * @pcm: PCM caps bits
5554  * @buf: the string buffer to write
5555  * @buflen: the max buffer length
5556  *
5557  * used by hda_proc.c and hda_eld.c
5558  */
5559 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5560 {
5561         static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5562         int i, j;
5563
5564         for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5565                 if (pcm & (AC_SUPPCM_BITS_8 << i))
5566                         j += snprintf(buf + j, buflen - j,  " %d", bits[i]);
5567
5568         buf[j] = '\0'; /* necessary when j == 0 */
5569 }
5570 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5571
5572 MODULE_DESCRIPTION("HDA codec core");
5573 MODULE_LICENSE("GPL");