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