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