506f46ef0304d54473f644fbfc40d7b02b53a72f
[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                                     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         snd_hda_codec_proc_new(codec);
982
983         snd_hda_create_hwdep(codec);
984
985         sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
986                 codec->subsystem_id, codec->revision_id);
987         snd_component_add(codec->bus->card, component);
988
989         if (codecp)
990                 *codecp = codec;
991         return 0;
992
993  error:
994         snd_hda_codec_free(codec);
995         return err;
996 }
997 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
998
999 int snd_hda_codec_configure(struct hda_codec *codec)
1000 {
1001         int err;
1002
1003         codec->preset = find_codec_preset(codec);
1004         if (!codec->vendor_name || !codec->chip_name) {
1005                 err = get_codec_name(codec);
1006                 if (err < 0)
1007                         return err;
1008         }
1009         /* audio codec should override the mixer name */
1010         if (codec->afg || !*codec->bus->card->mixername)
1011                 snprintf(codec->bus->card->mixername,
1012                          sizeof(codec->bus->card->mixername),
1013                          "%s %s", codec->vendor_name, codec->chip_name);
1014
1015         if (is_generic_config(codec)) {
1016                 err = snd_hda_parse_generic_codec(codec);
1017                 goto patched;
1018         }
1019         if (codec->preset && codec->preset->patch) {
1020                 err = codec->preset->patch(codec);
1021                 goto patched;
1022         }
1023
1024         /* call the default parser */
1025         err = snd_hda_parse_generic_codec(codec);
1026         if (err < 0)
1027                 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1028
1029  patched:
1030         if (!err && codec->patch_ops.unsol_event)
1031                 err = init_unsol_queue(codec->bus);
1032         return err;
1033 }
1034 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1035
1036 /**
1037  * snd_hda_codec_setup_stream - set up the codec for streaming
1038  * @codec: the CODEC to set up
1039  * @nid: the NID to set up
1040  * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1041  * @channel_id: channel id to pass, zero based.
1042  * @format: stream format.
1043  */
1044 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1045                                 u32 stream_tag,
1046                                 int channel_id, int format)
1047 {
1048         if (!nid)
1049                 return;
1050
1051         snd_printdd("hda_codec_setup_stream: "
1052                     "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1053                     nid, stream_tag, channel_id, format);
1054         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1055                             (stream_tag << 4) | channel_id);
1056         msleep(1);
1057         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1058 }
1059 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1060
1061 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1062 {
1063         if (!nid)
1064                 return;
1065
1066         snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1067         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1068 #if 0 /* keep the format */
1069         msleep(1);
1070         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1071 #endif
1072 }
1073 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
1074
1075 /*
1076  * amp access functions
1077  */
1078
1079 /* FIXME: more better hash key? */
1080 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1081 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1082 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1083 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1084 #define INFO_AMP_CAPS   (1<<0)
1085 #define INFO_AMP_VOL(ch)        (1 << (1 + (ch)))
1086
1087 /* initialize the hash table */
1088 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1089                                      unsigned int record_size)
1090 {
1091         memset(cache, 0, sizeof(*cache));
1092         memset(cache->hash, 0xff, sizeof(cache->hash));
1093         snd_array_init(&cache->buf, record_size, 64);
1094 }
1095
1096 static void free_hda_cache(struct hda_cache_rec *cache)
1097 {
1098         snd_array_free(&cache->buf);
1099 }
1100
1101 /* query the hash.  allocate an entry if not found. */
1102 static struct hda_cache_head  *get_alloc_hash(struct hda_cache_rec *cache,
1103                                               u32 key)
1104 {
1105         u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1106         u16 cur = cache->hash[idx];
1107         struct hda_cache_head *info;
1108
1109         while (cur != 0xffff) {
1110                 info = snd_array_elem(&cache->buf, cur);
1111                 if (info->key == key)
1112                         return info;
1113                 cur = info->next;
1114         }
1115
1116         /* add a new hash entry */
1117         info = snd_array_new(&cache->buf);
1118         if (!info)
1119                 return NULL;
1120         cur = snd_array_index(&cache->buf, info);
1121         info->key = key;
1122         info->val = 0;
1123         info->next = cache->hash[idx];
1124         cache->hash[idx] = cur;
1125
1126         return info;
1127 }
1128
1129 /* query and allocate an amp hash entry */
1130 static inline struct hda_amp_info *
1131 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1132 {
1133         return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1134 }
1135
1136 /*
1137  * query AMP capabilities for the given widget and direction
1138  */
1139 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1140 {
1141         struct hda_amp_info *info;
1142
1143         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1144         if (!info)
1145                 return 0;
1146         if (!(info->head.val & INFO_AMP_CAPS)) {
1147                 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1148                         nid = codec->afg;
1149                 info->amp_caps = snd_hda_param_read(codec, nid,
1150                                                     direction == HDA_OUTPUT ?
1151                                                     AC_PAR_AMP_OUT_CAP :
1152                                                     AC_PAR_AMP_IN_CAP);
1153                 if (info->amp_caps)
1154                         info->head.val |= INFO_AMP_CAPS;
1155         }
1156         return info->amp_caps;
1157 }
1158 EXPORT_SYMBOL_HDA(query_amp_caps);
1159
1160 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1161                               unsigned int caps)
1162 {
1163         struct hda_amp_info *info;
1164
1165         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1166         if (!info)
1167                 return -EINVAL;
1168         info->amp_caps = caps;
1169         info->head.val |= INFO_AMP_CAPS;
1170         return 0;
1171 }
1172 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1173
1174 static unsigned int
1175 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1176                 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1177 {
1178         struct hda_amp_info *info;
1179
1180         info = get_alloc_amp_hash(codec, key);
1181         if (!info)
1182                 return 0;
1183         if (!info->head.val) {
1184                 info->head.val |= INFO_AMP_CAPS;
1185                 info->amp_caps = func(codec, nid);
1186         }
1187         return info->amp_caps;
1188 }
1189
1190 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1191 {
1192         return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1193 }
1194
1195 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1196 {
1197         return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1198                                read_pin_cap);
1199 }
1200 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1201
1202 /*
1203  * read the current volume to info
1204  * if the cache exists, read the cache value.
1205  */
1206 static unsigned int get_vol_mute(struct hda_codec *codec,
1207                                  struct hda_amp_info *info, hda_nid_t nid,
1208                                  int ch, int direction, int index)
1209 {
1210         u32 val, parm;
1211
1212         if (info->head.val & INFO_AMP_VOL(ch))
1213                 return info->vol[ch];
1214
1215         parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1216         parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1217         parm |= index;
1218         val = snd_hda_codec_read(codec, nid, 0,
1219                                  AC_VERB_GET_AMP_GAIN_MUTE, parm);
1220         info->vol[ch] = val & 0xff;
1221         info->head.val |= INFO_AMP_VOL(ch);
1222         return info->vol[ch];
1223 }
1224
1225 /*
1226  * write the current volume in info to the h/w and update the cache
1227  */
1228 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1229                          hda_nid_t nid, int ch, int direction, int index,
1230                          int val)
1231 {
1232         u32 parm;
1233
1234         parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1235         parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1236         parm |= index << AC_AMP_SET_INDEX_SHIFT;
1237         parm |= val;
1238         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1239         info->vol[ch] = val;
1240 }
1241
1242 /*
1243  * read AMP value.  The volume is between 0 to 0x7f, 0x80 = mute bit.
1244  */
1245 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1246                            int direction, int index)
1247 {
1248         struct hda_amp_info *info;
1249         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1250         if (!info)
1251                 return 0;
1252         return get_vol_mute(codec, info, nid, ch, direction, index);
1253 }
1254 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1255
1256 /*
1257  * update the AMP value, mask = bit mask to set, val = the value
1258  */
1259 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1260                              int direction, int idx, int mask, int val)
1261 {
1262         struct hda_amp_info *info;
1263
1264         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1265         if (!info)
1266                 return 0;
1267         val &= mask;
1268         val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1269         if (info->vol[ch] == val)
1270                 return 0;
1271         put_vol_mute(codec, info, nid, ch, direction, idx, val);
1272         return 1;
1273 }
1274 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1275
1276 /*
1277  * update the AMP stereo with the same mask and value
1278  */
1279 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1280                              int direction, int idx, int mask, int val)
1281 {
1282         int ch, ret = 0;
1283         for (ch = 0; ch < 2; ch++)
1284                 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1285                                                 idx, mask, val);
1286         return ret;
1287 }
1288 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1289
1290 #ifdef SND_HDA_NEEDS_RESUME
1291 /* resume the all amp commands from the cache */
1292 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1293 {
1294         struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1295         int i;
1296
1297         for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1298                 u32 key = buffer->head.key;
1299                 hda_nid_t nid;
1300                 unsigned int idx, dir, ch;
1301                 if (!key)
1302                         continue;
1303                 nid = key & 0xff;
1304                 idx = (key >> 16) & 0xff;
1305                 dir = (key >> 24) & 0xff;
1306                 for (ch = 0; ch < 2; ch++) {
1307                         if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1308                                 continue;
1309                         put_vol_mute(codec, buffer, nid, ch, dir, idx,
1310                                      buffer->vol[ch]);
1311                 }
1312         }
1313 }
1314 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1315 #endif /* SND_HDA_NEEDS_RESUME */
1316
1317 /* volume */
1318 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1319                                   struct snd_ctl_elem_info *uinfo)
1320 {
1321         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1322         u16 nid = get_amp_nid(kcontrol);
1323         u8 chs = get_amp_channels(kcontrol);
1324         int dir = get_amp_direction(kcontrol);
1325         unsigned int ofs = get_amp_offset(kcontrol);
1326         u32 caps;
1327
1328         caps = query_amp_caps(codec, nid, dir);
1329         /* num steps */
1330         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1331         if (!caps) {
1332                 printk(KERN_WARNING "hda_codec: "
1333                        "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1334                        kcontrol->id.name);
1335                 return -EINVAL;
1336         }
1337         if (ofs < caps)
1338                 caps -= ofs;
1339         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1340         uinfo->count = chs == 3 ? 2 : 1;
1341         uinfo->value.integer.min = 0;
1342         uinfo->value.integer.max = caps;
1343         return 0;
1344 }
1345 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1346
1347
1348 static inline unsigned int
1349 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1350                int ch, int dir, int idx, unsigned int ofs)
1351 {
1352         unsigned int val;
1353         val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1354         val &= HDA_AMP_VOLMASK;
1355         if (val >= ofs)
1356                 val -= ofs;
1357         else
1358                 val = 0;
1359         return val;
1360 }
1361
1362 static inline int
1363 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1364                  int ch, int dir, int idx, unsigned int ofs,
1365                  unsigned int val)
1366 {
1367         if (val > 0)
1368                 val += ofs;
1369         return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1370                                         HDA_AMP_VOLMASK, val);
1371 }
1372
1373 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1374                                  struct snd_ctl_elem_value *ucontrol)
1375 {
1376         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1377         hda_nid_t nid = get_amp_nid(kcontrol);
1378         int chs = get_amp_channels(kcontrol);
1379         int dir = get_amp_direction(kcontrol);
1380         int idx = get_amp_index(kcontrol);
1381         unsigned int ofs = get_amp_offset(kcontrol);
1382         long *valp = ucontrol->value.integer.value;
1383
1384         if (chs & 1)
1385                 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1386         if (chs & 2)
1387                 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1388         return 0;
1389 }
1390 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1391
1392 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1393                                  struct snd_ctl_elem_value *ucontrol)
1394 {
1395         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1396         hda_nid_t nid = get_amp_nid(kcontrol);
1397         int chs = get_amp_channels(kcontrol);
1398         int dir = get_amp_direction(kcontrol);
1399         int idx = get_amp_index(kcontrol);
1400         unsigned int ofs = get_amp_offset(kcontrol);
1401         long *valp = ucontrol->value.integer.value;
1402         int change = 0;
1403
1404         snd_hda_power_up(codec);
1405         if (chs & 1) {
1406                 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1407                 valp++;
1408         }
1409         if (chs & 2)
1410                 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1411         snd_hda_power_down(codec);
1412         return change;
1413 }
1414 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1415
1416 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1417                           unsigned int size, unsigned int __user *_tlv)
1418 {
1419         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1420         hda_nid_t nid = get_amp_nid(kcontrol);
1421         int dir = get_amp_direction(kcontrol);
1422         unsigned int ofs = get_amp_offset(kcontrol);
1423         u32 caps, val1, val2;
1424
1425         if (size < 4 * sizeof(unsigned int))
1426                 return -ENOMEM;
1427         caps = query_amp_caps(codec, nid, dir);
1428         val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1429         val2 = (val2 + 1) * 25;
1430         val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1431         val1 += ofs;
1432         val1 = ((int)val1) * ((int)val2);
1433         if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1434                 return -EFAULT;
1435         if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1436                 return -EFAULT;
1437         if (put_user(val1, _tlv + 2))
1438                 return -EFAULT;
1439         if (put_user(val2, _tlv + 3))
1440                 return -EFAULT;
1441         return 0;
1442 }
1443 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1444
1445 /*
1446  * set (static) TLV for virtual master volume; recalculated as max 0dB
1447  */
1448 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1449                              unsigned int *tlv)
1450 {
1451         u32 caps;
1452         int nums, step;
1453
1454         caps = query_amp_caps(codec, nid, dir);
1455         nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1456         step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1457         step = (step + 1) * 25;
1458         tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1459         tlv[1] = 2 * sizeof(unsigned int);
1460         tlv[2] = -nums * step;
1461         tlv[3] = step;
1462 }
1463 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1464
1465 /* find a mixer control element with the given name */
1466 static struct snd_kcontrol *
1467 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1468                         const char *name, int idx)
1469 {
1470         struct snd_ctl_elem_id id;
1471         memset(&id, 0, sizeof(id));
1472         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1473         id.index = idx;
1474         if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1475                 return NULL;
1476         strcpy(id.name, name);
1477         return snd_ctl_find_id(codec->bus->card, &id);
1478 }
1479
1480 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1481                                             const char *name)
1482 {
1483         return _snd_hda_find_mixer_ctl(codec, name, 0);
1484 }
1485 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1486
1487 /* Add a control element and assign to the codec */
1488 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1489 {
1490         int err;
1491         struct snd_kcontrol **knewp;
1492
1493         err = snd_ctl_add(codec->bus->card, kctl);
1494         if (err < 0)
1495                 return err;
1496         knewp = snd_array_new(&codec->mixers);
1497         if (!knewp)
1498                 return -ENOMEM;
1499         *knewp = kctl;
1500         return 0;
1501 }
1502 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1503
1504 /* Clear all controls assigned to the given codec */
1505 void snd_hda_ctls_clear(struct hda_codec *codec)
1506 {
1507         int i;
1508         struct snd_kcontrol **kctls = codec->mixers.list;
1509         for (i = 0; i < codec->mixers.used; i++)
1510                 snd_ctl_remove(codec->bus->card, kctls[i]);
1511         snd_array_free(&codec->mixers);
1512 }
1513
1514 /* pseudo device locking
1515  * toggle card->shutdown to allow/disallow the device access (as a hack)
1516  */
1517 static int hda_lock_devices(struct snd_card *card)
1518 {
1519         spin_lock(&card->files_lock);
1520         if (card->shutdown) {
1521                 spin_unlock(&card->files_lock);
1522                 return -EINVAL;
1523         }
1524         card->shutdown = 1;
1525         spin_unlock(&card->files_lock);
1526         return 0;
1527 }
1528
1529 static void hda_unlock_devices(struct snd_card *card)
1530 {
1531         spin_lock(&card->files_lock);
1532         card->shutdown = 0;
1533         spin_unlock(&card->files_lock);
1534 }
1535
1536 int snd_hda_codec_reset(struct hda_codec *codec)
1537 {
1538         struct snd_card *card = codec->bus->card;
1539         int i, pcm;
1540
1541         if (hda_lock_devices(card) < 0)
1542                 return -EBUSY;
1543         /* check whether the codec isn't used by any mixer or PCM streams */
1544         if (!list_empty(&card->ctl_files)) {
1545                 hda_unlock_devices(card);
1546                 return -EBUSY;
1547         }
1548         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1549                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1550                 if (!cpcm->pcm)
1551                         continue;
1552                 if (cpcm->pcm->streams[0].substream_opened ||
1553                     cpcm->pcm->streams[1].substream_opened) {
1554                         hda_unlock_devices(card);
1555                         return -EBUSY;
1556                 }
1557         }
1558
1559         /* OK, let it free */
1560
1561 #ifdef CONFIG_SND_HDA_POWER_SAVE
1562         cancel_delayed_work(&codec->power_work);
1563         flush_workqueue(codec->bus->workq);
1564 #endif
1565         snd_hda_ctls_clear(codec);
1566         /* relase PCMs */
1567         for (i = 0; i < codec->num_pcms; i++) {
1568                 if (codec->pcm_info[i].pcm) {
1569                         snd_device_free(card, codec->pcm_info[i].pcm);
1570                         clear_bit(codec->pcm_info[i].device,
1571                                   codec->bus->pcm_dev_bits);
1572                 }
1573         }
1574         if (codec->patch_ops.free)
1575                 codec->patch_ops.free(codec);
1576         codec->proc_widget_hook = NULL;
1577         codec->spec = NULL;
1578         free_hda_cache(&codec->amp_cache);
1579         free_hda_cache(&codec->cmd_cache);
1580         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1581         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1582         /* free only driver_pins so that init_pins + user_pins are restored */
1583         snd_array_free(&codec->driver_pins);
1584         restore_pincfgs(codec);
1585         codec->num_pcms = 0;
1586         codec->pcm_info = NULL;
1587         codec->preset = NULL;
1588         memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1589         codec->slave_dig_outs = NULL;
1590         codec->spdif_status_reset = 0;
1591         module_put(codec->owner);
1592         codec->owner = NULL;
1593
1594         /* allow device access again */
1595         hda_unlock_devices(card);
1596         return 0;
1597 }
1598
1599 /* create a virtual master control and add slaves */
1600 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1601                         unsigned int *tlv, const char **slaves)
1602 {
1603         struct snd_kcontrol *kctl;
1604         const char **s;
1605         int err;
1606
1607         for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1608                 ;
1609         if (!*s) {
1610                 snd_printdd("No slave found for %s\n", name);
1611                 return 0;
1612         }
1613         kctl = snd_ctl_make_virtual_master(name, tlv);
1614         if (!kctl)
1615                 return -ENOMEM;
1616         err = snd_hda_ctl_add(codec, kctl);
1617         if (err < 0)
1618                 return err;
1619         
1620         for (s = slaves; *s; s++) {
1621                 struct snd_kcontrol *sctl;
1622                 int i = 0;
1623                 for (;;) {
1624                         sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1625                         if (!sctl) {
1626                                 if (!i)
1627                                         snd_printdd("Cannot find slave %s, "
1628                                                     "skipped\n", *s);
1629                                 break;
1630                         }
1631                         err = snd_ctl_add_slave(kctl, sctl);
1632                         if (err < 0)
1633                                 return err;
1634                         i++;
1635                 }
1636         }
1637         return 0;
1638 }
1639 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1640
1641 /* switch */
1642 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1643                                   struct snd_ctl_elem_info *uinfo)
1644 {
1645         int chs = get_amp_channels(kcontrol);
1646
1647         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1648         uinfo->count = chs == 3 ? 2 : 1;
1649         uinfo->value.integer.min = 0;
1650         uinfo->value.integer.max = 1;
1651         return 0;
1652 }
1653 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1654
1655 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1656                                  struct snd_ctl_elem_value *ucontrol)
1657 {
1658         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1659         hda_nid_t nid = get_amp_nid(kcontrol);
1660         int chs = get_amp_channels(kcontrol);
1661         int dir = get_amp_direction(kcontrol);
1662         int idx = get_amp_index(kcontrol);
1663         long *valp = ucontrol->value.integer.value;
1664
1665         if (chs & 1)
1666                 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1667                            HDA_AMP_MUTE) ? 0 : 1;
1668         if (chs & 2)
1669                 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1670                          HDA_AMP_MUTE) ? 0 : 1;
1671         return 0;
1672 }
1673 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1674
1675 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1676                                  struct snd_ctl_elem_value *ucontrol)
1677 {
1678         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1679         hda_nid_t nid = get_amp_nid(kcontrol);
1680         int chs = get_amp_channels(kcontrol);
1681         int dir = get_amp_direction(kcontrol);
1682         int idx = get_amp_index(kcontrol);
1683         long *valp = ucontrol->value.integer.value;
1684         int change = 0;
1685
1686         snd_hda_power_up(codec);
1687         if (chs & 1) {
1688                 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1689                                                   HDA_AMP_MUTE,
1690                                                   *valp ? 0 : HDA_AMP_MUTE);
1691                 valp++;
1692         }
1693         if (chs & 2)
1694                 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1695                                                    HDA_AMP_MUTE,
1696                                                    *valp ? 0 : HDA_AMP_MUTE);
1697 #ifdef CONFIG_SND_HDA_POWER_SAVE
1698         if (codec->patch_ops.check_power_status)
1699                 codec->patch_ops.check_power_status(codec, nid);
1700 #endif
1701         snd_hda_power_down(codec);
1702         return change;
1703 }
1704 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1705
1706 /*
1707  * bound volume controls
1708  *
1709  * bind multiple volumes (# indices, from 0)
1710  */
1711
1712 #define AMP_VAL_IDX_SHIFT       19
1713 #define AMP_VAL_IDX_MASK        (0x0f<<19)
1714
1715 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1716                                   struct snd_ctl_elem_value *ucontrol)
1717 {
1718         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1719         unsigned long pval;
1720         int err;
1721
1722         mutex_lock(&codec->control_mutex);
1723         pval = kcontrol->private_value;
1724         kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1725         err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1726         kcontrol->private_value = pval;
1727         mutex_unlock(&codec->control_mutex);
1728         return err;
1729 }
1730 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1731
1732 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1733                                   struct snd_ctl_elem_value *ucontrol)
1734 {
1735         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1736         unsigned long pval;
1737         int i, indices, err = 0, change = 0;
1738
1739         mutex_lock(&codec->control_mutex);
1740         pval = kcontrol->private_value;
1741         indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1742         for (i = 0; i < indices; i++) {
1743                 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1744                         (i << AMP_VAL_IDX_SHIFT);
1745                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1746                 if (err < 0)
1747                         break;
1748                 change |= err;
1749         }
1750         kcontrol->private_value = pval;
1751         mutex_unlock(&codec->control_mutex);
1752         return err < 0 ? err : change;
1753 }
1754 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1755
1756 /*
1757  * generic bound volume/swtich controls
1758  */
1759 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1760                                  struct snd_ctl_elem_info *uinfo)
1761 {
1762         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1763         struct hda_bind_ctls *c;
1764         int err;
1765
1766         mutex_lock(&codec->control_mutex);
1767         c = (struct hda_bind_ctls *)kcontrol->private_value;
1768         kcontrol->private_value = *c->values;
1769         err = c->ops->info(kcontrol, uinfo);
1770         kcontrol->private_value = (long)c;
1771         mutex_unlock(&codec->control_mutex);
1772         return err;
1773 }
1774 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1775
1776 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1777                                 struct snd_ctl_elem_value *ucontrol)
1778 {
1779         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1780         struct hda_bind_ctls *c;
1781         int err;
1782
1783         mutex_lock(&codec->control_mutex);
1784         c = (struct hda_bind_ctls *)kcontrol->private_value;
1785         kcontrol->private_value = *c->values;
1786         err = c->ops->get(kcontrol, ucontrol);
1787         kcontrol->private_value = (long)c;
1788         mutex_unlock(&codec->control_mutex);
1789         return err;
1790 }
1791 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1792
1793 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1794                                 struct snd_ctl_elem_value *ucontrol)
1795 {
1796         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1797         struct hda_bind_ctls *c;
1798         unsigned long *vals;
1799         int err = 0, change = 0;
1800
1801         mutex_lock(&codec->control_mutex);
1802         c = (struct hda_bind_ctls *)kcontrol->private_value;
1803         for (vals = c->values; *vals; vals++) {
1804                 kcontrol->private_value = *vals;
1805                 err = c->ops->put(kcontrol, ucontrol);
1806                 if (err < 0)
1807                         break;
1808                 change |= err;
1809         }
1810         kcontrol->private_value = (long)c;
1811         mutex_unlock(&codec->control_mutex);
1812         return err < 0 ? err : change;
1813 }
1814 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1815
1816 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1817                            unsigned int size, unsigned int __user *tlv)
1818 {
1819         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1820         struct hda_bind_ctls *c;
1821         int err;
1822
1823         mutex_lock(&codec->control_mutex);
1824         c = (struct hda_bind_ctls *)kcontrol->private_value;
1825         kcontrol->private_value = *c->values;
1826         err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1827         kcontrol->private_value = (long)c;
1828         mutex_unlock(&codec->control_mutex);
1829         return err;
1830 }
1831 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1832
1833 struct hda_ctl_ops snd_hda_bind_vol = {
1834         .info = snd_hda_mixer_amp_volume_info,
1835         .get = snd_hda_mixer_amp_volume_get,
1836         .put = snd_hda_mixer_amp_volume_put,
1837         .tlv = snd_hda_mixer_amp_tlv
1838 };
1839 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1840
1841 struct hda_ctl_ops snd_hda_bind_sw = {
1842         .info = snd_hda_mixer_amp_switch_info,
1843         .get = snd_hda_mixer_amp_switch_get,
1844         .put = snd_hda_mixer_amp_switch_put,
1845         .tlv = snd_hda_mixer_amp_tlv
1846 };
1847 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1848
1849 /*
1850  * SPDIF out controls
1851  */
1852
1853 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1854                                    struct snd_ctl_elem_info *uinfo)
1855 {
1856         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1857         uinfo->count = 1;
1858         return 0;
1859 }
1860
1861 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1862                                    struct snd_ctl_elem_value *ucontrol)
1863 {
1864         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1865                                            IEC958_AES0_NONAUDIO |
1866                                            IEC958_AES0_CON_EMPHASIS_5015 |
1867                                            IEC958_AES0_CON_NOT_COPYRIGHT;
1868         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1869                                            IEC958_AES1_CON_ORIGINAL;
1870         return 0;
1871 }
1872
1873 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1874                                    struct snd_ctl_elem_value *ucontrol)
1875 {
1876         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1877                                            IEC958_AES0_NONAUDIO |
1878                                            IEC958_AES0_PRO_EMPHASIS_5015;
1879         return 0;
1880 }
1881
1882 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1883                                      struct snd_ctl_elem_value *ucontrol)
1884 {
1885         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1886
1887         ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1888         ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1889         ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1890         ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1891
1892         return 0;
1893 }
1894
1895 /* convert from SPDIF status bits to HDA SPDIF bits
1896  * bit 0 (DigEn) is always set zero (to be filled later)
1897  */
1898 static unsigned short convert_from_spdif_status(unsigned int sbits)
1899 {
1900         unsigned short val = 0;
1901
1902         if (sbits & IEC958_AES0_PROFESSIONAL)
1903                 val |= AC_DIG1_PROFESSIONAL;
1904         if (sbits & IEC958_AES0_NONAUDIO)
1905                 val |= AC_DIG1_NONAUDIO;
1906         if (sbits & IEC958_AES0_PROFESSIONAL) {
1907                 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1908                     IEC958_AES0_PRO_EMPHASIS_5015)
1909                         val |= AC_DIG1_EMPHASIS;
1910         } else {
1911                 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1912                     IEC958_AES0_CON_EMPHASIS_5015)
1913                         val |= AC_DIG1_EMPHASIS;
1914                 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1915                         val |= AC_DIG1_COPYRIGHT;
1916                 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1917                         val |= AC_DIG1_LEVEL;
1918                 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1919         }
1920         return val;
1921 }
1922
1923 /* convert to SPDIF status bits from HDA SPDIF bits
1924  */
1925 static unsigned int convert_to_spdif_status(unsigned short val)
1926 {
1927         unsigned int sbits = 0;
1928
1929         if (val & AC_DIG1_NONAUDIO)
1930                 sbits |= IEC958_AES0_NONAUDIO;
1931         if (val & AC_DIG1_PROFESSIONAL)
1932                 sbits |= IEC958_AES0_PROFESSIONAL;
1933         if (sbits & IEC958_AES0_PROFESSIONAL) {
1934                 if (sbits & AC_DIG1_EMPHASIS)
1935                         sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1936         } else {
1937                 if (val & AC_DIG1_EMPHASIS)
1938                         sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1939                 if (!(val & AC_DIG1_COPYRIGHT))
1940                         sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1941                 if (val & AC_DIG1_LEVEL)
1942                         sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1943                 sbits |= val & (0x7f << 8);
1944         }
1945         return sbits;
1946 }
1947
1948 /* set digital convert verbs both for the given NID and its slaves */
1949 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1950                         int verb, int val)
1951 {
1952         hda_nid_t *d;
1953
1954         snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1955         d = codec->slave_dig_outs;
1956         if (!d)
1957                 return;
1958         for (; *d; d++)
1959                 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1960 }
1961
1962 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1963                                        int dig1, int dig2)
1964 {
1965         if (dig1 != -1)
1966                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1967         if (dig2 != -1)
1968                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1969 }
1970
1971 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1972                                      struct snd_ctl_elem_value *ucontrol)
1973 {
1974         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1975         hda_nid_t nid = kcontrol->private_value;
1976         unsigned short val;
1977         int change;
1978
1979         mutex_lock(&codec->spdif_mutex);
1980         codec->spdif_status = ucontrol->value.iec958.status[0] |
1981                 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1982                 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1983                 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1984         val = convert_from_spdif_status(codec->spdif_status);
1985         val |= codec->spdif_ctls & 1;
1986         change = codec->spdif_ctls != val;
1987         codec->spdif_ctls = val;
1988
1989         if (change)
1990                 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1991
1992         mutex_unlock(&codec->spdif_mutex);
1993         return change;
1994 }
1995
1996 #define snd_hda_spdif_out_switch_info   snd_ctl_boolean_mono_info
1997
1998 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1999                                         struct snd_ctl_elem_value *ucontrol)
2000 {
2001         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2002
2003         ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
2004         return 0;
2005 }
2006
2007 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2008                                         struct snd_ctl_elem_value *ucontrol)
2009 {
2010         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2011         hda_nid_t nid = kcontrol->private_value;
2012         unsigned short val;
2013         int change;
2014
2015         mutex_lock(&codec->spdif_mutex);
2016         val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2017         if (ucontrol->value.integer.value[0])
2018                 val |= AC_DIG1_ENABLE;
2019         change = codec->spdif_ctls != val;
2020         if (change) {
2021                 codec->spdif_ctls = val;
2022                 set_dig_out_convert(codec, nid, val & 0xff, -1);
2023                 /* unmute amp switch (if any) */
2024                 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2025                     (val & AC_DIG1_ENABLE))
2026                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2027                                                  HDA_AMP_MUTE, 0);
2028         }
2029         mutex_unlock(&codec->spdif_mutex);
2030         return change;
2031 }
2032
2033 static struct snd_kcontrol_new dig_mixes[] = {
2034         {
2035                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2036                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2037                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2038                 .info = snd_hda_spdif_mask_info,
2039                 .get = snd_hda_spdif_cmask_get,
2040         },
2041         {
2042                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2043                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2044                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2045                 .info = snd_hda_spdif_mask_info,
2046                 .get = snd_hda_spdif_pmask_get,
2047         },
2048         {
2049                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2050                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2051                 .info = snd_hda_spdif_mask_info,
2052                 .get = snd_hda_spdif_default_get,
2053                 .put = snd_hda_spdif_default_put,
2054         },
2055         {
2056                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2057                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2058                 .info = snd_hda_spdif_out_switch_info,
2059                 .get = snd_hda_spdif_out_switch_get,
2060                 .put = snd_hda_spdif_out_switch_put,
2061         },
2062         { } /* end */
2063 };
2064
2065 #define SPDIF_MAX_IDX   4       /* 4 instances should be enough to probe */
2066
2067 /**
2068  * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2069  * @codec: the HDA codec
2070  * @nid: audio out widget NID
2071  *
2072  * Creates controls related with the SPDIF output.
2073  * Called from each patch supporting the SPDIF out.
2074  *
2075  * Returns 0 if successful, or a negative error code.
2076  */
2077 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2078 {
2079         int err;
2080         struct snd_kcontrol *kctl;
2081         struct snd_kcontrol_new *dig_mix;
2082         int idx;
2083
2084         for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2085                 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2086                                              idx))
2087                         break;
2088         }
2089         if (idx >= SPDIF_MAX_IDX) {
2090                 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2091                 return -EBUSY;
2092         }
2093         for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2094                 kctl = snd_ctl_new1(dig_mix, codec);
2095                 if (!kctl)
2096                         return -ENOMEM;
2097                 kctl->id.index = idx;
2098                 kctl->private_value = nid;
2099                 err = snd_hda_ctl_add(codec, kctl);
2100                 if (err < 0)
2101                         return err;
2102         }
2103         codec->spdif_ctls =
2104                 snd_hda_codec_read(codec, nid, 0,
2105                                    AC_VERB_GET_DIGI_CONVERT_1, 0);
2106         codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2107         return 0;
2108 }
2109 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2110
2111 /*
2112  * SPDIF sharing with analog output
2113  */
2114 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2115                               struct snd_ctl_elem_value *ucontrol)
2116 {
2117         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2118         ucontrol->value.integer.value[0] = mout->share_spdif;
2119         return 0;
2120 }
2121
2122 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2123                               struct snd_ctl_elem_value *ucontrol)
2124 {
2125         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2126         mout->share_spdif = !!ucontrol->value.integer.value[0];
2127         return 0;
2128 }
2129
2130 static struct snd_kcontrol_new spdif_share_sw = {
2131         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2132         .name = "IEC958 Default PCM Playback Switch",
2133         .info = snd_ctl_boolean_mono_info,
2134         .get = spdif_share_sw_get,
2135         .put = spdif_share_sw_put,
2136 };
2137
2138 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2139                                   struct hda_multi_out *mout)
2140 {
2141         if (!mout->dig_out_nid)
2142                 return 0;
2143         /* ATTENTION: here mout is passed as private_data, instead of codec */
2144         return snd_hda_ctl_add(codec,
2145                            snd_ctl_new1(&spdif_share_sw, mout));
2146 }
2147 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2148
2149 /*
2150  * SPDIF input
2151  */
2152
2153 #define snd_hda_spdif_in_switch_info    snd_hda_spdif_out_switch_info
2154
2155 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2156                                        struct snd_ctl_elem_value *ucontrol)
2157 {
2158         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2159
2160         ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2161         return 0;
2162 }
2163
2164 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2165                                        struct snd_ctl_elem_value *ucontrol)
2166 {
2167         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2168         hda_nid_t nid = kcontrol->private_value;
2169         unsigned int val = !!ucontrol->value.integer.value[0];
2170         int change;
2171
2172         mutex_lock(&codec->spdif_mutex);
2173         change = codec->spdif_in_enable != val;
2174         if (change) {
2175                 codec->spdif_in_enable = val;
2176                 snd_hda_codec_write_cache(codec, nid, 0,
2177                                           AC_VERB_SET_DIGI_CONVERT_1, val);
2178         }
2179         mutex_unlock(&codec->spdif_mutex);
2180         return change;
2181 }
2182
2183 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2184                                        struct snd_ctl_elem_value *ucontrol)
2185 {
2186         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2187         hda_nid_t nid = kcontrol->private_value;
2188         unsigned short val;
2189         unsigned int sbits;
2190
2191         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2192         sbits = convert_to_spdif_status(val);
2193         ucontrol->value.iec958.status[0] = sbits;
2194         ucontrol->value.iec958.status[1] = sbits >> 8;
2195         ucontrol->value.iec958.status[2] = sbits >> 16;
2196         ucontrol->value.iec958.status[3] = sbits >> 24;
2197         return 0;
2198 }
2199
2200 static struct snd_kcontrol_new dig_in_ctls[] = {
2201         {
2202                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2203                 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2204                 .info = snd_hda_spdif_in_switch_info,
2205                 .get = snd_hda_spdif_in_switch_get,
2206                 .put = snd_hda_spdif_in_switch_put,
2207         },
2208         {
2209                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2210                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2211                 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2212                 .info = snd_hda_spdif_mask_info,
2213                 .get = snd_hda_spdif_in_status_get,
2214         },
2215         { } /* end */
2216 };
2217
2218 /**
2219  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2220  * @codec: the HDA codec
2221  * @nid: audio in widget NID
2222  *
2223  * Creates controls related with the SPDIF input.
2224  * Called from each patch supporting the SPDIF in.
2225  *
2226  * Returns 0 if successful, or a negative error code.
2227  */
2228 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2229 {
2230         int err;
2231         struct snd_kcontrol *kctl;
2232         struct snd_kcontrol_new *dig_mix;
2233         int idx;
2234
2235         for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2236                 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2237                                              idx))
2238                         break;
2239         }
2240         if (idx >= SPDIF_MAX_IDX) {
2241                 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2242                 return -EBUSY;
2243         }
2244         for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2245                 kctl = snd_ctl_new1(dig_mix, codec);
2246                 if (!kctl)
2247                         return -ENOMEM;
2248                 kctl->private_value = nid;
2249                 err = snd_hda_ctl_add(codec, kctl);
2250                 if (err < 0)
2251                         return err;
2252         }
2253         codec->spdif_in_enable =
2254                 snd_hda_codec_read(codec, nid, 0,
2255                                    AC_VERB_GET_DIGI_CONVERT_1, 0) &
2256                 AC_DIG1_ENABLE;
2257         return 0;
2258 }
2259 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2260
2261 #ifdef SND_HDA_NEEDS_RESUME
2262 /*
2263  * command cache
2264  */
2265
2266 /* build a 32bit cache key with the widget id and the command parameter */
2267 #define build_cmd_cache_key(nid, verb)  ((verb << 8) | nid)
2268 #define get_cmd_cache_nid(key)          ((key) & 0xff)
2269 #define get_cmd_cache_cmd(key)          (((key) >> 8) & 0xffff)
2270
2271 /**
2272  * snd_hda_codec_write_cache - send a single command with caching
2273  * @codec: the HDA codec
2274  * @nid: NID to send the command
2275  * @direct: direct flag
2276  * @verb: the verb to send
2277  * @parm: the parameter for the verb
2278  *
2279  * Send a single command without waiting for response.
2280  *
2281  * Returns 0 if successful, or a negative error code.
2282  */
2283 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2284                               int direct, unsigned int verb, unsigned int parm)
2285 {
2286         int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2287         struct hda_cache_head *c;
2288         u32 key;
2289
2290         if (err < 0)
2291                 return err;
2292         /* parm may contain the verb stuff for get/set amp */
2293         verb = verb | (parm >> 8);
2294         parm &= 0xff;
2295         key = build_cmd_cache_key(nid, verb);
2296         mutex_lock(&codec->bus->cmd_mutex);
2297         c = get_alloc_hash(&codec->cmd_cache, key);
2298         if (c)
2299                 c->val = parm;
2300         mutex_unlock(&codec->bus->cmd_mutex);
2301         return 0;
2302 }
2303 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2304
2305 /* resume the all commands from the cache */
2306 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2307 {
2308         struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2309         int i;
2310
2311         for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2312                 u32 key = buffer->key;
2313                 if (!key)
2314                         continue;
2315                 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2316                                     get_cmd_cache_cmd(key), buffer->val);
2317         }
2318 }
2319 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2320
2321 /**
2322  * snd_hda_sequence_write_cache - sequence writes with caching
2323  * @codec: the HDA codec
2324  * @seq: VERB array to send
2325  *
2326  * Send the commands sequentially from the given array.
2327  * Thte commands are recorded on cache for power-save and resume.
2328  * The array must be terminated with NID=0.
2329  */
2330 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2331                                   const struct hda_verb *seq)
2332 {
2333         for (; seq->nid; seq++)
2334                 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2335                                           seq->param);
2336 }
2337 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2338 #endif /* SND_HDA_NEEDS_RESUME */
2339
2340 /*
2341  * set power state of the codec
2342  */
2343 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2344                                 unsigned int power_state)
2345 {
2346         hda_nid_t nid;
2347         int i;
2348
2349         snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2350                             power_state);
2351         msleep(10); /* partial workaround for "azx_get_response timeout" */
2352
2353         nid = codec->start_nid;
2354         for (i = 0; i < codec->num_nodes; i++, nid++) {
2355                 unsigned int wcaps = get_wcaps(codec, nid);
2356                 if (wcaps & AC_WCAP_POWER) {
2357                         unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2358                                 AC_WCAP_TYPE_SHIFT;
2359                         if (power_state == AC_PWRST_D3 &&
2360                             wid_type == AC_WID_PIN) {
2361                                 unsigned int pincap;
2362                                 /*
2363                                  * don't power down the widget if it controls
2364                                  * eapd and EAPD_BTLENABLE is set.
2365                                  */
2366                                 pincap = snd_hda_query_pin_caps(codec, nid);
2367                                 if (pincap & AC_PINCAP_EAPD) {
2368                                         int eapd = snd_hda_codec_read(codec,
2369                                                 nid, 0,
2370                                                 AC_VERB_GET_EAPD_BTLENABLE, 0);
2371                                         eapd &= 0x02;
2372                                         if (eapd)
2373                                                 continue;
2374                                 }
2375                         }
2376                         snd_hda_codec_write(codec, nid, 0,
2377                                             AC_VERB_SET_POWER_STATE,
2378                                             power_state);
2379                 }
2380         }
2381
2382         if (power_state == AC_PWRST_D0) {
2383                 unsigned long end_time;
2384                 int state;
2385                 msleep(10);
2386                 /* wait until the codec reachs to D0 */
2387                 end_time = jiffies + msecs_to_jiffies(500);
2388                 do {
2389                         state = snd_hda_codec_read(codec, fg, 0,
2390                                                    AC_VERB_GET_POWER_STATE, 0);
2391                         if (state == power_state)
2392                                 break;
2393                         msleep(1);
2394                 } while (time_after_eq(end_time, jiffies));
2395         }
2396 }
2397
2398 #ifdef CONFIG_SND_HDA_HWDEP
2399 /* execute additional init verbs */
2400 static void hda_exec_init_verbs(struct hda_codec *codec)
2401 {
2402         if (codec->init_verbs.list)
2403                 snd_hda_sequence_write(codec, codec->init_verbs.list);
2404 }
2405 #else
2406 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2407 #endif
2408
2409 #ifdef SND_HDA_NEEDS_RESUME
2410 /*
2411  * call suspend and power-down; used both from PM and power-save
2412  */
2413 static void hda_call_codec_suspend(struct hda_codec *codec)
2414 {
2415         if (codec->patch_ops.suspend)
2416                 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2417         hda_set_power_state(codec,
2418                             codec->afg ? codec->afg : codec->mfg,
2419                             AC_PWRST_D3);
2420 #ifdef CONFIG_SND_HDA_POWER_SAVE
2421         cancel_delayed_work(&codec->power_work);
2422         codec->power_on = 0;
2423         codec->power_transition = 0;
2424 #endif
2425 }
2426
2427 /*
2428  * kick up codec; used both from PM and power-save
2429  */
2430 static void hda_call_codec_resume(struct hda_codec *codec)
2431 {
2432         hda_set_power_state(codec,
2433                             codec->afg ? codec->afg : codec->mfg,
2434                             AC_PWRST_D0);
2435         restore_pincfgs(codec); /* restore all current pin configs */
2436         hda_exec_init_verbs(codec);
2437         if (codec->patch_ops.resume)
2438                 codec->patch_ops.resume(codec);
2439         else {
2440                 if (codec->patch_ops.init)
2441                         codec->patch_ops.init(codec);
2442                 snd_hda_codec_resume_amp(codec);
2443                 snd_hda_codec_resume_cache(codec);
2444         }
2445 }
2446 #endif /* SND_HDA_NEEDS_RESUME */
2447
2448
2449 /**
2450  * snd_hda_build_controls - build mixer controls
2451  * @bus: the BUS
2452  *
2453  * Creates mixer controls for each codec included in the bus.
2454  *
2455  * Returns 0 if successful, otherwise a negative error code.
2456  */
2457 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2458 {
2459         struct hda_codec *codec;
2460
2461         list_for_each_entry(codec, &bus->codec_list, list) {
2462                 int err = snd_hda_codec_build_controls(codec);
2463                 if (err < 0) {
2464                         printk(KERN_ERR "hda_codec: cannot build controls"
2465                                "for #%d (error %d)\n", codec->addr, err); 
2466                         err = snd_hda_codec_reset(codec);
2467                         if (err < 0) {
2468                                 printk(KERN_ERR
2469                                        "hda_codec: cannot revert codec\n");
2470                                 return err;
2471                         }
2472                 }
2473         }
2474         return 0;
2475 }
2476 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2477
2478 int snd_hda_codec_build_controls(struct hda_codec *codec)
2479 {
2480         int err = 0;
2481         hda_exec_init_verbs(codec);
2482         /* continue to initialize... */
2483         if (codec->patch_ops.init)
2484                 err = codec->patch_ops.init(codec);
2485         if (!err && codec->patch_ops.build_controls)
2486                 err = codec->patch_ops.build_controls(codec);
2487         if (err < 0)
2488                 return err;
2489         return 0;
2490 }
2491
2492 /*
2493  * stream formats
2494  */
2495 struct hda_rate_tbl {
2496         unsigned int hz;
2497         unsigned int alsa_bits;
2498         unsigned int hda_fmt;
2499 };
2500
2501 static struct hda_rate_tbl rate_bits[] = {
2502         /* rate in Hz, ALSA rate bitmask, HDA format value */
2503
2504         /* autodetected value used in snd_hda_query_supported_pcm */
2505         { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2506         { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2507         { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2508         { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2509         { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2510         { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2511         { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2512         { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2513         { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2514         { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2515         { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2516 #define AC_PAR_PCM_RATE_BITS    11
2517         /* up to bits 10, 384kHZ isn't supported properly */
2518
2519         /* not autodetected value */
2520         { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2521
2522         { 0 } /* terminator */
2523 };
2524
2525 /**
2526  * snd_hda_calc_stream_format - calculate format bitset
2527  * @rate: the sample rate
2528  * @channels: the number of channels
2529  * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2530  * @maxbps: the max. bps
2531  *
2532  * Calculate the format bitset from the given rate, channels and th PCM format.
2533  *
2534  * Return zero if invalid.
2535  */
2536 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2537                                         unsigned int channels,
2538                                         unsigned int format,
2539                                         unsigned int maxbps)
2540 {
2541         int i;
2542         unsigned int val = 0;
2543
2544         for (i = 0; rate_bits[i].hz; i++)
2545                 if (rate_bits[i].hz == rate) {
2546                         val = rate_bits[i].hda_fmt;
2547                         break;
2548                 }
2549         if (!rate_bits[i].hz) {
2550                 snd_printdd("invalid rate %d\n", rate);
2551                 return 0;
2552         }
2553
2554         if (channels == 0 || channels > 8) {
2555                 snd_printdd("invalid channels %d\n", channels);
2556                 return 0;
2557         }
2558         val |= channels - 1;
2559
2560         switch (snd_pcm_format_width(format)) {
2561         case 8:  val |= 0x00; break;
2562         case 16: val |= 0x10; break;
2563         case 20:
2564         case 24:
2565         case 32:
2566                 if (maxbps >= 32)
2567                         val |= 0x40;
2568                 else if (maxbps >= 24)
2569                         val |= 0x30;
2570                 else
2571                         val |= 0x20;
2572                 break;
2573         default:
2574                 snd_printdd("invalid format width %d\n",
2575                             snd_pcm_format_width(format));
2576                 return 0;
2577         }
2578
2579         return val;
2580 }
2581 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2582
2583 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2584 {
2585         unsigned int val = 0;
2586         if (nid != codec->afg &&
2587             (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2588                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2589         if (!val || val == -1)
2590                 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2591         if (!val || val == -1)
2592                 return 0;
2593         return val;
2594 }
2595
2596 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2597 {
2598         return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2599                                get_pcm_param);
2600 }
2601
2602 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2603 {
2604         unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2605         if (!streams || streams == -1)
2606                 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2607         if (!streams || streams == -1)
2608                 return 0;
2609         return streams;
2610 }
2611
2612 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2613 {
2614         return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2615                                get_stream_param);
2616 }
2617
2618 /**
2619  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2620  * @codec: the HDA codec
2621  * @nid: NID to query
2622  * @ratesp: the pointer to store the detected rate bitflags
2623  * @formatsp: the pointer to store the detected formats
2624  * @bpsp: the pointer to store the detected format widths
2625  *
2626  * Queries the supported PCM rates and formats.  The NULL @ratesp, @formatsp
2627  * or @bsps argument is ignored.
2628  *
2629  * Returns 0 if successful, otherwise a negative error code.
2630  */
2631 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2632                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2633 {
2634         unsigned int i, val, wcaps;
2635
2636         wcaps = get_wcaps(codec, nid);
2637         val = query_pcm_param(codec, nid);
2638
2639         if (ratesp) {
2640                 u32 rates = 0;
2641                 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2642                         if (val & (1 << i))
2643                                 rates |= rate_bits[i].alsa_bits;
2644                 }
2645                 if (rates == 0) {
2646                         snd_printk(KERN_ERR "hda_codec: rates == 0 "
2647                                    "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2648                                         nid, val,
2649                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2650                         return -EIO;
2651                 }
2652                 *ratesp = rates;
2653         }
2654
2655         if (formatsp || bpsp) {
2656                 u64 formats = 0;
2657                 unsigned int streams, bps;
2658
2659                 streams = query_stream_param(codec, nid);
2660                 if (!streams)
2661                         return -EIO;
2662
2663                 bps = 0;
2664                 if (streams & AC_SUPFMT_PCM) {
2665                         if (val & AC_SUPPCM_BITS_8) {
2666                                 formats |= SNDRV_PCM_FMTBIT_U8;
2667                                 bps = 8;
2668                         }
2669                         if (val & AC_SUPPCM_BITS_16) {
2670                                 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2671                                 bps = 16;
2672                         }
2673                         if (wcaps & AC_WCAP_DIGITAL) {
2674                                 if (val & AC_SUPPCM_BITS_32)
2675                                         formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2676                                 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2677                                         formats |= SNDRV_PCM_FMTBIT_S32_LE;
2678                                 if (val & AC_SUPPCM_BITS_24)
2679                                         bps = 24;
2680                                 else if (val & AC_SUPPCM_BITS_20)
2681                                         bps = 20;
2682                         } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2683                                           AC_SUPPCM_BITS_32)) {
2684                                 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2685                                 if (val & AC_SUPPCM_BITS_32)
2686                                         bps = 32;
2687                                 else if (val & AC_SUPPCM_BITS_24)
2688                                         bps = 24;
2689                                 else if (val & AC_SUPPCM_BITS_20)
2690                                         bps = 20;
2691                         }
2692                 }
2693                 else if (streams == AC_SUPFMT_FLOAT32) {
2694                         /* should be exclusive */
2695                         formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2696                         bps = 32;
2697                 } else if (streams == AC_SUPFMT_AC3) {
2698                         /* should be exclusive */
2699                         /* temporary hack: we have still no proper support
2700                          * for the direct AC3 stream...
2701                          */
2702                         formats |= SNDRV_PCM_FMTBIT_U8;
2703                         bps = 8;
2704                 }
2705                 if (formats == 0) {
2706                         snd_printk(KERN_ERR "hda_codec: formats == 0 "
2707                                    "(nid=0x%x, val=0x%x, ovrd=%i, "
2708                                    "streams=0x%x)\n",
2709                                         nid, val,
2710                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2711                                         streams);
2712                         return -EIO;
2713                 }
2714                 if (formatsp)
2715                         *formatsp = formats;
2716                 if (bpsp)
2717                         *bpsp = bps;
2718         }
2719
2720         return 0;
2721 }
2722
2723 /**
2724  * snd_hda_is_supported_format - check whether the given node supports
2725  * the format val
2726  *
2727  * Returns 1 if supported, 0 if not.
2728  */
2729 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2730                                 unsigned int format)
2731 {
2732         int i;
2733         unsigned int val = 0, rate, stream;
2734
2735         val = query_pcm_param(codec, nid);
2736         if (!val)
2737                 return 0;
2738
2739         rate = format & 0xff00;
2740         for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2741                 if (rate_bits[i].hda_fmt == rate) {
2742                         if (val & (1 << i))
2743                                 break;
2744                         return 0;
2745                 }
2746         if (i >= AC_PAR_PCM_RATE_BITS)
2747                 return 0;
2748
2749         stream = query_stream_param(codec, nid);
2750         if (!stream)
2751                 return 0;
2752
2753         if (stream & AC_SUPFMT_PCM) {
2754                 switch (format & 0xf0) {
2755                 case 0x00:
2756                         if (!(val & AC_SUPPCM_BITS_8))
2757                                 return 0;
2758                         break;
2759                 case 0x10:
2760                         if (!(val & AC_SUPPCM_BITS_16))
2761                                 return 0;
2762                         break;
2763                 case 0x20:
2764                         if (!(val & AC_SUPPCM_BITS_20))
2765                                 return 0;
2766                         break;
2767                 case 0x30:
2768                         if (!(val & AC_SUPPCM_BITS_24))
2769                                 return 0;
2770                         break;
2771                 case 0x40:
2772                         if (!(val & AC_SUPPCM_BITS_32))
2773                                 return 0;
2774                         break;
2775                 default:
2776                         return 0;
2777                 }
2778         } else {
2779                 /* FIXME: check for float32 and AC3? */
2780         }
2781
2782         return 1;
2783 }
2784 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2785
2786 /*
2787  * PCM stuff
2788  */
2789 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2790                                       struct hda_codec *codec,
2791                                       struct snd_pcm_substream *substream)
2792 {
2793         return 0;
2794 }
2795
2796 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2797                                    struct hda_codec *codec,
2798                                    unsigned int stream_tag,
2799                                    unsigned int format,
2800                                    struct snd_pcm_substream *substream)
2801 {
2802         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2803         return 0;
2804 }
2805
2806 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2807                                    struct hda_codec *codec,
2808                                    struct snd_pcm_substream *substream)
2809 {
2810         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2811         return 0;
2812 }
2813
2814 static int set_pcm_default_values(struct hda_codec *codec,
2815                                   struct hda_pcm_stream *info)
2816 {
2817         int err;
2818
2819         /* query support PCM information from the given NID */
2820         if (info->nid && (!info->rates || !info->formats)) {
2821                 err = snd_hda_query_supported_pcm(codec, info->nid,
2822                                 info->rates ? NULL : &info->rates,
2823                                 info->formats ? NULL : &info->formats,
2824                                 info->maxbps ? NULL : &info->maxbps);
2825                 if (err < 0)
2826                         return err;
2827         }
2828         if (info->ops.open == NULL)
2829                 info->ops.open = hda_pcm_default_open_close;
2830         if (info->ops.close == NULL)
2831                 info->ops.close = hda_pcm_default_open_close;
2832         if (info->ops.prepare == NULL) {
2833                 if (snd_BUG_ON(!info->nid))
2834                         return -EINVAL;
2835                 info->ops.prepare = hda_pcm_default_prepare;
2836         }
2837         if (info->ops.cleanup == NULL) {
2838                 if (snd_BUG_ON(!info->nid))
2839                         return -EINVAL;
2840                 info->ops.cleanup = hda_pcm_default_cleanup;
2841         }
2842         return 0;
2843 }
2844
2845 /*
2846  * get the empty PCM device number to assign
2847  */
2848 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2849 {
2850         static const char *dev_name[HDA_PCM_NTYPES] = {
2851                 "Audio", "SPDIF", "HDMI", "Modem"
2852         };
2853         /* starting device index for each PCM type */
2854         static int dev_idx[HDA_PCM_NTYPES] = {
2855                 [HDA_PCM_TYPE_AUDIO] = 0,
2856                 [HDA_PCM_TYPE_SPDIF] = 1,
2857                 [HDA_PCM_TYPE_HDMI] = 3,
2858                 [HDA_PCM_TYPE_MODEM] = 6
2859         };
2860         /* normal audio device indices; not linear to keep compatibility */
2861         static int audio_idx[4] = { 0, 2, 4, 5 };
2862         int i, dev;
2863
2864         switch (type) {
2865         case HDA_PCM_TYPE_AUDIO:
2866                 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2867                         dev = audio_idx[i];
2868                         if (!test_bit(dev, bus->pcm_dev_bits))
2869                                 goto ok;
2870                 }
2871                 snd_printk(KERN_WARNING "Too many audio devices\n");
2872                 return -EAGAIN;
2873         case HDA_PCM_TYPE_SPDIF:
2874         case HDA_PCM_TYPE_HDMI:
2875         case HDA_PCM_TYPE_MODEM:
2876                 dev = dev_idx[type];
2877                 if (test_bit(dev, bus->pcm_dev_bits)) {
2878                         snd_printk(KERN_WARNING "%s already defined\n",
2879                                    dev_name[type]);
2880                         return -EAGAIN;
2881                 }
2882                 break;
2883         default:
2884                 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2885                 return -EINVAL;
2886         }
2887  ok:
2888         set_bit(dev, bus->pcm_dev_bits);
2889         return dev;
2890 }
2891
2892 /*
2893  * attach a new PCM stream
2894  */
2895 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2896 {
2897         struct hda_bus *bus = codec->bus;
2898         struct hda_pcm_stream *info;
2899         int stream, err;
2900
2901         if (snd_BUG_ON(!pcm->name))
2902                 return -EINVAL;
2903         for (stream = 0; stream < 2; stream++) {
2904                 info = &pcm->stream[stream];
2905                 if (info->substreams) {
2906                         err = set_pcm_default_values(codec, info);
2907                         if (err < 0)
2908                                 return err;
2909                 }
2910         }
2911         return bus->ops.attach_pcm(bus, codec, pcm);
2912 }
2913
2914 /* assign all PCMs of the given codec */
2915 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2916 {
2917         unsigned int pcm;
2918         int err;
2919
2920         if (!codec->num_pcms) {
2921                 if (!codec->patch_ops.build_pcms)
2922                         return 0;
2923                 err = codec->patch_ops.build_pcms(codec);
2924                 if (err < 0) {
2925                         printk(KERN_ERR "hda_codec: cannot build PCMs"
2926                                "for #%d (error %d)\n", codec->addr, err); 
2927                         err = snd_hda_codec_reset(codec);
2928                         if (err < 0) {
2929                                 printk(KERN_ERR
2930                                        "hda_codec: cannot revert codec\n");
2931                                 return err;
2932                         }
2933                 }
2934         }
2935         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2936                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2937                 int dev;
2938
2939                 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2940                         continue; /* no substreams assigned */
2941
2942                 if (!cpcm->pcm) {
2943                         dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2944                         if (dev < 0)
2945                                 continue; /* no fatal error */
2946                         cpcm->device = dev;
2947                         err = snd_hda_attach_pcm(codec, cpcm);
2948                         if (err < 0) {
2949                                 printk(KERN_ERR "hda_codec: cannot attach "
2950                                        "PCM stream %d for codec #%d\n",
2951                                        dev, codec->addr);
2952                                 continue; /* no fatal error */
2953                         }
2954                 }
2955         }
2956         return 0;
2957 }
2958
2959 /**
2960  * snd_hda_build_pcms - build PCM information
2961  * @bus: the BUS
2962  *
2963  * Create PCM information for each codec included in the bus.
2964  *
2965  * The build_pcms codec patch is requested to set up codec->num_pcms and
2966  * codec->pcm_info properly.  The array is referred by the top-level driver
2967  * to create its PCM instances.
2968  * The allocated codec->pcm_info should be released in codec->patch_ops.free
2969  * callback.
2970  *
2971  * At least, substreams, channels_min and channels_max must be filled for
2972  * each stream.  substreams = 0 indicates that the stream doesn't exist.
2973  * When rates and/or formats are zero, the supported values are queried
2974  * from the given nid.  The nid is used also by the default ops.prepare
2975  * and ops.cleanup callbacks.
2976  *
2977  * The driver needs to call ops.open in its open callback.  Similarly,
2978  * ops.close is supposed to be called in the close callback.
2979  * ops.prepare should be called in the prepare or hw_params callback
2980  * with the proper parameters for set up.
2981  * ops.cleanup should be called in hw_free for clean up of streams.
2982  *
2983  * This function returns 0 if successfull, or a negative error code.
2984  */
2985 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2986 {
2987         struct hda_codec *codec;
2988
2989         list_for_each_entry(codec, &bus->codec_list, list) {
2990                 int err = snd_hda_codec_build_pcms(codec);
2991                 if (err < 0)
2992                         return err;
2993         }
2994         return 0;
2995 }
2996 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2997
2998 /**
2999  * snd_hda_check_board_config - compare the current codec with the config table
3000  * @codec: the HDA codec
3001  * @num_configs: number of config enums
3002  * @models: array of model name strings
3003  * @tbl: configuration table, terminated by null entries
3004  *
3005  * Compares the modelname or PCI subsystem id of the current codec with the
3006  * given configuration table.  If a matching entry is found, returns its
3007  * config value (supposed to be 0 or positive).
3008  *
3009  * If no entries are matching, the function returns a negative value.
3010  */
3011 int snd_hda_check_board_config(struct hda_codec *codec,
3012                                int num_configs, const char **models,
3013                                const struct snd_pci_quirk *tbl)
3014 {
3015         if (codec->modelname && models) {
3016                 int i;
3017                 for (i = 0; i < num_configs; i++) {
3018                         if (models[i] &&
3019                             !strcmp(codec->modelname, models[i])) {
3020                                 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3021                                            "selected\n", models[i]);
3022                                 return i;
3023                         }
3024                 }
3025         }
3026
3027         if (!codec->bus->pci || !tbl)
3028                 return -1;
3029
3030         tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3031         if (!tbl)
3032                 return -1;
3033         if (tbl->value >= 0 && tbl->value < num_configs) {
3034 #ifdef CONFIG_SND_DEBUG_VERBOSE
3035                 char tmp[10];
3036                 const char *model = NULL;
3037                 if (models)
3038                         model = models[tbl->value];
3039                 if (!model) {
3040                         sprintf(tmp, "#%d", tbl->value);
3041                         model = tmp;
3042                 }
3043                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3044                             "for config %x:%x (%s)\n",
3045                             model, tbl->subvendor, tbl->subdevice,
3046                             (tbl->name ? tbl->name : "Unknown device"));
3047 #endif
3048                 return tbl->value;
3049         }
3050         return -1;
3051 }
3052 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3053
3054 /**
3055  * snd_hda_check_board_codec_sid_config - compare the current codec
3056                                           subsystem ID with the
3057                                           config table
3058
3059            This is important for Gateway notebooks with SB450 HDA Audio
3060            where the vendor ID of the PCI device is:
3061                 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3062            and the vendor/subvendor are found only at the codec.
3063
3064  * @codec: the HDA codec
3065  * @num_configs: number of config enums
3066  * @models: array of model name strings
3067  * @tbl: configuration table, terminated by null entries
3068  *
3069  * Compares the modelname or PCI subsystem id of the current codec with the
3070  * given configuration table.  If a matching entry is found, returns its
3071  * config value (supposed to be 0 or positive).
3072  *
3073  * If no entries are matching, the function returns a negative value.
3074  */
3075 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3076                                int num_configs, const char **models,
3077                                const struct snd_pci_quirk *tbl)
3078 {
3079         const struct snd_pci_quirk *q;
3080
3081         /* Search for codec ID */
3082         for (q = tbl; q->subvendor; q++) {
3083                 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3084
3085                 if (vendorid == codec->subsystem_id)
3086                         break;
3087         }
3088
3089         if (!q->subvendor)
3090                 return -1;
3091
3092         tbl = q;
3093
3094         if (tbl->value >= 0 && tbl->value < num_configs) {
3095 #ifdef CONFIG_SND_DEBUG_DETECT
3096                 char tmp[10];
3097                 const char *model = NULL;
3098                 if (models)
3099                         model = models[tbl->value];
3100                 if (!model) {
3101                         sprintf(tmp, "#%d", tbl->value);
3102                         model = tmp;
3103                 }
3104                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3105                             "for config %x:%x (%s)\n",
3106                             model, tbl->subvendor, tbl->subdevice,
3107                             (tbl->name ? tbl->name : "Unknown device"));
3108 #endif
3109                 return tbl->value;
3110         }
3111         return -1;
3112 }
3113 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3114
3115 /**
3116  * snd_hda_add_new_ctls - create controls from the array
3117  * @codec: the HDA codec
3118  * @knew: the array of struct snd_kcontrol_new
3119  *
3120  * This helper function creates and add new controls in the given array.
3121  * The array must be terminated with an empty entry as terminator.
3122  *
3123  * Returns 0 if successful, or a negative error code.
3124  */
3125 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3126 {
3127         int err;
3128
3129         for (; knew->name; knew++) {
3130                 struct snd_kcontrol *kctl;
3131                 kctl = snd_ctl_new1(knew, codec);
3132                 if (!kctl)
3133                         return -ENOMEM;
3134                 err = snd_hda_ctl_add(codec, kctl);
3135                 if (err < 0) {
3136                         if (!codec->addr)
3137                                 return err;
3138                         kctl = snd_ctl_new1(knew, codec);
3139                         if (!kctl)
3140                                 return -ENOMEM;
3141                         kctl->id.device = codec->addr;
3142                         err = snd_hda_ctl_add(codec, kctl);
3143                         if (err < 0)
3144                                 return err;
3145                 }
3146         }
3147         return 0;
3148 }
3149 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3150
3151 #ifdef CONFIG_SND_HDA_POWER_SAVE
3152 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3153                                 unsigned int power_state);
3154
3155 static void hda_power_work(struct work_struct *work)
3156 {
3157         struct hda_codec *codec =
3158                 container_of(work, struct hda_codec, power_work.work);
3159         struct hda_bus *bus = codec->bus;
3160
3161         if (!codec->power_on || codec->power_count) {
3162                 codec->power_transition = 0;
3163                 return;
3164         }
3165
3166         hda_call_codec_suspend(codec);
3167         if (bus->ops.pm_notify)
3168                 bus->ops.pm_notify(bus);
3169 }
3170
3171 static void hda_keep_power_on(struct hda_codec *codec)
3172 {
3173         codec->power_count++;
3174         codec->power_on = 1;
3175 }
3176
3177 void snd_hda_power_up(struct hda_codec *codec)
3178 {
3179         struct hda_bus *bus = codec->bus;
3180
3181         codec->power_count++;
3182         if (codec->power_on || codec->power_transition)
3183                 return;
3184
3185         codec->power_on = 1;
3186         if (bus->ops.pm_notify)
3187                 bus->ops.pm_notify(bus);
3188         hda_call_codec_resume(codec);
3189         cancel_delayed_work(&codec->power_work);
3190         codec->power_transition = 0;
3191 }
3192 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3193
3194 #define power_save(codec)       \
3195         ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3196
3197 #define power_save(codec)       \
3198         ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3199
3200 void snd_hda_power_down(struct hda_codec *codec)
3201 {
3202         --codec->power_count;
3203         if (!codec->power_on || codec->power_count || codec->power_transition)
3204                 return;
3205         if (power_save(codec)) {
3206                 codec->power_transition = 1; /* avoid reentrance */
3207                 queue_delayed_work(codec->bus->workq, &codec->power_work,
3208                                 msecs_to_jiffies(power_save(codec) * 1000));
3209         }
3210 }
3211 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3212
3213 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3214                                  struct hda_loopback_check *check,
3215                                  hda_nid_t nid)
3216 {
3217         struct hda_amp_list *p;
3218         int ch, v;
3219
3220         if (!check->amplist)
3221                 return 0;
3222         for (p = check->amplist; p->nid; p++) {
3223                 if (p->nid == nid)
3224                         break;
3225         }
3226         if (!p->nid)
3227                 return 0; /* nothing changed */
3228
3229         for (p = check->amplist; p->nid; p++) {
3230                 for (ch = 0; ch < 2; ch++) {
3231                         v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3232                                                    p->idx);
3233                         if (!(v & HDA_AMP_MUTE) && v > 0) {
3234                                 if (!check->power_on) {
3235                                         check->power_on = 1;
3236                                         snd_hda_power_up(codec);
3237                                 }
3238                                 return 1;
3239                         }
3240                 }
3241         }
3242         if (check->power_on) {
3243                 check->power_on = 0;
3244                 snd_hda_power_down(codec);
3245         }
3246         return 0;
3247 }
3248 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3249 #endif
3250
3251 /*
3252  * Channel mode helper
3253  */
3254 int snd_hda_ch_mode_info(struct hda_codec *codec,
3255                          struct snd_ctl_elem_info *uinfo,
3256                          const struct hda_channel_mode *chmode,
3257                          int num_chmodes)
3258 {
3259         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3260         uinfo->count = 1;
3261         uinfo->value.enumerated.items = num_chmodes;
3262         if (uinfo->value.enumerated.item >= num_chmodes)
3263                 uinfo->value.enumerated.item = num_chmodes - 1;
3264         sprintf(uinfo->value.enumerated.name, "%dch",
3265                 chmode[uinfo->value.enumerated.item].channels);
3266         return 0;
3267 }
3268 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3269
3270 int snd_hda_ch_mode_get(struct hda_codec *codec,
3271                         struct snd_ctl_elem_value *ucontrol,
3272                         const struct hda_channel_mode *chmode,
3273                         int num_chmodes,
3274                         int max_channels)
3275 {
3276         int i;
3277
3278         for (i = 0; i < num_chmodes; i++) {
3279                 if (max_channels == chmode[i].channels) {
3280                         ucontrol->value.enumerated.item[0] = i;
3281                         break;
3282                 }
3283         }
3284         return 0;
3285 }
3286 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3287
3288 int snd_hda_ch_mode_put(struct hda_codec *codec,
3289                         struct snd_ctl_elem_value *ucontrol,
3290                         const struct hda_channel_mode *chmode,
3291                         int num_chmodes,
3292                         int *max_channelsp)
3293 {
3294         unsigned int mode;
3295
3296         mode = ucontrol->value.enumerated.item[0];
3297         if (mode >= num_chmodes)
3298                 return -EINVAL;
3299         if (*max_channelsp == chmode[mode].channels)
3300                 return 0;
3301         /* change the current channel setting */
3302         *max_channelsp = chmode[mode].channels;
3303         if (chmode[mode].sequence)
3304                 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3305         return 1;
3306 }
3307 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3308
3309 /*
3310  * input MUX helper
3311  */
3312 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3313                            struct snd_ctl_elem_info *uinfo)
3314 {
3315         unsigned int index;
3316
3317         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3318         uinfo->count = 1;
3319         uinfo->value.enumerated.items = imux->num_items;
3320         if (!imux->num_items)
3321                 return 0;
3322         index = uinfo->value.enumerated.item;
3323         if (index >= imux->num_items)
3324                 index = imux->num_items - 1;
3325         strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3326         return 0;
3327 }
3328 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3329
3330 int snd_hda_input_mux_put(struct hda_codec *codec,
3331                           const struct hda_input_mux *imux,
3332                           struct snd_ctl_elem_value *ucontrol,
3333                           hda_nid_t nid,
3334                           unsigned int *cur_val)
3335 {
3336         unsigned int idx;
3337
3338         if (!imux->num_items)
3339                 return 0;
3340         idx = ucontrol->value.enumerated.item[0];
3341         if (idx >= imux->num_items)
3342                 idx = imux->num_items - 1;
3343         if (*cur_val == idx)
3344                 return 0;
3345         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3346                                   imux->items[idx].index);
3347         *cur_val = idx;
3348         return 1;
3349 }
3350 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3351
3352
3353 /*
3354  * Multi-channel / digital-out PCM helper functions
3355  */
3356
3357 /* setup SPDIF output stream */
3358 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3359                                  unsigned int stream_tag, unsigned int format)
3360 {
3361         /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3362         if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3363                 set_dig_out_convert(codec, nid, 
3364                                     codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3365                                     -1);
3366         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3367         if (codec->slave_dig_outs) {
3368                 hda_nid_t *d;
3369                 for (d = codec->slave_dig_outs; *d; d++)
3370                         snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3371                                                    format);
3372         }
3373         /* turn on again (if needed) */
3374         if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3375                 set_dig_out_convert(codec, nid,
3376                                     codec->spdif_ctls & 0xff, -1);
3377 }
3378
3379 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3380 {
3381         snd_hda_codec_cleanup_stream(codec, nid);
3382         if (codec->slave_dig_outs) {
3383                 hda_nid_t *d;
3384                 for (d = codec->slave_dig_outs; *d; d++)
3385                         snd_hda_codec_cleanup_stream(codec, *d);
3386         }
3387 }
3388
3389 /*
3390  * open the digital out in the exclusive mode
3391  */
3392 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3393                                struct hda_multi_out *mout)
3394 {
3395         mutex_lock(&codec->spdif_mutex);
3396         if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3397                 /* already opened as analog dup; reset it once */
3398                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3399         mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3400         mutex_unlock(&codec->spdif_mutex);
3401         return 0;
3402 }
3403 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3404
3405 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3406                                   struct hda_multi_out *mout,
3407                                   unsigned int stream_tag,
3408                                   unsigned int format,
3409                                   struct snd_pcm_substream *substream)
3410 {
3411         mutex_lock(&codec->spdif_mutex);
3412         setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3413         mutex_unlock(&codec->spdif_mutex);
3414         return 0;
3415 }
3416 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3417
3418 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3419                                   struct hda_multi_out *mout)
3420 {
3421         mutex_lock(&codec->spdif_mutex);
3422         cleanup_dig_out_stream(codec, mout->dig_out_nid);
3423         mutex_unlock(&codec->spdif_mutex);
3424         return 0;
3425 }
3426 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3427
3428 /*
3429  * release the digital out
3430  */
3431 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3432                                 struct hda_multi_out *mout)
3433 {
3434         mutex_lock(&codec->spdif_mutex);
3435         mout->dig_out_used = 0;
3436         mutex_unlock(&codec->spdif_mutex);
3437         return 0;
3438 }
3439 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3440
3441 /*
3442  * set up more restrictions for analog out
3443  */
3444 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3445                                   struct hda_multi_out *mout,
3446                                   struct snd_pcm_substream *substream,
3447                                   struct hda_pcm_stream *hinfo)
3448 {
3449         struct snd_pcm_runtime *runtime = substream->runtime;
3450         runtime->hw.channels_max = mout->max_channels;
3451         if (mout->dig_out_nid) {
3452                 if (!mout->analog_rates) {
3453                         mout->analog_rates = hinfo->rates;
3454                         mout->analog_formats = hinfo->formats;
3455                         mout->analog_maxbps = hinfo->maxbps;
3456                 } else {
3457                         runtime->hw.rates = mout->analog_rates;
3458                         runtime->hw.formats = mout->analog_formats;
3459                         hinfo->maxbps = mout->analog_maxbps;
3460                 }
3461                 if (!mout->spdif_rates) {
3462                         snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3463                                                     &mout->spdif_rates,
3464                                                     &mout->spdif_formats,
3465                                                     &mout->spdif_maxbps);
3466                 }
3467                 mutex_lock(&codec->spdif_mutex);
3468                 if (mout->share_spdif) {
3469                         runtime->hw.rates &= mout->spdif_rates;
3470                         runtime->hw.formats &= mout->spdif_formats;
3471                         if (mout->spdif_maxbps < hinfo->maxbps)
3472                                 hinfo->maxbps = mout->spdif_maxbps;
3473                 }
3474                 mutex_unlock(&codec->spdif_mutex);
3475         }
3476         return snd_pcm_hw_constraint_step(substream->runtime, 0,
3477                                           SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3478 }
3479 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3480
3481 /*
3482  * set up the i/o for analog out
3483  * when the digital out is available, copy the front out to digital out, too.
3484  */
3485 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3486                                      struct hda_multi_out *mout,
3487                                      unsigned int stream_tag,
3488                                      unsigned int format,
3489                                      struct snd_pcm_substream *substream)
3490 {
3491         hda_nid_t *nids = mout->dac_nids;
3492         int chs = substream->runtime->channels;
3493         int i;
3494
3495         mutex_lock(&codec->spdif_mutex);
3496         if (mout->dig_out_nid && mout->share_spdif &&
3497             mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3498                 if (chs == 2 &&
3499                     snd_hda_is_supported_format(codec, mout->dig_out_nid,
3500                                                 format) &&
3501                     !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3502                         mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3503                         setup_dig_out_stream(codec, mout->dig_out_nid,
3504                                              stream_tag, format);
3505                 } else {
3506                         mout->dig_out_used = 0;
3507                         cleanup_dig_out_stream(codec, mout->dig_out_nid);
3508                 }
3509         }
3510         mutex_unlock(&codec->spdif_mutex);
3511
3512         /* front */
3513         snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3514                                    0, format);
3515         if (!mout->no_share_stream &&
3516             mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3517                 /* headphone out will just decode front left/right (stereo) */
3518                 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3519                                            0, format);
3520         /* extra outputs copied from front */
3521         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3522                 if (!mout->no_share_stream && mout->extra_out_nid[i])
3523                         snd_hda_codec_setup_stream(codec,
3524                                                    mout->extra_out_nid[i],
3525                                                    stream_tag, 0, format);
3526
3527         /* surrounds */
3528         for (i = 1; i < mout->num_dacs; i++) {
3529                 if (chs >= (i + 1) * 2) /* independent out */
3530                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3531                                                    i * 2, format);
3532                 else if (!mout->no_share_stream) /* copy front */
3533                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3534                                                    0, format);
3535         }
3536         return 0;
3537 }
3538 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3539
3540 /*
3541  * clean up the setting for analog out
3542  */
3543 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3544                                      struct hda_multi_out *mout)
3545 {
3546         hda_nid_t *nids = mout->dac_nids;
3547         int i;
3548
3549         for (i = 0; i < mout->num_dacs; i++)
3550                 snd_hda_codec_cleanup_stream(codec, nids[i]);
3551         if (mout->hp_nid)
3552                 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3553         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3554                 if (mout->extra_out_nid[i])
3555                         snd_hda_codec_cleanup_stream(codec,
3556                                                      mout->extra_out_nid[i]);
3557         mutex_lock(&codec->spdif_mutex);
3558         if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3559                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3560                 mout->dig_out_used = 0;
3561         }
3562         mutex_unlock(&codec->spdif_mutex);
3563         return 0;
3564 }
3565 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3566
3567 /*
3568  * Helper for automatic pin configuration
3569  */
3570
3571 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3572 {
3573         for (; *list; list++)
3574                 if (*list == nid)
3575                         return 1;
3576         return 0;
3577 }
3578
3579
3580 /*
3581  * Sort an associated group of pins according to their sequence numbers.
3582  */
3583 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3584                                   int num_pins)
3585 {
3586         int i, j;
3587         short seq;
3588         hda_nid_t nid;
3589         
3590         for (i = 0; i < num_pins; i++) {
3591                 for (j = i + 1; j < num_pins; j++) {
3592                         if (sequences[i] > sequences[j]) {
3593                                 seq = sequences[i];
3594                                 sequences[i] = sequences[j];
3595                                 sequences[j] = seq;
3596                                 nid = pins[i];
3597                                 pins[i] = pins[j];
3598                                 pins[j] = nid;
3599                         }
3600                 }
3601         }
3602 }
3603
3604
3605 /*
3606  * Parse all pin widgets and store the useful pin nids to cfg
3607  *
3608  * The number of line-outs or any primary output is stored in line_outs,
3609  * and the corresponding output pins are assigned to line_out_pins[],
3610  * in the order of front, rear, CLFE, side, ...
3611  *
3612  * If more extra outputs (speaker and headphone) are found, the pins are
3613  * assisnged to hp_pins[] and speaker_pins[], respectively.  If no line-out jack
3614  * is detected, one of speaker of HP pins is assigned as the primary
3615  * output, i.e. to line_out_pins[0].  So, line_outs is always positive
3616  * if any analog output exists.
3617  * 
3618  * The analog input pins are assigned to input_pins array.
3619  * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3620  * respectively.
3621  */
3622 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3623                                  struct auto_pin_cfg *cfg,
3624                                  hda_nid_t *ignore_nids)
3625 {
3626         hda_nid_t nid, end_nid;
3627         short seq, assoc_line_out, assoc_speaker;
3628         short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3629         short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3630         short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3631
3632         memset(cfg, 0, sizeof(*cfg));