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