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