b649033a4c8181549be2a6a460cdf3263ea28b32
[linux-2.6.git] / sound / pci / hda / hda_codec.c
1 /*
2  * Universal Interface for Intel High Definition Audio Codec
3  *
4  * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
5  *
6  *
7  *  This driver is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License as published by
9  *  the Free Software Foundation; either version 2 of the License, or
10  *  (at your option) any later version.
11  *
12  *  This driver is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *  GNU General Public License for more details.
16  *
17  *  You should have received a copy of the GNU General Public License
18  *  along with this program; if not, write to the Free Software
19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
20  */
21
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/pci.h>
26 #include <linux/mutex.h>
27 #include <sound/core.h>
28 #include "hda_codec.h"
29 #include <sound/asoundef.h>
30 #include <sound/tlv.h>
31 #include <sound/initval.h>
32 #include "hda_local.h"
33 #include <sound/hda_hwdep.h>
34
35 /*
36  * vendor / preset table
37  */
38
39 struct hda_vendor_id {
40         unsigned int id;
41         const char *name;
42 };
43
44 /* codec vendor labels */
45 static struct hda_vendor_id hda_vendor_ids[] = {
46         { 0x1002, "ATI" },
47         { 0x1057, "Motorola" },
48         { 0x1095, "Silicon Image" },
49         { 0x10de, "Nvidia" },
50         { 0x10ec, "Realtek" },
51         { 0x1102, "Creative" },
52         { 0x1106, "VIA" },
53         { 0x111d, "IDT" },
54         { 0x11c1, "LSI" },
55         { 0x11d4, "Analog Devices" },
56         { 0x13f6, "C-Media" },
57         { 0x14f1, "Conexant" },
58         { 0x17e8, "Chrontel" },
59         { 0x1854, "LG" },
60         { 0x1aec, "Wolfson Microelectronics" },
61         { 0x434d, "C-Media" },
62         { 0x8086, "Intel" },
63         { 0x8384, "SigmaTel" },
64         {} /* terminator */
65 };
66
67 static DEFINE_MUTEX(preset_mutex);
68 static LIST_HEAD(hda_preset_tables);
69
70 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
71 {
72         mutex_lock(&preset_mutex);
73         list_add_tail(&preset->list, &hda_preset_tables);
74         mutex_unlock(&preset_mutex);
75         return 0;
76 }
77 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
78
79 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
80 {
81         mutex_lock(&preset_mutex);
82         list_del(&preset->list);
83         mutex_unlock(&preset_mutex);
84         return 0;
85 }
86 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
87
88 #ifdef CONFIG_SND_HDA_POWER_SAVE
89 static void hda_power_work(struct work_struct *work);
90 static void hda_keep_power_on(struct hda_codec *codec);
91 #else
92 static inline void hda_keep_power_on(struct hda_codec *codec) {}
93 #endif
94
95 const char *snd_hda_get_jack_location(u32 cfg)
96 {
97         static char *bases[7] = {
98                 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
99         };
100         static unsigned char specials_idx[] = {
101                 0x07, 0x08,
102                 0x17, 0x18, 0x19,
103                 0x37, 0x38
104         };
105         static char *specials[] = {
106                 "Rear Panel", "Drive Bar",
107                 "Riser", "HDMI", "ATAPI",
108                 "Mobile-In", "Mobile-Out"
109         };
110         int i;
111         cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
112         if ((cfg & 0x0f) < 7)
113                 return bases[cfg & 0x0f];
114         for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
115                 if (cfg == specials_idx[i])
116                         return specials[i];
117         }
118         return "UNKNOWN";
119 }
120 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
121
122 const char *snd_hda_get_jack_connectivity(u32 cfg)
123 {
124         static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
125
126         return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
127 }
128 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
129
130 const char *snd_hda_get_jack_type(u32 cfg)
131 {
132         static char *jack_types[16] = {
133                 "Line Out", "Speaker", "HP Out", "CD",
134                 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
135                 "Line In", "Aux", "Mic", "Telephony",
136                 "SPDIF In", "Digitial In", "Reserved", "Other"
137         };
138
139         return jack_types[(cfg & AC_DEFCFG_DEVICE)
140                                 >> AC_DEFCFG_DEVICE_SHIFT];
141 }
142 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
143
144 /*
145  * Compose a 32bit command word to be sent to the HD-audio controller
146  */
147 static inline unsigned int
148 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
149                unsigned int verb, unsigned int parm)
150 {
151         u32 val;
152
153         val = (u32)(codec->addr & 0x0f) << 28;
154         val |= (u32)direct << 27;
155         val |= (u32)nid << 20;
156         val |= verb << 8;
157         val |= parm;
158         return val;
159 }
160
161 /**
162  * snd_hda_codec_read - send a command and get the response
163  * @codec: the HDA codec
164  * @nid: NID to send the command
165  * @direct: direct flag
166  * @verb: the verb to send
167  * @parm: the parameter for the verb
168  *
169  * Send a single command and read the corresponding response.
170  *
171  * Returns the obtained response value, or -1 for an error.
172  */
173 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
174                                 int direct,
175                                 unsigned int verb, unsigned int parm)
176 {
177         struct hda_bus *bus = codec->bus;
178         unsigned int cmd, res;
179         int repeated = 0;
180
181         cmd = make_codec_cmd(codec, nid, direct, verb, parm);
182         snd_hda_power_up(codec);
183         mutex_lock(&bus->cmd_mutex);
184  again:
185         if (!bus->ops.command(bus, cmd)) {
186                 res = bus->ops.get_response(bus);
187                 if (res == -1 && bus->rirb_error) {
188                         if (repeated++ < 1) {
189                                 snd_printd(KERN_WARNING "hda_codec: "
190                                            "Trying verb 0x%08x again\n", cmd);
191                                 goto again;
192                         }
193                 }
194         } else
195                 res = (unsigned int)-1;
196         mutex_unlock(&bus->cmd_mutex);
197         snd_hda_power_down(codec);
198         return res;
199 }
200 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
201
202 /**
203  * snd_hda_codec_write - send a single command without waiting for response
204  * @codec: the HDA codec
205  * @nid: NID to send the command
206  * @direct: direct flag
207  * @verb: the verb to send
208  * @parm: the parameter for the verb
209  *
210  * Send a single command without waiting for response.
211  *
212  * Returns 0 if successful, or a negative error code.
213  */
214 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
215                          unsigned int verb, unsigned int parm)
216 {
217         struct hda_bus *bus = codec->bus;
218         unsigned int res;
219         int err;
220
221         res = make_codec_cmd(codec, nid, direct, verb, parm);
222         snd_hda_power_up(codec);
223         mutex_lock(&bus->cmd_mutex);
224         err = bus->ops.command(bus, res);
225         mutex_unlock(&bus->cmd_mutex);
226         snd_hda_power_down(codec);
227         return err;
228 }
229 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
230
231 /**
232  * snd_hda_sequence_write - sequence writes
233  * @codec: the HDA codec
234  * @seq: VERB array to send
235  *
236  * Send the commands sequentially from the given array.
237  * The array must be terminated with NID=0.
238  */
239 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
240 {
241         for (; seq->nid; seq++)
242                 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
243 }
244 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
245
246 /**
247  * snd_hda_get_sub_nodes - get the range of sub nodes
248  * @codec: the HDA codec
249  * @nid: NID to parse
250  * @start_id: the pointer to store the start NID
251  *
252  * Parse the NID and store the start NID of its sub-nodes.
253  * Returns the number of sub-nodes.
254  */
255 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
256                           hda_nid_t *start_id)
257 {
258         unsigned int parm;
259
260         parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
261         if (parm == -1)
262                 return 0;
263         *start_id = (parm >> 16) & 0x7fff;
264         return (int)(parm & 0x7fff);
265 }
266 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
267
268 /**
269  * snd_hda_get_connections - get connection list
270  * @codec: the HDA codec
271  * @nid: NID to parse
272  * @conn_list: connection list array
273  * @max_conns: max. number of connections to store
274  *
275  * Parses the connection list of the given widget and stores the list
276  * of NIDs.
277  *
278  * Returns the number of connections, or a negative error code.
279  */
280 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
281                             hda_nid_t *conn_list, int max_conns)
282 {
283         unsigned int parm;
284         int i, conn_len, conns;
285         unsigned int shift, num_elems, mask;
286         hda_nid_t prev_nid;
287
288         if (snd_BUG_ON(!conn_list || max_conns <= 0))
289                 return -EINVAL;
290
291         parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
292         if (parm & AC_CLIST_LONG) {
293                 /* long form */
294                 shift = 16;
295                 num_elems = 2;
296         } else {
297                 /* short form */
298                 shift = 8;
299                 num_elems = 4;
300         }
301         conn_len = parm & AC_CLIST_LENGTH;
302         mask = (1 << (shift-1)) - 1;
303
304         if (!conn_len)
305                 return 0; /* no connection */
306
307         if (conn_len == 1) {
308                 /* single connection */
309                 parm = snd_hda_codec_read(codec, nid, 0,
310                                           AC_VERB_GET_CONNECT_LIST, 0);
311                 conn_list[0] = parm & mask;
312                 return 1;
313         }
314
315         /* multi connection */
316         conns = 0;
317         prev_nid = 0;
318         for (i = 0; i < conn_len; i++) {
319                 int range_val;
320                 hda_nid_t val, n;
321
322                 if (i % num_elems == 0)
323                         parm = snd_hda_codec_read(codec, nid, 0,
324                                                   AC_VERB_GET_CONNECT_LIST, i);
325                 range_val = !!(parm & (1 << (shift-1))); /* ranges */
326                 val = parm & mask;
327                 parm >>= shift;
328                 if (range_val) {
329                         /* ranges between the previous and this one */
330                         if (!prev_nid || prev_nid >= val) {
331                                 snd_printk(KERN_WARNING "hda_codec: "
332                                            "invalid dep_range_val %x:%x\n",
333                                            prev_nid, val);
334                                 continue;
335                         }
336                         for (n = prev_nid + 1; n <= val; n++) {
337                                 if (conns >= max_conns) {
338                                         snd_printk(KERN_ERR
339                                                    "Too many connections\n");
340                                         return -EINVAL;
341                                 }
342                                 conn_list[conns++] = n;
343                         }
344                 } else {
345                         if (conns >= max_conns) {
346                                 snd_printk(KERN_ERR "Too many connections\n");
347                                 return -EINVAL;
348                         }
349                         conn_list[conns++] = val;
350                 }
351                 prev_nid = val;
352         }
353         return conns;
354 }
355 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
356
357
358 /**
359  * snd_hda_queue_unsol_event - add an unsolicited event to queue
360  * @bus: the BUS
361  * @res: unsolicited event (lower 32bit of RIRB entry)
362  * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
363  *
364  * Adds the given event to the queue.  The events are processed in
365  * the workqueue asynchronously.  Call this function in the interrupt
366  * hanlder when RIRB receives an unsolicited event.
367  *
368  * Returns 0 if successful, or a negative error code.
369  */
370 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
371 {
372         struct hda_bus_unsolicited *unsol;
373         unsigned int wp;
374
375         unsol = bus->unsol;
376         if (!unsol)
377                 return 0;
378
379         wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
380         unsol->wp = wp;
381
382         wp <<= 1;
383         unsol->queue[wp] = res;
384         unsol->queue[wp + 1] = res_ex;
385
386         queue_work(bus->workq, &unsol->work);
387
388         return 0;
389 }
390 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
391
392 /*
393  * process queued unsolicited events
394  */
395 static void process_unsol_events(struct work_struct *work)
396 {
397         struct hda_bus_unsolicited *unsol =
398                 container_of(work, struct hda_bus_unsolicited, work);
399         struct hda_bus *bus = unsol->bus;
400         struct hda_codec *codec;
401         unsigned int rp, caddr, res;
402
403         while (unsol->rp != unsol->wp) {
404                 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
405                 unsol->rp = rp;
406                 rp <<= 1;
407                 res = unsol->queue[rp];
408                 caddr = unsol->queue[rp + 1];
409                 if (!(caddr & (1 << 4))) /* no unsolicited event? */
410                         continue;
411                 codec = bus->caddr_tbl[caddr & 0x0f];
412                 if (codec && codec->patch_ops.unsol_event)
413                         codec->patch_ops.unsol_event(codec, res);
414         }
415 }
416
417 /*
418  * initialize unsolicited queue
419  */
420 static int init_unsol_queue(struct hda_bus *bus)
421 {
422         struct hda_bus_unsolicited *unsol;
423
424         if (bus->unsol) /* already initialized */
425                 return 0;
426
427         unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
428         if (!unsol) {
429                 snd_printk(KERN_ERR "hda_codec: "
430                            "can't allocate unsolicited queue\n");
431                 return -ENOMEM;
432         }
433         INIT_WORK(&unsol->work, process_unsol_events);
434         unsol->bus = bus;
435         bus->unsol = unsol;
436         return 0;
437 }
438
439 /*
440  * destructor
441  */
442 static void snd_hda_codec_free(struct hda_codec *codec);
443
444 static int snd_hda_bus_free(struct hda_bus *bus)
445 {
446         struct hda_codec *codec, *n;
447
448         if (!bus)
449                 return 0;
450         if (bus->workq)
451                 flush_workqueue(bus->workq);
452         if (bus->unsol)
453                 kfree(bus->unsol);
454         list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
455                 snd_hda_codec_free(codec);
456         }
457         if (bus->ops.private_free)
458                 bus->ops.private_free(bus);
459         if (bus->workq)
460                 destroy_workqueue(bus->workq);
461         kfree(bus);
462         return 0;
463 }
464
465 static int snd_hda_bus_dev_free(struct snd_device *device)
466 {
467         struct hda_bus *bus = device->device_data;
468         bus->shutdown = 1;
469         return snd_hda_bus_free(bus);
470 }
471
472 #ifdef CONFIG_SND_HDA_HWDEP
473 static int snd_hda_bus_dev_register(struct snd_device *device)
474 {
475         struct hda_bus *bus = device->device_data;
476         struct hda_codec *codec;
477         list_for_each_entry(codec, &bus->codec_list, list) {
478                 snd_hda_hwdep_add_sysfs(codec);
479         }
480         return 0;
481 }
482 #else
483 #define snd_hda_bus_dev_register        NULL
484 #endif
485
486 /**
487  * snd_hda_bus_new - create a HDA bus
488  * @card: the card entry
489  * @temp: the template for hda_bus information
490  * @busp: the pointer to store the created bus instance
491  *
492  * Returns 0 if successful, or a negative error code.
493  */
494 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
495                               const struct hda_bus_template *temp,
496                               struct hda_bus **busp)
497 {
498         struct hda_bus *bus;
499         int err;
500         static struct snd_device_ops dev_ops = {
501                 .dev_register = snd_hda_bus_dev_register,
502                 .dev_free = snd_hda_bus_dev_free,
503         };
504
505         if (snd_BUG_ON(!temp))
506                 return -EINVAL;
507         if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
508                 return -EINVAL;
509
510         if (busp)
511                 *busp = NULL;
512
513         bus = kzalloc(sizeof(*bus), GFP_KERNEL);
514         if (bus == NULL) {
515                 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
516                 return -ENOMEM;
517         }
518
519         bus->card = card;
520         bus->private_data = temp->private_data;
521         bus->pci = temp->pci;
522         bus->modelname = temp->modelname;
523         bus->power_save = temp->power_save;
524         bus->ops = temp->ops;
525
526         mutex_init(&bus->cmd_mutex);
527         INIT_LIST_HEAD(&bus->codec_list);
528
529         snprintf(bus->workq_name, sizeof(bus->workq_name),
530                  "hd-audio%d", card->number);
531         bus->workq = create_singlethread_workqueue(bus->workq_name);
532         if (!bus->workq) {
533                 snd_printk(KERN_ERR "cannot create workqueue %s\n",
534                            bus->workq_name);
535                 kfree(bus);
536                 return -ENOMEM;
537         }
538
539         err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
540         if (err < 0) {
541                 snd_hda_bus_free(bus);
542                 return err;
543         }
544         if (busp)
545                 *busp = bus;
546         return 0;
547 }
548 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
549
550 #ifdef CONFIG_SND_HDA_GENERIC
551 #define is_generic_config(codec) \
552         (codec->modelname && !strcmp(codec->modelname, "generic"))
553 #else
554 #define is_generic_config(codec)        0
555 #endif
556
557 #ifdef MODULE
558 #define HDA_MODREQ_MAX_COUNT    2       /* two request_modules()'s */
559 #else
560 #define HDA_MODREQ_MAX_COUNT    0       /* all presets are statically linked */
561 #endif
562
563 /*
564  * find a matching codec preset
565  */
566 static const struct hda_codec_preset *
567 find_codec_preset(struct hda_codec *codec)
568 {
569         struct hda_codec_preset_list *tbl;
570         const struct hda_codec_preset *preset;
571         int mod_requested = 0;
572
573         if (is_generic_config(codec))
574                 return NULL; /* use the generic parser */
575
576  again:
577         mutex_lock(&preset_mutex);
578         list_for_each_entry(tbl, &hda_preset_tables, list) {
579                 if (!try_module_get(tbl->owner)) {
580                         snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
581                         continue;
582                 }
583                 for (preset = tbl->preset; preset->id; preset++) {
584                         u32 mask = preset->mask;
585                         if (preset->afg && preset->afg != codec->afg)
586                                 continue;
587                         if (preset->mfg && preset->mfg != codec->mfg)
588                                 continue;
589                         if (!mask)
590                                 mask = ~0;
591                         if (preset->id == (codec->vendor_id & mask) &&
592                             (!preset->rev ||
593                              preset->rev == codec->revision_id)) {
594                                 mutex_unlock(&preset_mutex);
595                                 codec->owner = tbl->owner;
596                                 return preset;
597                         }
598                 }
599                 module_put(tbl->owner);
600         }
601         mutex_unlock(&preset_mutex);
602
603         if (mod_requested < HDA_MODREQ_MAX_COUNT) {
604                 char name[32];
605                 if (!mod_requested)
606                         snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
607                                  codec->vendor_id);
608                 else
609                         snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
610                                  (codec->vendor_id >> 16) & 0xffff);
611                 request_module(name);
612                 mod_requested++;
613                 goto again;
614         }
615         return NULL;
616 }
617
618 /*
619  * get_codec_name - store the codec name
620  */
621 static int get_codec_name(struct hda_codec *codec)
622 {
623         const struct hda_vendor_id *c;
624         const char *vendor = NULL;
625         u16 vendor_id = codec->vendor_id >> 16;
626         char tmp[16], name[32];
627
628         for (c = hda_vendor_ids; c->id; c++) {
629                 if (c->id == vendor_id) {
630                         vendor = c->name;
631                         break;
632                 }
633         }
634         if (!vendor) {
635                 sprintf(tmp, "Generic %04x", vendor_id);
636                 vendor = tmp;
637         }
638         if (codec->preset && codec->preset->name)
639                 snprintf(name, sizeof(name), "%s %s", vendor,
640                          codec->preset->name);
641         else
642                 snprintf(name, sizeof(name), "%s ID %x", vendor,
643                          codec->vendor_id & 0xffff);
644         codec->name = kstrdup(name, GFP_KERNEL);
645         if (!codec->name)
646                 return -ENOMEM;
647         return 0;
648 }
649
650 /*
651  * look for an AFG and MFG nodes
652  */
653 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
654 {
655         int i, total_nodes, function_id;
656         hda_nid_t nid;
657
658         total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
659         for (i = 0; i < total_nodes; i++, nid++) {
660                 function_id = snd_hda_param_read(codec, nid,
661                                                 AC_PAR_FUNCTION_TYPE) & 0xff;
662                 switch (function_id) {
663                 case AC_GRP_AUDIO_FUNCTION:
664                         codec->afg = nid;
665                         codec->function_id = function_id;
666                         break;
667                 case AC_GRP_MODEM_FUNCTION:
668                         codec->mfg = nid;
669                         codec->function_id = function_id;
670                         break;
671                 default:
672                         break;
673                 }
674         }
675 }
676
677 /*
678  * read widget caps for each widget and store in cache
679  */
680 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
681 {
682         int i;
683         hda_nid_t nid;
684
685         codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
686                                                  &codec->start_nid);
687         codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
688         if (!codec->wcaps)
689                 return -ENOMEM;
690         nid = codec->start_nid;
691         for (i = 0; i < codec->num_nodes; i++, nid++)
692                 codec->wcaps[i] = snd_hda_param_read(codec, nid,
693                                                      AC_PAR_AUDIO_WIDGET_CAP);
694         return 0;
695 }
696
697 /* read all pin default configurations and save codec->init_pins */
698 static int read_pin_defaults(struct hda_codec *codec)
699 {
700         int i;
701         hda_nid_t nid = codec->start_nid;
702
703         for (i = 0; i < codec->num_nodes; i++, nid++) {
704                 struct hda_pincfg *pin;
705                 unsigned int wcaps = get_wcaps(codec, nid);
706                 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
707                                 AC_WCAP_TYPE_SHIFT;
708                 if (wid_type != AC_WID_PIN)
709                         continue;
710                 pin = snd_array_new(&codec->init_pins);
711                 if (!pin)
712                         return -ENOMEM;
713                 pin->nid = nid;
714                 pin->cfg = snd_hda_codec_read(codec, nid, 0,
715                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
716         }
717         return 0;
718 }
719
720 /* look up the given pin config list and return the item matching with NID */
721 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
722                                          struct snd_array *array,
723                                          hda_nid_t nid)
724 {
725         int i;
726         for (i = 0; i < array->used; i++) {
727                 struct hda_pincfg *pin = snd_array_elem(array, i);
728                 if (pin->nid == nid)
729                         return pin;
730         }
731         return NULL;
732 }
733
734 /* write a config value for the given NID */
735 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
736                        unsigned int cfg)
737 {
738         int i;
739         for (i = 0; i < 4; i++) {
740                 snd_hda_codec_write(codec, nid, 0,
741                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
742                                     cfg & 0xff);
743                 cfg >>= 8;
744         }
745 }
746
747 /* set the current pin config value for the given NID.
748  * the value is cached, and read via snd_hda_codec_get_pincfg()
749  */
750 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
751                        hda_nid_t nid, unsigned int cfg)
752 {
753         struct hda_pincfg *pin;
754         unsigned int oldcfg;
755
756         oldcfg = snd_hda_codec_get_pincfg(codec, nid);
757         pin = look_up_pincfg(codec, list, nid);
758         if (!pin) {
759                 pin = snd_array_new(list);
760                 if (!pin)
761                         return -ENOMEM;
762                 pin->nid = nid;
763         }
764         pin->cfg = cfg;
765
766         /* change only when needed; e.g. if the pincfg is already present
767          * in user_pins[], don't write it
768          */
769         cfg = snd_hda_codec_get_pincfg(codec, nid);
770         if (oldcfg != cfg)
771                 set_pincfg(codec, nid, cfg);
772         return 0;
773 }
774
775 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
776                              hda_nid_t nid, unsigned int cfg)
777 {
778         return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
779 }
780 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
781
782 /* get the current pin config value of the given pin NID */
783 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
784 {
785         struct hda_pincfg *pin;
786
787 #ifdef CONFIG_SND_HDA_HWDEP
788         pin = look_up_pincfg(codec, &codec->user_pins, nid);
789         if (pin)
790                 return pin->cfg;
791 #endif
792         pin = look_up_pincfg(codec, &codec->driver_pins, nid);
793         if (pin)
794                 return pin->cfg;
795         pin = look_up_pincfg(codec, &codec->init_pins, nid);
796         if (pin)
797                 return pin->cfg;
798         return 0;
799 }
800 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
801
802 /* restore all current pin configs */
803 static void restore_pincfgs(struct hda_codec *codec)
804 {
805         int i;
806         for (i = 0; i < codec->init_pins.used; i++) {
807                 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
808                 set_pincfg(codec, pin->nid,
809                            snd_hda_codec_get_pincfg(codec, pin->nid));
810         }
811 }
812
813 static void init_hda_cache(struct hda_cache_rec *cache,
814                            unsigned int record_size);
815 static void free_hda_cache(struct hda_cache_rec *cache);
816
817 /* restore the initial pin cfgs and release all pincfg lists */
818 static void restore_init_pincfgs(struct hda_codec *codec)
819 {
820         /* first free driver_pins and user_pins, then call restore_pincfg
821          * so that only the values in init_pins are restored
822          */
823         snd_array_free(&codec->driver_pins);
824 #ifdef CONFIG_SND_HDA_HWDEP
825         snd_array_free(&codec->user_pins);
826 #endif
827         restore_pincfgs(codec);
828         snd_array_free(&codec->init_pins);
829 }
830
831 /*
832  * codec destructor
833  */
834 static void snd_hda_codec_free(struct hda_codec *codec)
835 {
836         if (!codec)
837                 return;
838         restore_init_pincfgs(codec);
839 #ifdef CONFIG_SND_HDA_POWER_SAVE
840         cancel_delayed_work(&codec->power_work);
841         flush_workqueue(codec->bus->workq);
842 #endif
843         list_del(&codec->list);
844         snd_array_free(&codec->mixers);
845         codec->bus->caddr_tbl[codec->addr] = NULL;
846         if (codec->patch_ops.free)
847                 codec->patch_ops.free(codec);
848         module_put(codec->owner);
849         free_hda_cache(&codec->amp_cache);
850         free_hda_cache(&codec->cmd_cache);
851         kfree(codec->name);
852         kfree(codec->modelname);
853         kfree(codec->wcaps);
854         kfree(codec);
855 }
856
857 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
858                                 unsigned int power_state);
859
860 /**
861  * snd_hda_codec_new - create a HDA codec
862  * @bus: the bus to assign
863  * @codec_addr: the codec address
864  * @codecp: the pointer to store the generated codec
865  *
866  * Returns 0 if successful, or a negative error code.
867  */
868 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
869                                     int do_init, struct hda_codec **codecp)
870 {
871         struct hda_codec *codec;
872         char component[31];
873         int err;
874
875         if (snd_BUG_ON(!bus))
876                 return -EINVAL;
877         if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
878                 return -EINVAL;
879
880         if (bus->caddr_tbl[codec_addr]) {
881                 snd_printk(KERN_ERR "hda_codec: "
882                            "address 0x%x is already occupied\n", codec_addr);
883                 return -EBUSY;
884         }
885
886         codec = kzalloc(sizeof(*codec), GFP_KERNEL);
887         if (codec == NULL) {
888                 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
889                 return -ENOMEM;
890         }
891
892         codec->bus = bus;
893         codec->addr = codec_addr;
894         mutex_init(&codec->spdif_mutex);
895         mutex_init(&codec->control_mutex);
896         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
897         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
898         snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
899         snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
900         snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
901         if (codec->bus->modelname) {
902                 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
903                 if (!codec->modelname) {
904                         snd_hda_codec_free(codec);
905                         return -ENODEV;
906                 }
907         }
908
909 #ifdef CONFIG_SND_HDA_POWER_SAVE
910         INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
911         /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
912          * the caller has to power down appropriatley after initialization
913          * phase.
914          */
915         hda_keep_power_on(codec);
916 #endif
917
918         list_add_tail(&codec->list, &bus->codec_list);
919         bus->caddr_tbl[codec_addr] = codec;
920
921         codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
922                                               AC_PAR_VENDOR_ID);
923         if (codec->vendor_id == -1)
924                 /* read again, hopefully the access method was corrected
925                  * in the last read...
926                  */
927                 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
928                                                       AC_PAR_VENDOR_ID);
929         codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
930                                                  AC_PAR_SUBSYSTEM_ID);
931         codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
932                                                 AC_PAR_REV_ID);
933
934         setup_fg_nodes(codec);
935         if (!codec->afg && !codec->mfg) {
936                 snd_printdd("hda_codec: no AFG or MFG node found\n");
937                 err = -ENODEV;
938                 goto error;
939         }
940
941         err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
942         if (err < 0) {
943                 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
944                 goto error;
945         }
946         err = read_pin_defaults(codec);
947         if (err < 0)
948                 goto error;
949
950         if (!codec->subsystem_id) {
951                 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
952                 codec->subsystem_id =
953                         snd_hda_codec_read(codec, nid, 0,
954                                            AC_VERB_GET_SUBSYSTEM_ID, 0);
955         }
956         if (bus->modelname)
957                 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
958
959         /* power-up all before initialization */
960         hda_set_power_state(codec,
961                             codec->afg ? codec->afg : codec->mfg,
962                             AC_PWRST_D0);
963
964         if (do_init) {
965                 err = snd_hda_codec_configure(codec);
966                 if (err < 0)
967                         goto error;
968         }
969         snd_hda_codec_proc_new(codec);
970
971         snd_hda_create_hwdep(codec);
972
973         sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
974                 codec->subsystem_id, codec->revision_id);
975         snd_component_add(codec->bus->card, component);
976
977         if (codecp)
978                 *codecp = codec;
979         return 0;
980
981  error:
982         snd_hda_codec_free(codec);
983         return err;
984 }
985 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
986
987 int snd_hda_codec_configure(struct hda_codec *codec)
988 {
989         int err;
990
991         codec->preset = find_codec_preset(codec);
992         if (!codec->name) {
993                 err = get_codec_name(codec);
994                 if (err < 0)
995                         return err;
996         }
997         /* audio codec should override the mixer name */
998         if (codec->afg || !*codec->bus->card->mixername)
999                 strlcpy(codec->bus->card->mixername, codec->name,
1000                         sizeof(codec->bus->card->mixername));
1001
1002         if (is_generic_config(codec)) {
1003                 err = snd_hda_parse_generic_codec(codec);
1004                 goto patched;
1005         }
1006         if (codec->preset && codec->preset->patch) {
1007                 err = codec->preset->patch(codec);
1008                 goto patched;
1009         }
1010
1011         /* call the default parser */
1012         err = snd_hda_parse_generic_codec(codec);
1013         if (err < 0)
1014                 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1015
1016  patched:
1017         if (!err && codec->patch_ops.unsol_event)
1018                 err = init_unsol_queue(codec->bus);
1019         return err;
1020 }
1021
1022 /**
1023  * snd_hda_codec_setup_stream - set up the codec for streaming
1024  * @codec: the CODEC to set up
1025  * @nid: the NID to set up
1026  * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1027  * @channel_id: channel id to pass, zero based.
1028  * @format: stream format.
1029  */
1030 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1031                                 u32 stream_tag,
1032                                 int channel_id, int format)
1033 {
1034         if (!nid)
1035                 return;
1036
1037         snd_printdd("hda_codec_setup_stream: "
1038                     "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1039                     nid, stream_tag, channel_id, format);
1040         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1041                             (stream_tag << 4) | channel_id);
1042         msleep(1);
1043         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1044 }
1045 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1046
1047 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1048 {
1049         if (!nid)
1050                 return;
1051
1052         snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1053         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1054 #if 0 /* keep the format */
1055         msleep(1);
1056         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1057 #endif
1058 }
1059 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
1060
1061 /*
1062  * amp access functions
1063  */
1064
1065 /* FIXME: more better hash key? */
1066 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1067 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1068 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1069 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1070 #define INFO_AMP_CAPS   (1<<0)
1071 #define INFO_AMP_VOL(ch)        (1 << (1 + (ch)))
1072
1073 /* initialize the hash table */
1074 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1075                                      unsigned int record_size)
1076 {
1077         memset(cache, 0, sizeof(*cache));
1078         memset(cache->hash, 0xff, sizeof(cache->hash));
1079         snd_array_init(&cache->buf, record_size, 64);
1080 }
1081
1082 static void free_hda_cache(struct hda_cache_rec *cache)
1083 {
1084         snd_array_free(&cache->buf);
1085 }
1086
1087 /* query the hash.  allocate an entry if not found. */
1088 static struct hda_cache_head  *get_alloc_hash(struct hda_cache_rec *cache,
1089                                               u32 key)
1090 {
1091         u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1092         u16 cur = cache->hash[idx];
1093         struct hda_cache_head *info;
1094
1095         while (cur != 0xffff) {
1096                 info = snd_array_elem(&cache->buf, cur);
1097                 if (info->key == key)
1098                         return info;
1099                 cur = info->next;
1100         }
1101
1102         /* add a new hash entry */
1103         info = snd_array_new(&cache->buf);
1104         if (!info)
1105                 return NULL;
1106         cur = snd_array_index(&cache->buf, info);
1107         info->key = key;
1108         info->val = 0;
1109         info->next = cache->hash[idx];
1110         cache->hash[idx] = cur;
1111
1112         return info;
1113 }
1114
1115 /* query and allocate an amp hash entry */
1116 static inline struct hda_amp_info *
1117 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1118 {
1119         return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1120 }
1121
1122 /*
1123  * query AMP capabilities for the given widget and direction
1124  */
1125 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1126 {
1127         struct hda_amp_info *info;
1128
1129         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1130         if (!info)
1131                 return 0;
1132         if (!(info->head.val & INFO_AMP_CAPS)) {
1133                 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1134                         nid = codec->afg;
1135                 info->amp_caps = snd_hda_param_read(codec, nid,
1136                                                     direction == HDA_OUTPUT ?
1137                                                     AC_PAR_AMP_OUT_CAP :
1138                                                     AC_PAR_AMP_IN_CAP);
1139                 if (info->amp_caps)
1140                         info->head.val |= INFO_AMP_CAPS;
1141         }
1142         return info->amp_caps;
1143 }
1144 EXPORT_SYMBOL_HDA(query_amp_caps);
1145
1146 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1147                               unsigned int caps)
1148 {
1149         struct hda_amp_info *info;
1150
1151         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1152         if (!info)
1153                 return -EINVAL;
1154         info->amp_caps = caps;
1155         info->head.val |= INFO_AMP_CAPS;
1156         return 0;
1157 }
1158 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1159
1160 static unsigned int
1161 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1162                 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1163 {
1164         struct hda_amp_info *info;
1165
1166         info = get_alloc_amp_hash(codec, key);
1167         if (!info)
1168                 return 0;
1169         if (!info->head.val) {
1170                 info->head.val |= INFO_AMP_CAPS;
1171                 info->amp_caps = func(codec, nid);
1172         }
1173         return info->amp_caps;
1174 }
1175
1176 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1177 {
1178         return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1179 }
1180
1181 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1182 {
1183         return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1184                                read_pin_cap);
1185 }
1186 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1187
1188 /*
1189  * read the current volume to info
1190  * if the cache exists, read the cache value.
1191  */
1192 static unsigned int get_vol_mute(struct hda_codec *codec,
1193                                  struct hda_amp_info *info, hda_nid_t nid,
1194                                  int ch, int direction, int index)
1195 {
1196         u32 val, parm;
1197
1198         if (info->head.val & INFO_AMP_VOL(ch))
1199                 return info->vol[ch];
1200
1201         parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1202         parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1203         parm |= index;
1204         val = snd_hda_codec_read(codec, nid, 0,
1205                                  AC_VERB_GET_AMP_GAIN_MUTE, parm);
1206         info->vol[ch] = val & 0xff;
1207         info->head.val |= INFO_AMP_VOL(ch);
1208         return info->vol[ch];
1209 }
1210
1211 /*
1212  * write the current volume in info to the h/w and update the cache
1213  */
1214 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1215                          hda_nid_t nid, int ch, int direction, int index,
1216                          int val)
1217 {
1218         u32 parm;
1219
1220         parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1221         parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1222         parm |= index << AC_AMP_SET_INDEX_SHIFT;
1223         parm |= val;
1224         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1225         info->vol[ch] = val;
1226 }
1227
1228 /*
1229  * read AMP value.  The volume is between 0 to 0x7f, 0x80 = mute bit.
1230  */
1231 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1232                            int direction, int index)
1233 {
1234         struct hda_amp_info *info;
1235         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1236         if (!info)
1237                 return 0;
1238         return get_vol_mute(codec, info, nid, ch, direction, index);
1239 }
1240 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1241
1242 /*
1243  * update the AMP value, mask = bit mask to set, val = the value
1244  */
1245 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1246                              int direction, int idx, int mask, int val)
1247 {
1248         struct hda_amp_info *info;
1249
1250         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1251         if (!info)
1252                 return 0;
1253         val &= mask;
1254         val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1255         if (info->vol[ch] == val)
1256                 return 0;
1257         put_vol_mute(codec, info, nid, ch, direction, idx, val);
1258         return 1;
1259 }
1260 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1261
1262 /*
1263  * update the AMP stereo with the same mask and value
1264  */
1265 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1266                              int direction, int idx, int mask, int val)
1267 {
1268         int ch, ret = 0;
1269         for (ch = 0; ch < 2; ch++)
1270                 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1271                                                 idx, mask, val);
1272         return ret;
1273 }
1274 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1275
1276 #ifdef SND_HDA_NEEDS_RESUME
1277 /* resume the all amp commands from the cache */
1278 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1279 {
1280         struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1281         int i;
1282
1283         for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1284                 u32 key = buffer->head.key;
1285                 hda_nid_t nid;
1286                 unsigned int idx, dir, ch;
1287                 if (!key)
1288                         continue;
1289                 nid = key & 0xff;
1290                 idx = (key >> 16) & 0xff;
1291                 dir = (key >> 24) & 0xff;
1292                 for (ch = 0; ch < 2; ch++) {
1293                         if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1294                                 continue;
1295                         put_vol_mute(codec, buffer, nid, ch, dir, idx,
1296                                      buffer->vol[ch]);
1297                 }
1298         }
1299 }
1300 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1301 #endif /* SND_HDA_NEEDS_RESUME */
1302
1303 /* volume */
1304 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1305                                   struct snd_ctl_elem_info *uinfo)
1306 {
1307         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1308         u16 nid = get_amp_nid(kcontrol);
1309         u8 chs = get_amp_channels(kcontrol);
1310         int dir = get_amp_direction(kcontrol);
1311         unsigned int ofs = get_amp_offset(kcontrol);
1312         u32 caps;
1313
1314         caps = query_amp_caps(codec, nid, dir);
1315         /* num steps */
1316         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1317         if (!caps) {
1318                 printk(KERN_WARNING "hda_codec: "
1319                        "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1320                        kcontrol->id.name);
1321                 return -EINVAL;
1322         }
1323         if (ofs < caps)
1324                 caps -= ofs;
1325         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1326         uinfo->count = chs == 3 ? 2 : 1;
1327         uinfo->value.integer.min = 0;
1328         uinfo->value.integer.max = caps;
1329         return 0;
1330 }
1331 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1332
1333
1334 static inline unsigned int
1335 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1336                int ch, int dir, int idx, unsigned int ofs)
1337 {
1338         unsigned int val;
1339         val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1340         val &= HDA_AMP_VOLMASK;
1341         if (val >= ofs)
1342                 val -= ofs;
1343         else
1344                 val = 0;
1345         return val;
1346 }
1347
1348 static inline int
1349 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1350                  int ch, int dir, int idx, unsigned int ofs,
1351                  unsigned int val)
1352 {
1353         if (val > 0)
1354                 val += ofs;
1355         return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1356                                         HDA_AMP_VOLMASK, val);
1357 }
1358
1359 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1360                                  struct snd_ctl_elem_value *ucontrol)
1361 {
1362         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1363         hda_nid_t nid = get_amp_nid(kcontrol);
1364         int chs = get_amp_channels(kcontrol);
1365         int dir = get_amp_direction(kcontrol);
1366         int idx = get_amp_index(kcontrol);
1367         unsigned int ofs = get_amp_offset(kcontrol);
1368         long *valp = ucontrol->value.integer.value;
1369
1370         if (chs & 1)
1371                 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1372         if (chs & 2)
1373                 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1374         return 0;
1375 }
1376 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1377
1378 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1379                                  struct snd_ctl_elem_value *ucontrol)
1380 {
1381         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1382         hda_nid_t nid = get_amp_nid(kcontrol);
1383         int chs = get_amp_channels(kcontrol);
1384         int dir = get_amp_direction(kcontrol);
1385         int idx = get_amp_index(kcontrol);
1386         unsigned int ofs = get_amp_offset(kcontrol);
1387         long *valp = ucontrol->value.integer.value;
1388         int change = 0;
1389
1390         snd_hda_power_up(codec);
1391         if (chs & 1) {
1392                 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1393                 valp++;
1394         }
1395         if (chs & 2)
1396                 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1397         snd_hda_power_down(codec);
1398         return change;
1399 }
1400 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1401
1402 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1403                           unsigned int size, unsigned int __user *_tlv)
1404 {
1405         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1406         hda_nid_t nid = get_amp_nid(kcontrol);
1407         int dir = get_amp_direction(kcontrol);
1408         unsigned int ofs = get_amp_offset(kcontrol);
1409         u32 caps, val1, val2;
1410
1411         if (size < 4 * sizeof(unsigned int))
1412                 return -ENOMEM;
1413         caps = query_amp_caps(codec, nid, dir);
1414         val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1415         val2 = (val2 + 1) * 25;
1416         val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1417         val1 += ofs;
1418         val1 = ((int)val1) * ((int)val2);
1419         if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1420                 return -EFAULT;
1421         if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1422                 return -EFAULT;
1423         if (put_user(val1, _tlv + 2))
1424                 return -EFAULT;
1425         if (put_user(val2, _tlv + 3))
1426                 return -EFAULT;
1427         return 0;
1428 }
1429 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1430
1431 /*
1432  * set (static) TLV for virtual master volume; recalculated as max 0dB
1433  */
1434 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1435                              unsigned int *tlv)
1436 {
1437         u32 caps;
1438         int nums, step;
1439
1440         caps = query_amp_caps(codec, nid, dir);
1441         nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1442         step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1443         step = (step + 1) * 25;
1444         tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1445         tlv[1] = 2 * sizeof(unsigned int);
1446         tlv[2] = -nums * step;
1447         tlv[3] = step;
1448 }
1449 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1450
1451 /* find a mixer control element with the given name */
1452 static struct snd_kcontrol *
1453 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1454                         const char *name, int idx)
1455 {
1456         struct snd_ctl_elem_id id;
1457         memset(&id, 0, sizeof(id));
1458         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1459         id.index = idx;
1460         if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1461                 return NULL;
1462         strcpy(id.name, name);
1463         return snd_ctl_find_id(codec->bus->card, &id);
1464 }
1465
1466 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1467                                             const char *name)
1468 {
1469         return _snd_hda_find_mixer_ctl(codec, name, 0);
1470 }
1471 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1472
1473 /* Add a control element and assign to the codec */
1474 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1475 {
1476         int err;
1477         struct snd_kcontrol **knewp;
1478
1479         err = snd_ctl_add(codec->bus->card, kctl);
1480         if (err < 0)
1481                 return err;
1482         knewp = snd_array_new(&codec->mixers);
1483         if (!knewp)
1484                 return -ENOMEM;
1485         *knewp = kctl;
1486         return 0;
1487 }
1488 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1489
1490 /* Clear all controls assigned to the given codec */
1491 void snd_hda_ctls_clear(struct hda_codec *codec)
1492 {
1493         int i;
1494         struct snd_kcontrol **kctls = codec->mixers.list;
1495         for (i = 0; i < codec->mixers.used; i++)
1496                 snd_ctl_remove(codec->bus->card, kctls[i]);
1497         snd_array_free(&codec->mixers);
1498 }
1499
1500 /* pseudo device locking
1501  * toggle card->shutdown to allow/disallow the device access (as a hack)
1502  */
1503 static int hda_lock_devices(struct snd_card *card)
1504 {
1505         spin_lock(&card->files_lock);
1506         if (card->shutdown) {
1507                 spin_unlock(&card->files_lock);
1508                 return -EINVAL;
1509         }
1510         card->shutdown = 1;
1511         spin_unlock(&card->files_lock);
1512         return 0;
1513 }
1514
1515 static void hda_unlock_devices(struct snd_card *card)
1516 {
1517         spin_lock(&card->files_lock);
1518         card->shutdown = 0;
1519         spin_unlock(&card->files_lock);
1520 }
1521
1522 int snd_hda_codec_reset(struct hda_codec *codec)
1523 {
1524         struct snd_card *card = codec->bus->card;
1525         int i, pcm;
1526
1527         if (hda_lock_devices(card) < 0)
1528                 return -EBUSY;
1529         /* check whether the codec isn't used by any mixer or PCM streams */
1530         if (!list_empty(&card->ctl_files)) {
1531                 hda_unlock_devices(card);
1532                 return -EBUSY;
1533         }
1534         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1535                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1536                 if (!cpcm->pcm)
1537                         continue;
1538                 if (cpcm->pcm->streams[0].substream_opened ||
1539                     cpcm->pcm->streams[1].substream_opened) {
1540                         hda_unlock_devices(card);
1541                         return -EBUSY;
1542                 }
1543         }
1544
1545         /* OK, let it free */
1546
1547 #ifdef CONFIG_SND_HDA_POWER_SAVE
1548         cancel_delayed_work(&codec->power_work);
1549         flush_workqueue(codec->bus->workq);
1550 #endif
1551         snd_hda_ctls_clear(codec);
1552         /* relase PCMs */
1553         for (i = 0; i < codec->num_pcms; i++) {
1554                 if (codec->pcm_info[i].pcm) {
1555                         snd_device_free(card, codec->pcm_info[i].pcm);
1556                         clear_bit(codec->pcm_info[i].device,
1557                                   codec->bus->pcm_dev_bits);
1558                 }
1559         }
1560         if (codec->patch_ops.free)
1561                 codec->patch_ops.free(codec);
1562         codec->proc_widget_hook = NULL;
1563         codec->spec = NULL;
1564         free_hda_cache(&codec->amp_cache);
1565         free_hda_cache(&codec->cmd_cache);
1566         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1567         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1568         /* free only driver_pins so that init_pins + user_pins are restored */
1569         snd_array_free(&codec->driver_pins);
1570         restore_pincfgs(codec);
1571         codec->num_pcms = 0;
1572         codec->pcm_info = NULL;
1573         codec->preset = NULL;
1574         memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1575         codec->slave_dig_outs = NULL;
1576         codec->spdif_status_reset = 0;
1577         module_put(codec->owner);
1578         codec->owner = NULL;
1579
1580         /* allow device access again */
1581         hda_unlock_devices(card);
1582         return 0;
1583 }
1584
1585 /* create a virtual master control and add slaves */
1586 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1587                         unsigned int *tlv, const char **slaves)
1588 {
1589         struct snd_kcontrol *kctl;
1590         const char **s;
1591         int err;
1592
1593         for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1594                 ;
1595         if (!*s) {
1596                 snd_printdd("No slave found for %s\n", name);
1597                 return 0;
1598         }
1599         kctl = snd_ctl_make_virtual_master(name, tlv);
1600         if (!kctl)
1601                 return -ENOMEM;
1602         err = snd_hda_ctl_add(codec, kctl);
1603         if (err < 0)
1604                 return err;
1605         
1606         for (s = slaves; *s; s++) {
1607                 struct snd_kcontrol *sctl;
1608                 int i = 0;
1609                 for (;;) {
1610                         sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1611                         if (!sctl) {
1612                                 if (!i)
1613                                         snd_printdd("Cannot find slave %s, "
1614                                                     "skipped\n", *s);
1615                                 break;
1616                         }
1617                         err = snd_ctl_add_slave(kctl, sctl);
1618                         if (err < 0)
1619                                 return err;
1620                         i++;
1621                 }
1622         }
1623         return 0;
1624 }
1625 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1626
1627 /* switch */
1628 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1629                                   struct snd_ctl_elem_info *uinfo)
1630 {
1631         int chs = get_amp_channels(kcontrol);
1632
1633         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1634         uinfo->count = chs == 3 ? 2 : 1;
1635         uinfo->value.integer.min = 0;
1636         uinfo->value.integer.max = 1;
1637         return 0;
1638 }
1639 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1640
1641 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1642                                  struct snd_ctl_elem_value *ucontrol)
1643 {
1644         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1645         hda_nid_t nid = get_amp_nid(kcontrol);
1646         int chs = get_amp_channels(kcontrol);
1647         int dir = get_amp_direction(kcontrol);
1648         int idx = get_amp_index(kcontrol);
1649         long *valp = ucontrol->value.integer.value;
1650
1651         if (chs & 1)
1652                 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1653                            HDA_AMP_MUTE) ? 0 : 1;
1654         if (chs & 2)
1655                 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1656                          HDA_AMP_MUTE) ? 0 : 1;
1657         return 0;
1658 }
1659 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1660
1661 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1662                                  struct snd_ctl_elem_value *ucontrol)
1663 {
1664         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1665         hda_nid_t nid = get_amp_nid(kcontrol);
1666         int chs = get_amp_channels(kcontrol);
1667         int dir = get_amp_direction(kcontrol);
1668         int idx = get_amp_index(kcontrol);
1669         long *valp = ucontrol->value.integer.value;
1670         int change = 0;
1671
1672         snd_hda_power_up(codec);
1673         if (chs & 1) {
1674                 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1675                                                   HDA_AMP_MUTE,
1676                                                   *valp ? 0 : HDA_AMP_MUTE);
1677                 valp++;
1678         }
1679         if (chs & 2)
1680                 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1681                                                    HDA_AMP_MUTE,
1682                                                    *valp ? 0 : HDA_AMP_MUTE);
1683 #ifdef CONFIG_SND_HDA_POWER_SAVE
1684         if (codec->patch_ops.check_power_status)
1685                 codec->patch_ops.check_power_status(codec, nid);
1686 #endif
1687         snd_hda_power_down(codec);
1688         return change;
1689 }
1690 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1691
1692 /*
1693  * bound volume controls
1694  *
1695  * bind multiple volumes (# indices, from 0)
1696  */
1697
1698 #define AMP_VAL_IDX_SHIFT       19
1699 #define AMP_VAL_IDX_MASK        (0x0f<<19)
1700
1701 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1702                                   struct snd_ctl_elem_value *ucontrol)
1703 {
1704         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1705         unsigned long pval;
1706         int err;
1707
1708         mutex_lock(&codec->control_mutex);
1709         pval = kcontrol->private_value;
1710         kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1711         err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1712         kcontrol->private_value = pval;
1713         mutex_unlock(&codec->control_mutex);
1714         return err;
1715 }
1716 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1717
1718 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1719                                   struct snd_ctl_elem_value *ucontrol)
1720 {
1721         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1722         unsigned long pval;
1723         int i, indices, err = 0, change = 0;
1724
1725         mutex_lock(&codec->control_mutex);
1726         pval = kcontrol->private_value;
1727         indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1728         for (i = 0; i < indices; i++) {
1729                 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1730                         (i << AMP_VAL_IDX_SHIFT);
1731                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1732                 if (err < 0)
1733                         break;
1734                 change |= err;
1735         }
1736         kcontrol->private_value = pval;
1737         mutex_unlock(&codec->control_mutex);
1738         return err < 0 ? err : change;
1739 }
1740 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1741
1742 /*
1743  * generic bound volume/swtich controls
1744  */
1745 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1746                                  struct snd_ctl_elem_info *uinfo)
1747 {
1748         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1749         struct hda_bind_ctls *c;
1750         int err;
1751
1752         mutex_lock(&codec->control_mutex);
1753         c = (struct hda_bind_ctls *)kcontrol->private_value;
1754         kcontrol->private_value = *c->values;
1755         err = c->ops->info(kcontrol, uinfo);
1756         kcontrol->private_value = (long)c;
1757         mutex_unlock(&codec->control_mutex);
1758         return err;
1759 }
1760 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1761
1762 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1763                                 struct snd_ctl_elem_value *ucontrol)
1764 {
1765         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1766         struct hda_bind_ctls *c;
1767         int err;
1768
1769         mutex_lock(&codec->control_mutex);
1770         c = (struct hda_bind_ctls *)kcontrol->private_value;
1771         kcontrol->private_value = *c->values;
1772         err = c->ops->get(kcontrol, ucontrol);
1773         kcontrol->private_value = (long)c;
1774         mutex_unlock(&codec->control_mutex);
1775         return err;
1776 }
1777 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1778
1779 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1780                                 struct snd_ctl_elem_value *ucontrol)
1781 {
1782         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1783         struct hda_bind_ctls *c;
1784         unsigned long *vals;
1785         int err = 0, change = 0;
1786
1787         mutex_lock(&codec->control_mutex);
1788         c = (struct hda_bind_ctls *)kcontrol->private_value;
1789         for (vals = c->values; *vals; vals++) {
1790                 kcontrol->private_value = *vals;
1791                 err = c->ops->put(kcontrol, ucontrol);
1792                 if (err < 0)
1793                         break;
1794                 change |= err;
1795         }
1796         kcontrol->private_value = (long)c;
1797         mutex_unlock(&codec->control_mutex);
1798         return err < 0 ? err : change;
1799 }
1800 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1801
1802 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1803                            unsigned int size, unsigned int __user *tlv)
1804 {
1805         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1806         struct hda_bind_ctls *c;
1807         int err;
1808
1809         mutex_lock(&codec->control_mutex);
1810         c = (struct hda_bind_ctls *)kcontrol->private_value;
1811         kcontrol->private_value = *c->values;
1812         err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1813         kcontrol->private_value = (long)c;
1814         mutex_unlock(&codec->control_mutex);
1815         return err;
1816 }
1817 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1818
1819 struct hda_ctl_ops snd_hda_bind_vol = {
1820         .info = snd_hda_mixer_amp_volume_info,
1821         .get = snd_hda_mixer_amp_volume_get,
1822         .put = snd_hda_mixer_amp_volume_put,
1823         .tlv = snd_hda_mixer_amp_tlv
1824 };
1825 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1826
1827 struct hda_ctl_ops snd_hda_bind_sw = {
1828         .info = snd_hda_mixer_amp_switch_info,
1829         .get = snd_hda_mixer_amp_switch_get,
1830         .put = snd_hda_mixer_amp_switch_put,
1831         .tlv = snd_hda_mixer_amp_tlv
1832 };
1833 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1834
1835 /*
1836  * SPDIF out controls
1837  */
1838
1839 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1840                                    struct snd_ctl_elem_info *uinfo)
1841 {
1842         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1843         uinfo->count = 1;
1844         return 0;
1845 }
1846
1847 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1848                                    struct snd_ctl_elem_value *ucontrol)
1849 {
1850         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1851                                            IEC958_AES0_NONAUDIO |
1852                                            IEC958_AES0_CON_EMPHASIS_5015 |
1853                                            IEC958_AES0_CON_NOT_COPYRIGHT;
1854         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1855                                            IEC958_AES1_CON_ORIGINAL;
1856         return 0;
1857 }
1858
1859 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1860                                    struct snd_ctl_elem_value *ucontrol)
1861 {
1862         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1863                                            IEC958_AES0_NONAUDIO |
1864                                            IEC958_AES0_PRO_EMPHASIS_5015;
1865         return 0;
1866 }
1867
1868 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1869                                      struct snd_ctl_elem_value *ucontrol)
1870 {
1871         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1872
1873         ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1874         ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1875         ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1876         ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1877
1878         return 0;
1879 }
1880
1881 /* convert from SPDIF status bits to HDA SPDIF bits
1882  * bit 0 (DigEn) is always set zero (to be filled later)
1883  */
1884 static unsigned short convert_from_spdif_status(unsigned int sbits)
1885 {
1886         unsigned short val = 0;
1887
1888         if (sbits & IEC958_AES0_PROFESSIONAL)
1889                 val |= AC_DIG1_PROFESSIONAL;
1890         if (sbits & IEC958_AES0_NONAUDIO)
1891                 val |= AC_DIG1_NONAUDIO;
1892         if (sbits & IEC958_AES0_PROFESSIONAL) {
1893                 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1894                     IEC958_AES0_PRO_EMPHASIS_5015)
1895                         val |= AC_DIG1_EMPHASIS;
1896         } else {
1897                 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1898                     IEC958_AES0_CON_EMPHASIS_5015)
1899                         val |= AC_DIG1_EMPHASIS;
1900                 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1901                         val |= AC_DIG1_COPYRIGHT;
1902                 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1903                         val |= AC_DIG1_LEVEL;
1904                 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1905         }
1906         return val;
1907 }
1908
1909 /* convert to SPDIF status bits from HDA SPDIF bits
1910  */
1911 static unsigned int convert_to_spdif_status(unsigned short val)
1912 {
1913         unsigned int sbits = 0;
1914
1915         if (val & AC_DIG1_NONAUDIO)
1916                 sbits |= IEC958_AES0_NONAUDIO;
1917         if (val & AC_DIG1_PROFESSIONAL)
1918                 sbits |= IEC958_AES0_PROFESSIONAL;
1919         if (sbits & IEC958_AES0_PROFESSIONAL) {
1920                 if (sbits & AC_DIG1_EMPHASIS)
1921                         sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1922         } else {
1923                 if (val & AC_DIG1_EMPHASIS)
1924                         sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1925                 if (!(val & AC_DIG1_COPYRIGHT))
1926                         sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1927                 if (val & AC_DIG1_LEVEL)
1928                         sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1929                 sbits |= val & (0x7f << 8);
1930         }
1931         return sbits;
1932 }
1933
1934 /* set digital convert verbs both for the given NID and its slaves */
1935 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1936                         int verb, int val)
1937 {
1938         hda_nid_t *d;
1939
1940         snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1941         d = codec->slave_dig_outs;
1942         if (!d)
1943                 return;
1944         for (; *d; d++)
1945                 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1946 }
1947
1948 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1949                                        int dig1, int dig2)
1950 {
1951         if (dig1 != -1)
1952                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1953         if (dig2 != -1)
1954                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1955 }
1956
1957 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1958                                      struct snd_ctl_elem_value *ucontrol)
1959 {
1960         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1961         hda_nid_t nid = kcontrol->private_value;
1962         unsigned short val;
1963         int change;
1964
1965         mutex_lock(&codec->spdif_mutex);
1966         codec->spdif_status = ucontrol->value.iec958.status[0] |
1967                 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1968                 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1969                 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1970         val = convert_from_spdif_status(codec->spdif_status);
1971         val |= codec->spdif_ctls & 1;
1972         change = codec->spdif_ctls != val;
1973         codec->spdif_ctls = val;
1974
1975         if (change)
1976                 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1977
1978         mutex_unlock(&codec->spdif_mutex);
1979         return change;
1980 }
1981
1982 #define snd_hda_spdif_out_switch_info   snd_ctl_boolean_mono_info
1983
1984 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1985                                         struct snd_ctl_elem_value *ucontrol)
1986 {
1987         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1988
1989         ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1990         return 0;
1991 }
1992
1993 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1994                                         struct snd_ctl_elem_value *ucontrol)
1995 {
1996         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1997         hda_nid_t nid = kcontrol->private_value;
1998         unsigned short val;
1999         int change;
2000
2001         mutex_lock(&codec->spdif_mutex);
2002         val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2003         if (ucontrol->value.integer.value[0])
2004                 val |= AC_DIG1_ENABLE;
2005         change = codec->spdif_ctls != val;
2006         if (change) {
2007                 codec->spdif_ctls = val;
2008                 set_dig_out_convert(codec, nid, val & 0xff, -1);
2009                 /* unmute amp switch (if any) */
2010                 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2011                     (val & AC_DIG1_ENABLE))
2012                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2013                                                  HDA_AMP_MUTE, 0);
2014         }
2015         mutex_unlock(&codec->spdif_mutex);
2016         return change;
2017 }
2018
2019 static struct snd_kcontrol_new dig_mixes[] = {
2020         {
2021                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2022                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2023                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2024                 .info = snd_hda_spdif_mask_info,
2025                 .get = snd_hda_spdif_cmask_get,
2026         },
2027         {
2028                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2029                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2030                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2031                 .info = snd_hda_spdif_mask_info,
2032                 .get = snd_hda_spdif_pmask_get,
2033         },
2034         {
2035                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2036                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2037                 .info = snd_hda_spdif_mask_info,
2038                 .get = snd_hda_spdif_default_get,
2039                 .put = snd_hda_spdif_default_put,
2040         },
2041         {
2042                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2043                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2044                 .info = snd_hda_spdif_out_switch_info,
2045                 .get = snd_hda_spdif_out_switch_get,
2046                 .put = snd_hda_spdif_out_switch_put,
2047         },
2048         { } /* end */
2049 };
2050
2051 #define SPDIF_MAX_IDX   4       /* 4 instances should be enough to probe */
2052
2053 /**
2054  * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2055  * @codec: the HDA codec
2056  * @nid: audio out widget NID
2057  *
2058  * Creates controls related with the SPDIF output.
2059  * Called from each patch supporting the SPDIF out.
2060  *
2061  * Returns 0 if successful, or a negative error code.
2062  */
2063 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2064 {
2065         int err;
2066         struct snd_kcontrol *kctl;
2067         struct snd_kcontrol_new *dig_mix;
2068         int idx;
2069
2070         for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2071                 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2072                                              idx))
2073                         break;
2074         }
2075         if (idx >= SPDIF_MAX_IDX) {
2076                 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2077                 return -EBUSY;
2078         }
2079         for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2080                 kctl = snd_ctl_new1(dig_mix, codec);
2081                 if (!kctl)
2082                         return -ENOMEM;
2083                 kctl->id.index = idx;
2084                 kctl->private_value = nid;
2085                 err = snd_hda_ctl_add(codec, kctl);
2086                 if (err < 0)
2087                         return err;
2088         }
2089         codec->spdif_ctls =
2090                 snd_hda_codec_read(codec, nid, 0,
2091                                    AC_VERB_GET_DIGI_CONVERT_1, 0);
2092         codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2093         return 0;
2094 }
2095 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2096
2097 /*
2098  * SPDIF sharing with analog output
2099  */
2100 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2101                               struct snd_ctl_elem_value *ucontrol)
2102 {
2103         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2104         ucontrol->value.integer.value[0] = mout->share_spdif;
2105         return 0;
2106 }
2107
2108 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2109                               struct snd_ctl_elem_value *ucontrol)
2110 {
2111         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2112         mout->share_spdif = !!ucontrol->value.integer.value[0];
2113         return 0;
2114 }
2115
2116 static struct snd_kcontrol_new spdif_share_sw = {
2117         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2118         .name = "IEC958 Default PCM Playback Switch",
2119         .info = snd_ctl_boolean_mono_info,
2120         .get = spdif_share_sw_get,
2121         .put = spdif_share_sw_put,
2122 };
2123
2124 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2125                                   struct hda_multi_out *mout)
2126 {
2127         if (!mout->dig_out_nid)
2128                 return 0;
2129         /* ATTENTION: here mout is passed as private_data, instead of codec */
2130         return snd_hda_ctl_add(codec,
2131                            snd_ctl_new1(&spdif_share_sw, mout));
2132 }
2133 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2134
2135 /*
2136  * SPDIF input
2137  */
2138
2139 #define snd_hda_spdif_in_switch_info    snd_hda_spdif_out_switch_info
2140
2141 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2142                                        struct snd_ctl_elem_value *ucontrol)
2143 {
2144         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2145
2146         ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2147         return 0;
2148 }
2149
2150 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2151                                        struct snd_ctl_elem_value *ucontrol)
2152 {
2153         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2154         hda_nid_t nid = kcontrol->private_value;
2155         unsigned int val = !!ucontrol->value.integer.value[0];
2156         int change;
2157
2158         mutex_lock(&codec->spdif_mutex);
2159         change = codec->spdif_in_enable != val;
2160         if (change) {
2161                 codec->spdif_in_enable = val;
2162                 snd_hda_codec_write_cache(codec, nid, 0,
2163                                           AC_VERB_SET_DIGI_CONVERT_1, val);
2164         }
2165         mutex_unlock(&codec->spdif_mutex);
2166         return change;
2167 }
2168
2169 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2170                                        struct snd_ctl_elem_value *ucontrol)
2171 {
2172         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2173         hda_nid_t nid = kcontrol->private_value;
2174         unsigned short val;
2175         unsigned int sbits;
2176
2177         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2178         sbits = convert_to_spdif_status(val);
2179         ucontrol->value.iec958.status[0] = sbits;
2180         ucontrol->value.iec958.status[1] = sbits >> 8;
2181         ucontrol->value.iec958.status[2] = sbits >> 16;
2182         ucontrol->value.iec958.status[3] = sbits >> 24;
2183         return 0;
2184 }
2185
2186 static struct snd_kcontrol_new dig_in_ctls[] = {
2187         {
2188                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2189                 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2190                 .info = snd_hda_spdif_in_switch_info,
2191                 .get = snd_hda_spdif_in_switch_get,
2192                 .put = snd_hda_spdif_in_switch_put,
2193         },
2194         {
2195                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2196                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2197                 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2198                 .info = snd_hda_spdif_mask_info,
2199                 .get = snd_hda_spdif_in_status_get,
2200         },
2201         { } /* end */
2202 };
2203
2204 /**
2205  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2206  * @codec: the HDA codec
2207  * @nid: audio in widget NID
2208  *
2209  * Creates controls related with the SPDIF input.
2210  * Called from each patch supporting the SPDIF in.
2211  *
2212  * Returns 0 if successful, or a negative error code.
2213  */
2214 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2215 {
2216         int err;
2217         struct snd_kcontrol *kctl;
2218         struct snd_kcontrol_new *dig_mix;
2219         int idx;
2220
2221         for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2222                 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2223                                              idx))
2224                         break;
2225         }
2226         if (idx >= SPDIF_MAX_IDX) {
2227                 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2228                 return -EBUSY;
2229         }
2230         for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2231                 kctl = snd_ctl_new1(dig_mix, codec);
2232                 if (!kctl)
2233                         return -ENOMEM;
2234                 kctl->private_value = nid;
2235                 err = snd_hda_ctl_add(codec, kctl);
2236                 if (err < 0)
2237                         return err;
2238         }
2239         codec->spdif_in_enable =
2240                 snd_hda_codec_read(codec, nid, 0,
2241                                    AC_VERB_GET_DIGI_CONVERT_1, 0) &
2242                 AC_DIG1_ENABLE;
2243         return 0;
2244 }
2245 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2246
2247 #ifdef SND_HDA_NEEDS_RESUME
2248 /*
2249  * command cache
2250  */
2251
2252 /* build a 32bit cache key with the widget id and the command parameter */
2253 #define build_cmd_cache_key(nid, verb)  ((verb << 8) | nid)
2254 #define get_cmd_cache_nid(key)          ((key) & 0xff)
2255 #define get_cmd_cache_cmd(key)          (((key) >> 8) & 0xffff)
2256
2257 /**
2258  * snd_hda_codec_write_cache - send a single command with caching
2259  * @codec: the HDA codec
2260  * @nid: NID to send the command
2261  * @direct: direct flag
2262  * @verb: the verb to send
2263  * @parm: the parameter for the verb
2264  *
2265  * Send a single command without waiting for response.
2266  *
2267  * Returns 0 if successful, or a negative error code.
2268  */
2269 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2270                               int direct, unsigned int verb, unsigned int parm)
2271 {
2272         struct hda_bus *bus = codec->bus;
2273         unsigned int res;
2274         int err;
2275
2276         res = make_codec_cmd(codec, nid, direct, verb, parm);
2277         snd_hda_power_up(codec);
2278         mutex_lock(&bus->cmd_mutex);
2279         err = bus->ops.command(bus, res);
2280         if (!err) {
2281                 struct hda_cache_head *c;
2282                 u32 key;
2283                 /* parm may contain the verb stuff for get/set amp */
2284                 verb = verb | (parm >> 8);
2285                 parm &= 0xff;
2286                 key = build_cmd_cache_key(nid, verb);
2287                 c = get_alloc_hash(&codec->cmd_cache, key);
2288                 if (c)
2289                         c->val = parm;
2290         }
2291         mutex_unlock(&bus->cmd_mutex);
2292         snd_hda_power_down(codec);
2293         return err;
2294 }
2295 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2296
2297 /* resume the all commands from the cache */
2298 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2299 {
2300         struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2301         int i;
2302
2303         for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2304                 u32 key = buffer->key;
2305                 if (!key)
2306                         continue;
2307                 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2308                                     get_cmd_cache_cmd(key), buffer->val);
2309         }
2310 }
2311 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2312
2313 /**
2314  * snd_hda_sequence_write_cache - sequence writes with caching
2315  * @codec: the HDA codec
2316  * @seq: VERB array to send
2317  *
2318  * Send the commands sequentially from the given array.
2319  * Thte commands are recorded on cache for power-save and resume.
2320  * The array must be terminated with NID=0.
2321  */
2322 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2323                                   const struct hda_verb *seq)
2324 {
2325         for (; seq->nid; seq++)
2326                 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2327                                           seq->param);
2328 }
2329 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2330 #endif /* SND_HDA_NEEDS_RESUME */
2331
2332 /*
2333  * set power state of the codec
2334  */
2335 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2336                                 unsigned int power_state)
2337 {
2338         hda_nid_t nid;
2339         int i;
2340
2341         snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2342                             power_state);
2343         msleep(10); /* partial workaround for "azx_get_response timeout" */
2344
2345         nid = codec->start_nid;
2346         for (i = 0; i < codec->num_nodes; i++, nid++) {
2347                 unsigned int wcaps = get_wcaps(codec, nid);
2348                 if (wcaps & AC_WCAP_POWER) {
2349                         unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2350                                 AC_WCAP_TYPE_SHIFT;
2351                         if (wid_type == AC_WID_PIN) {
2352                                 unsigned int pincap;
2353                                 /*
2354                                  * don't power down the widget if it controls
2355                                  * eapd and EAPD_BTLENABLE is set.
2356                                  */
2357                                 pincap = snd_hda_query_pin_caps(codec, nid);
2358                                 if (pincap & AC_PINCAP_EAPD) {
2359                                         int eapd = snd_hda_codec_read(codec,
2360                                                 nid, 0,
2361                                                 AC_VERB_GET_EAPD_BTLENABLE, 0);
2362                                         eapd &= 0x02;
2363                                         if (power_state == AC_PWRST_D3 && eapd)
2364                                                 continue;
2365                                 }
2366                         }
2367                         snd_hda_codec_write(codec, nid, 0,
2368                                             AC_VERB_SET_POWER_STATE,
2369                                             power_state);
2370                 }
2371         }
2372
2373         if (power_state == AC_PWRST_D0) {
2374                 unsigned long end_time;
2375                 int state;
2376                 msleep(10);
2377                 /* wait until the codec reachs to D0 */
2378                 end_time = jiffies + msecs_to_jiffies(500);
2379                 do {
2380                         state = snd_hda_codec_read(codec, fg, 0,
2381                                                    AC_VERB_GET_POWER_STATE, 0);
2382                         if (state == power_state)
2383                                 break;
2384                         msleep(1);
2385                 } while (time_after_eq(end_time, jiffies));
2386         }
2387 }
2388
2389 #ifdef CONFIG_SND_HDA_HWDEP
2390 /* execute additional init verbs */
2391 static void hda_exec_init_verbs(struct hda_codec *codec)
2392 {
2393         if (codec->init_verbs.list)
2394                 snd_hda_sequence_write(codec, codec->init_verbs.list);
2395 }
2396 #else
2397 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2398 #endif
2399
2400 #ifdef SND_HDA_NEEDS_RESUME
2401 /*
2402  * call suspend and power-down; used both from PM and power-save
2403  */
2404 static void hda_call_codec_suspend(struct hda_codec *codec)
2405 {
2406         if (codec->patch_ops.suspend)
2407                 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2408         hda_set_power_state(codec,
2409                             codec->afg ? codec->afg : codec->mfg,
2410                             AC_PWRST_D3);
2411 #ifdef CONFIG_SND_HDA_POWER_SAVE
2412         cancel_delayed_work(&codec->power_work);
2413         codec->power_on = 0;
2414         codec->power_transition = 0;
2415 #endif
2416 }
2417
2418 /*
2419  * kick up codec; used both from PM and power-save
2420  */
2421 static void hda_call_codec_resume(struct hda_codec *codec)
2422 {
2423         hda_set_power_state(codec,
2424                             codec->afg ? codec->afg : codec->mfg,
2425                             AC_PWRST_D0);
2426         restore_pincfgs(codec); /* restore all current pin configs */
2427         hda_exec_init_verbs(codec);
2428         if (codec->patch_ops.resume)
2429                 codec->patch_ops.resume(codec);
2430         else {
2431                 if (codec->patch_ops.init)
2432                         codec->patch_ops.init(codec);
2433                 snd_hda_codec_resume_amp(codec);
2434                 snd_hda_codec_resume_cache(codec);
2435         }
2436 }
2437 #endif /* SND_HDA_NEEDS_RESUME */
2438
2439
2440 /**
2441  * snd_hda_build_controls - build mixer controls
2442  * @bus: the BUS
2443  *
2444  * Creates mixer controls for each codec included in the bus.
2445  *
2446  * Returns 0 if successful, otherwise a negative error code.
2447  */
2448 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2449 {
2450         struct hda_codec *codec;
2451
2452         list_for_each_entry(codec, &bus->codec_list, list) {
2453                 int err = snd_hda_codec_build_controls(codec);
2454                 if (err < 0) {
2455                         printk(KERN_ERR "hda_codec: cannot build controls"
2456                                "for #%d (error %d)\n", codec->addr, err); 
2457                         err = snd_hda_codec_reset(codec);
2458                         if (err < 0) {
2459                                 printk(KERN_ERR
2460                                        "hda_codec: cannot revert codec\n");
2461                                 return err;
2462                         }
2463                 }
2464         }
2465         return 0;
2466 }
2467 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2468
2469 int snd_hda_codec_build_controls(struct hda_codec *codec)
2470 {
2471         int err = 0;
2472         hda_exec_init_verbs(codec);
2473         /* continue to initialize... */
2474         if (codec->patch_ops.init)
2475                 err = codec->patch_ops.init(codec);
2476         if (!err && codec->patch_ops.build_controls)
2477                 err = codec->patch_ops.build_controls(codec);
2478         if (err < 0)
2479                 return err;
2480         return 0;
2481 }
2482
2483 /*
2484  * stream formats
2485  */
2486 struct hda_rate_tbl {
2487         unsigned int hz;
2488         unsigned int alsa_bits;
2489         unsigned int hda_fmt;
2490 };
2491
2492 static struct hda_rate_tbl rate_bits[] = {
2493         /* rate in Hz, ALSA rate bitmask, HDA format value */
2494
2495         /* autodetected value used in snd_hda_query_supported_pcm */
2496         { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2497         { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2498         { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2499         { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2500         { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2501         { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2502         { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2503         { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2504         { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2505         { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2506         { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2507 #define AC_PAR_PCM_RATE_BITS    11
2508         /* up to bits 10, 384kHZ isn't supported properly */
2509
2510         /* not autodetected value */
2511         { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2512
2513         { 0 } /* terminator */
2514 };
2515
2516 /**
2517  * snd_hda_calc_stream_format - calculate format bitset
2518  * @rate: the sample rate
2519  * @channels: the number of channels
2520  * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2521  * @maxbps: the max. bps
2522  *
2523  * Calculate the format bitset from the given rate, channels and th PCM format.
2524  *
2525  * Return zero if invalid.
2526  */
2527 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2528                                         unsigned int channels,
2529                                         unsigned int format,
2530                                         unsigned int maxbps)
2531 {
2532         int i;
2533         unsigned int val = 0;
2534
2535         for (i = 0; rate_bits[i].hz; i++)
2536                 if (rate_bits[i].hz == rate) {
2537                         val = rate_bits[i].hda_fmt;
2538                         break;
2539                 }
2540         if (!rate_bits[i].hz) {
2541                 snd_printdd("invalid rate %d\n", rate);
2542                 return 0;
2543         }
2544
2545         if (channels == 0 || channels > 8) {
2546                 snd_printdd("invalid channels %d\n", channels);
2547                 return 0;
2548         }
2549         val |= channels - 1;
2550
2551         switch (snd_pcm_format_width(format)) {
2552         case 8:  val |= 0x00; break;
2553         case 16: val |= 0x10; break;
2554         case 20:
2555         case 24:
2556         case 32:
2557                 if (maxbps >= 32)
2558                         val |= 0x40;
2559                 else if (maxbps >= 24)
2560                         val |= 0x30;
2561                 else
2562                         val |= 0x20;
2563                 break;
2564         default:
2565                 snd_printdd("invalid format width %d\n",
2566                             snd_pcm_format_width(format));
2567                 return 0;
2568         }
2569
2570         return val;
2571 }
2572 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2573
2574 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2575 {
2576         unsigned int val = 0;
2577         if (nid != codec->afg &&
2578             (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2579                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2580         if (!val || val == -1)
2581                 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2582         if (!val || val == -1)
2583                 return 0;
2584         return val;
2585 }
2586
2587 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2588 {
2589         return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2590                                get_pcm_param);
2591 }
2592
2593 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2594 {
2595         unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2596         if (!streams || streams == -1)
2597                 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2598         if (!streams || streams == -1)
2599                 return 0;
2600         return streams;
2601 }
2602
2603 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2604 {
2605         return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2606                                get_stream_param);
2607 }
2608
2609 /**
2610  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2611  * @codec: the HDA codec
2612  * @nid: NID to query
2613  * @ratesp: the pointer to store the detected rate bitflags
2614  * @formatsp: the pointer to store the detected formats
2615  * @bpsp: the pointer to store the detected format widths
2616  *
2617  * Queries the supported PCM rates and formats.  The NULL @ratesp, @formatsp
2618  * or @bsps argument is ignored.
2619  *
2620  * Returns 0 if successful, otherwise a negative error code.
2621  */
2622 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2623                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2624 {
2625         unsigned int i, val, wcaps;
2626
2627         wcaps = get_wcaps(codec, nid);
2628         val = query_pcm_param(codec, nid);
2629
2630         if (ratesp) {
2631                 u32 rates = 0;
2632                 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2633                         if (val & (1 << i))
2634                                 rates |= rate_bits[i].alsa_bits;
2635                 }
2636                 if (rates == 0) {
2637                         snd_printk(KERN_ERR "hda_codec: rates == 0 "
2638                                    "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2639                                         nid, val,
2640                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2641                         return -EIO;
2642                 }
2643                 *ratesp = rates;
2644         }
2645
2646         if (formatsp || bpsp) {
2647                 u64 formats = 0;
2648                 unsigned int streams, bps;
2649
2650                 streams = query_stream_param(codec, nid);
2651                 if (!streams)
2652                         return -EIO;
2653
2654                 bps = 0;
2655                 if (streams & AC_SUPFMT_PCM) {
2656                         if (val & AC_SUPPCM_BITS_8) {
2657                                 formats |= SNDRV_PCM_FMTBIT_U8;
2658                                 bps = 8;
2659                         }
2660                         if (val & AC_SUPPCM_BITS_16) {
2661                                 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2662                                 bps = 16;
2663                         }
2664                         if (wcaps & AC_WCAP_DIGITAL) {
2665                                 if (val & AC_SUPPCM_BITS_32)
2666                                         formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2667                                 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2668                                         formats |= SNDRV_PCM_FMTBIT_S32_LE;
2669                                 if (val & AC_SUPPCM_BITS_24)
2670                                         bps = 24;
2671                                 else if (val & AC_SUPPCM_BITS_20)
2672                                         bps = 20;
2673                         } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2674                                           AC_SUPPCM_BITS_32)) {
2675                                 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2676                                 if (val & AC_SUPPCM_BITS_32)
2677                                         bps = 32;
2678                                 else if (val & AC_SUPPCM_BITS_24)
2679                                         bps = 24;
2680                                 else if (val & AC_SUPPCM_BITS_20)
2681                                         bps = 20;
2682                         }
2683                 }
2684                 else if (streams == AC_SUPFMT_FLOAT32) {
2685                         /* should be exclusive */
2686                         formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2687                         bps = 32;
2688                 } else if (streams == AC_SUPFMT_AC3) {
2689                         /* should be exclusive */
2690                         /* temporary hack: we have still no proper support
2691                          * for the direct AC3 stream...
2692                          */
2693                         formats |= SNDRV_PCM_FMTBIT_U8;
2694                         bps = 8;
2695                 }
2696                 if (formats == 0) {
2697                         snd_printk(KERN_ERR "hda_codec: formats == 0 "
2698                                    "(nid=0x%x, val=0x%x, ovrd=%i, "
2699                                    "streams=0x%x)\n",
2700                                         nid, val,
2701                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2702                                         streams);
2703                         return -EIO;
2704                 }
2705                 if (formatsp)
2706                         *formatsp = formats;
2707                 if (bpsp)
2708                         *bpsp = bps;
2709         }
2710
2711         return 0;
2712 }
2713
2714 /**
2715  * snd_hda_is_supported_format - check whether the given node supports
2716  * the format val
2717  *
2718  * Returns 1 if supported, 0 if not.
2719  */
2720 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2721                                 unsigned int format)
2722 {
2723         int i;
2724         unsigned int val = 0, rate, stream;
2725
2726         val = query_pcm_param(codec, nid);
2727         if (!val)
2728                 return 0;
2729
2730         rate = format & 0xff00;
2731         for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2732                 if (rate_bits[i].hda_fmt == rate) {
2733                         if (val & (1 << i))
2734                                 break;
2735                         return 0;
2736                 }
2737         if (i >= AC_PAR_PCM_RATE_BITS)
2738                 return 0;
2739
2740         stream = query_stream_param(codec, nid);
2741         if (!stream)
2742                 return 0;
2743
2744         if (stream & AC_SUPFMT_PCM) {
2745                 switch (format & 0xf0) {
2746                 case 0x00:
2747                         if (!(val & AC_SUPPCM_BITS_8))
2748                                 return 0;
2749                         break;
2750                 case 0x10:
2751                         if (!(val & AC_SUPPCM_BITS_16))
2752                                 return 0;
2753                         break;
2754                 case 0x20:
2755                         if (!(val & AC_SUPPCM_BITS_20))
2756                                 return 0;
2757                         break;
2758                 case 0x30:
2759                         if (!(val & AC_SUPPCM_BITS_24))
2760                                 return 0;
2761                         break;
2762                 case 0x40:
2763                         if (!(val & AC_SUPPCM_BITS_32))
2764                                 return 0;
2765                         break;
2766                 default:
2767                         return 0;
2768                 }
2769         } else {
2770                 /* FIXME: check for float32 and AC3? */
2771         }
2772
2773         return 1;
2774 }
2775 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2776
2777 /*
2778  * PCM stuff
2779  */
2780 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2781                                       struct hda_codec *codec,
2782                                       struct snd_pcm_substream *substream)
2783 {
2784         return 0;
2785 }
2786
2787 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2788                                    struct hda_codec *codec,
2789                                    unsigned int stream_tag,
2790                                    unsigned int format,
2791                                    struct snd_pcm_substream *substream)
2792 {
2793         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2794         return 0;
2795 }
2796
2797 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2798                                    struct hda_codec *codec,
2799                                    struct snd_pcm_substream *substream)
2800 {
2801         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2802         return 0;
2803 }
2804
2805 static int set_pcm_default_values(struct hda_codec *codec,
2806                                   struct hda_pcm_stream *info)
2807 {
2808         int err;
2809
2810         /* query support PCM information from the given NID */
2811         if (info->nid && (!info->rates || !info->formats)) {
2812                 err = snd_hda_query_supported_pcm(codec, info->nid,
2813                                 info->rates ? NULL : &info->rates,
2814                                 info->formats ? NULL : &info->formats,
2815                                 info->maxbps ? NULL : &info->maxbps);
2816                 if (err < 0)
2817                         return err;
2818         }
2819         if (info->ops.open == NULL)
2820                 info->ops.open = hda_pcm_default_open_close;
2821         if (info->ops.close == NULL)
2822                 info->ops.close = hda_pcm_default_open_close;
2823         if (info->ops.prepare == NULL) {
2824                 if (snd_BUG_ON(!info->nid))
2825                         return -EINVAL;
2826                 info->ops.prepare = hda_pcm_default_prepare;
2827         }
2828         if (info->ops.cleanup == NULL) {
2829                 if (snd_BUG_ON(!info->nid))
2830                         return -EINVAL;
2831                 info->ops.cleanup = hda_pcm_default_cleanup;
2832         }
2833         return 0;
2834 }
2835
2836 /*
2837  * get the empty PCM device number to assign
2838  */
2839 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2840 {
2841         static const char *dev_name[HDA_PCM_NTYPES] = {
2842                 "Audio", "SPDIF", "HDMI", "Modem"
2843         };
2844         /* starting device index for each PCM type */
2845         static int dev_idx[HDA_PCM_NTYPES] = {
2846                 [HDA_PCM_TYPE_AUDIO] = 0,
2847                 [HDA_PCM_TYPE_SPDIF] = 1,
2848                 [HDA_PCM_TYPE_HDMI] = 3,
2849                 [HDA_PCM_TYPE_MODEM] = 6
2850         };
2851         /* normal audio device indices; not linear to keep compatibility */
2852         static int audio_idx[4] = { 0, 2, 4, 5 };
2853         int i, dev;
2854
2855         switch (type) {
2856         case HDA_PCM_TYPE_AUDIO:
2857                 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2858                         dev = audio_idx[i];
2859                         if (!test_bit(dev, bus->pcm_dev_bits))
2860                                 goto ok;
2861                 }
2862                 snd_printk(KERN_WARNING "Too many audio devices\n");
2863                 return -EAGAIN;
2864         case HDA_PCM_TYPE_SPDIF:
2865         case HDA_PCM_TYPE_HDMI:
2866         case HDA_PCM_TYPE_MODEM:
2867                 dev = dev_idx[type];
2868                 if (test_bit(dev, bus->pcm_dev_bits)) {
2869                         snd_printk(KERN_WARNING "%s already defined\n",
2870                                    dev_name[type]);
2871                         return -EAGAIN;
2872                 }
2873                 break;
2874         default:
2875                 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2876                 return -EINVAL;
2877         }
2878  ok:
2879         set_bit(dev, bus->pcm_dev_bits);
2880         return dev;
2881 }
2882
2883 /*
2884  * attach a new PCM stream
2885  */
2886 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2887 {
2888         struct hda_bus *bus = codec->bus;
2889         struct hda_pcm_stream *info;
2890         int stream, err;
2891
2892         if (snd_BUG_ON(!pcm->name))
2893                 return -EINVAL;
2894         for (stream = 0; stream < 2; stream++) {
2895                 info = &pcm->stream[stream];
2896                 if (info->substreams) {
2897                         err = set_pcm_default_values(codec, info);
2898                         if (err < 0)
2899                                 return err;
2900                 }
2901         }
2902         return bus->ops.attach_pcm(bus, codec, pcm);
2903 }
2904
2905 /* assign all PCMs of the given codec */
2906 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2907 {
2908         unsigned int pcm;
2909         int err;
2910
2911         if (!codec->num_pcms) {
2912                 if (!codec->patch_ops.build_pcms)
2913                         return 0;
2914                 err = codec->patch_ops.build_pcms(codec);
2915                 if (err < 0) {
2916                         printk(KERN_ERR "hda_codec: cannot build PCMs"
2917                                "for #%d (error %d)\n", codec->addr, err); 
2918                         err = snd_hda_codec_reset(codec);
2919                         if (err < 0) {
2920                                 printk(KERN_ERR
2921                                        "hda_codec: cannot revert codec\n");
2922                                 return err;
2923                         }
2924                 }
2925         }
2926         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2927                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2928                 int dev;
2929
2930                 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2931                         continue; /* no substreams assigned */
2932
2933                 if (!cpcm->pcm) {
2934                         dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2935                         if (dev < 0)
2936                                 continue; /* no fatal error */
2937                         cpcm->device = dev;
2938                         err = snd_hda_attach_pcm(codec, cpcm);
2939                         if (err < 0) {
2940                                 printk(KERN_ERR "hda_codec: cannot attach "
2941                                        "PCM stream %d for codec #%d\n",
2942                                        dev, codec->addr);
2943                                 continue; /* no fatal error */
2944                         }
2945                 }
2946         }
2947         return 0;
2948 }
2949
2950 /**
2951  * snd_hda_build_pcms - build PCM information
2952  * @bus: the BUS
2953  *
2954  * Create PCM information for each codec included in the bus.
2955  *
2956  * The build_pcms codec patch is requested to set up codec->num_pcms and
2957  * codec->pcm_info properly.  The array is referred by the top-level driver
2958  * to create its PCM instances.
2959  * The allocated codec->pcm_info should be released in codec->patch_ops.free
2960  * callback.
2961  *
2962  * At least, substreams, channels_min and channels_max must be filled for
2963  * each stream.  substreams = 0 indicates that the stream doesn't exist.
2964  * When rates and/or formats are zero, the supported values are queried
2965  * from the given nid.  The nid is used also by the default ops.prepare
2966  * and ops.cleanup callbacks.
2967  *
2968  * The driver needs to call ops.open in its open callback.  Similarly,
2969  * ops.close is supposed to be called in the close callback.
2970  * ops.prepare should be called in the prepare or hw_params callback
2971  * with the proper parameters for set up.
2972  * ops.cleanup should be called in hw_free for clean up of streams.
2973  *
2974  * This function returns 0 if successfull, or a negative error code.
2975  */
2976 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2977 {
2978         struct hda_codec *codec;
2979
2980         list_for_each_entry(codec, &bus->codec_list, list) {
2981                 int err = snd_hda_codec_build_pcms(codec);
2982                 if (err < 0)
2983                         return err;
2984         }
2985         return 0;
2986 }
2987 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2988
2989 /**
2990  * snd_hda_check_board_config - compare the current codec with the config table
2991  * @codec: the HDA codec
2992  * @num_configs: number of config enums
2993  * @models: array of model name strings
2994  * @tbl: configuration table, terminated by null entries
2995  *
2996  * Compares the modelname or PCI subsystem id of the current codec with the
2997  * given configuration table.  If a matching entry is found, returns its
2998  * config value (supposed to be 0 or positive).
2999  *
3000  * If no entries are matching, the function returns a negative value.
3001  */
3002 int snd_hda_check_board_config(struct hda_codec *codec,
3003                                int num_configs, const char **models,
3004                                const struct snd_pci_quirk *tbl)
3005 {
3006         if (codec->modelname && models) {
3007                 int i;
3008                 for (i = 0; i < num_configs; i++) {
3009                         if (models[i] &&
3010                             !strcmp(codec->modelname, models[i])) {
3011                                 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3012                                            "selected\n", models[i]);
3013                                 return i;
3014                         }
3015                 }
3016         }
3017
3018         if (!codec->bus->pci || !tbl)
3019                 return -1;
3020
3021         tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3022         if (!tbl)
3023                 return -1;
3024         if (tbl->value >= 0 && tbl->value < num_configs) {
3025 #ifdef CONFIG_SND_DEBUG_VERBOSE
3026                 char tmp[10];
3027                 const char *model = NULL;
3028                 if (models)
3029                         model = models[tbl->value];
3030                 if (!model) {
3031                         sprintf(tmp, "#%d", tbl->value);
3032                         model = tmp;
3033                 }
3034                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3035                             "for config %x:%x (%s)\n",
3036                             model, tbl->subvendor, tbl->subdevice,
3037                             (tbl->name ? tbl->name : "Unknown device"));
3038 #endif
3039                 return tbl->value;
3040         }
3041         return -1;
3042 }
3043 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3044
3045 /**
3046  * snd_hda_check_board_codec_sid_config - compare the current codec
3047                                           subsystem ID with the
3048                                           config table
3049
3050            This is important for Gateway notebooks with SB450 HDA Audio
3051            where the vendor ID of the PCI device is:
3052                 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3053            and the vendor/subvendor are found only at the codec.
3054
3055  * @codec: the HDA codec
3056  * @num_configs: number of config enums
3057  * @models: array of model name strings
3058  * @tbl: configuration table, terminated by null entries
3059  *
3060  * Compares the modelname or PCI subsystem id of the current codec with the
3061  * given configuration table.  If a matching entry is found, returns its
3062  * config value (supposed to be 0 or positive).
3063  *
3064  * If no entries are matching, the function returns a negative value.
3065  */
3066 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3067                                int num_configs, const char **models,
3068                                const struct snd_pci_quirk *tbl)
3069 {
3070         const struct snd_pci_quirk *q;
3071
3072         /* Search for codec ID */
3073         for (q = tbl; q->subvendor; q++) {
3074                 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3075
3076                 if (vendorid == codec->subsystem_id)
3077                         break;
3078         }
3079
3080         if (!q->subvendor)
3081                 return -1;
3082
3083         tbl = q;
3084
3085         if (tbl->value >= 0 && tbl->value < num_configs) {
3086 #ifdef CONFIG_SND_DEBUG_DETECT
3087                 char tmp[10];
3088                 const char *model = NULL;
3089                 if (models)
3090                         model = models[tbl->value];
3091                 if (!model) {
3092                         sprintf(tmp, "#%d", tbl->value);
3093                         model = tmp;
3094                 }
3095                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3096                             "for config %x:%x (%s)\n",
3097                             model, tbl->subvendor, tbl->subdevice,
3098                             (tbl->name ? tbl->name : "Unknown device"));
3099 #endif
3100                 return tbl->value;
3101         }
3102         return -1;
3103 }
3104 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3105
3106 /**
3107  * snd_hda_add_new_ctls - create controls from the array
3108  * @codec: the HDA codec
3109  * @knew: the array of struct snd_kcontrol_new
3110  *
3111  * This helper function creates and add new controls in the given array.
3112  * The array must be terminated with an empty entry as terminator.
3113  *
3114  * Returns 0 if successful, or a negative error code.
3115  */
3116 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3117 {
3118         int err;
3119
3120         for (; knew->name; knew++) {
3121                 struct snd_kcontrol *kctl;
3122                 kctl = snd_ctl_new1(knew, codec);
3123                 if (!kctl)
3124                         return -ENOMEM;
3125                 err = snd_hda_ctl_add(codec, kctl);
3126                 if (err < 0) {
3127                         if (!codec->addr)
3128                                 return err;
3129                         kctl = snd_ctl_new1(knew, codec);
3130                         if (!kctl)
3131                                 return -ENOMEM;
3132                         kctl->id.device = codec->addr;
3133                         err = snd_hda_ctl_add(codec, kctl);
3134                         if (err < 0)
3135                                 return err;
3136                 }
3137         }
3138         return 0;
3139 }
3140 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3141
3142 #ifdef CONFIG_SND_HDA_POWER_SAVE
3143 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3144                                 unsigned int power_state);
3145
3146 static void hda_power_work(struct work_struct *work)
3147 {
3148         struct hda_codec *codec =
3149                 container_of(work, struct hda_codec, power_work.work);
3150         struct hda_bus *bus = codec->bus;
3151
3152         if (!codec->power_on || codec->power_count) {
3153                 codec->power_transition = 0;
3154                 return;
3155         }
3156
3157         hda_call_codec_suspend(codec);
3158         if (bus->ops.pm_notify)
3159                 bus->ops.pm_notify(bus);
3160 }
3161
3162 static void hda_keep_power_on(struct hda_codec *codec)
3163 {
3164         codec->power_count++;
3165         codec->power_on = 1;
3166 }
3167
3168 void snd_hda_power_up(struct hda_codec *codec)
3169 {
3170         struct hda_bus *bus = codec->bus;
3171
3172         codec->power_count++;
3173         if (codec->power_on || codec->power_transition)
3174                 return;
3175
3176         codec->power_on = 1;
3177         if (bus->ops.pm_notify)
3178                 bus->ops.pm_notify(bus);
3179         hda_call_codec_resume(codec);
3180         cancel_delayed_work(&codec->power_work);
3181         codec->power_transition = 0;
3182 }
3183 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3184
3185 #define power_save(codec)       \
3186         ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3187
3188 #define power_save(codec)       \
3189         ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3190
3191 void snd_hda_power_down(struct hda_codec *codec)
3192 {
3193         --codec->power_count;
3194         if (!codec->power_on || codec->power_count || codec->power_transition)
3195                 return;
3196         if (power_save(codec)) {
3197                 codec->power_transition = 1; /* avoid reentrance */
3198                 queue_delayed_work(codec->bus->workq, &codec->power_work,
3199                                 msecs_to_jiffies(power_save(codec) * 1000));
3200         }
3201 }
3202 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3203
3204 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3205                                  struct hda_loopback_check *check,
3206                                  hda_nid_t nid)
3207 {
3208         struct hda_amp_list *p;
3209         int ch, v;
3210
3211         if (!check->amplist)
3212                 return 0;
3213         for (p = check->amplist; p->nid; p++) {
3214                 if (p->nid == nid)
3215                         break;
3216         }
3217         if (!p->nid)
3218                 return 0; /* nothing changed */
3219
3220         for (p = check->amplist; p->nid; p++) {
3221                 for (ch = 0; ch < 2; ch++) {
3222                         v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3223                                                    p->idx);
3224                         if (!(v & HDA_AMP_MUTE) && v > 0) {
3225                                 if (!check->power_on) {
3226                                         check->power_on = 1;
3227                                         snd_hda_power_up(codec);
3228                                 }
3229                                 return 1;
3230                         }
3231                 }
3232         }
3233         if (check->power_on) {
3234                 check->power_on = 0;
3235                 snd_hda_power_down(codec);
3236         }
3237         return 0;
3238 }
3239 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3240 #endif
3241
3242 /*
3243  * Channel mode helper
3244  */
3245 int snd_hda_ch_mode_info(struct hda_codec *codec,
3246                          struct snd_ctl_elem_info *uinfo,
3247                          const struct hda_channel_mode *chmode,
3248                          int num_chmodes)
3249 {
3250         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3251         uinfo->count = 1;
3252         uinfo->value.enumerated.items = num_chmodes;
3253         if (uinfo->value.enumerated.item >= num_chmodes)
3254                 uinfo->value.enumerated.item = num_chmodes - 1;
3255         sprintf(uinfo->value.enumerated.name, "%dch",
3256                 chmode[uinfo->value.enumerated.item].channels);
3257         return 0;
3258 }
3259 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3260
3261 int snd_hda_ch_mode_get(struct hda_codec *codec,
3262                         struct snd_ctl_elem_value *ucontrol,
3263                         const struct hda_channel_mode *chmode,
3264                         int num_chmodes,
3265                         int max_channels)
3266 {
3267         int i;
3268
3269         for (i = 0; i < num_chmodes; i++) {
3270                 if (max_channels == chmode[i].channels) {
3271                         ucontrol->value.enumerated.item[0] = i;
3272                         break;
3273                 }
3274         }
3275         return 0;
3276 }
3277 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3278
3279 int snd_hda_ch_mode_put(struct hda_codec *codec,
3280                         struct snd_ctl_elem_value *ucontrol,
3281                         const struct hda_channel_mode *chmode,
3282                         int num_chmodes,
3283                         int *max_channelsp)
3284 {
3285         unsigned int mode;
3286
3287         mode = ucontrol->value.enumerated.item[0];
3288         if (mode >= num_chmodes)
3289                 return -EINVAL;
3290         if (*max_channelsp == chmode[mode].channels)
3291                 return 0;
3292         /* change the current channel setting */
3293         *max_channelsp = chmode[mode].channels;
3294         if (chmode[mode].sequence)
3295                 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3296         return 1;
3297 }
3298 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3299
3300 /*
3301  * input MUX helper
3302  */
3303 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3304                            struct snd_ctl_elem_info *uinfo)
3305 {
3306         unsigned int index;
3307
3308         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3309         uinfo->count = 1;
3310         uinfo->value.enumerated.items = imux->num_items;
3311         if (!imux->num_items)
3312                 return 0;
3313  &