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