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