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