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