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