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