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