ALSA: hda - Introduce hda_call_check_power_status() helper
[~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         hda_call_check_power_status(codec, nid);
2232         snd_hda_power_down(codec);
2233         return change;
2234 }
2235 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2236
2237 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2238 /**
2239  * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2240  *
2241  * This function calls snd_hda_enable_beep_device(), which behaves differently
2242  * depending on beep_mode option.
2243  */
2244 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2245                                       struct snd_ctl_elem_value *ucontrol)
2246 {
2247         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2248         long *valp = ucontrol->value.integer.value;
2249
2250         snd_hda_enable_beep_device(codec, *valp);
2251         return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2252 }
2253 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
2254 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2255
2256 /*
2257  * bound volume controls
2258  *
2259  * bind multiple volumes (# indices, from 0)
2260  */
2261
2262 #define AMP_VAL_IDX_SHIFT       19
2263 #define AMP_VAL_IDX_MASK        (0x0f<<19)
2264
2265 /**
2266  * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2267  *
2268  * The control element is supposed to have the private_value field
2269  * set up via HDA_BIND_MUTE*() macros.
2270  */
2271 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2272                                   struct snd_ctl_elem_value *ucontrol)
2273 {
2274         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2275         unsigned long pval;
2276         int err;
2277
2278         mutex_lock(&codec->control_mutex);
2279         pval = kcontrol->private_value;
2280         kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2281         err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2282         kcontrol->private_value = pval;
2283         mutex_unlock(&codec->control_mutex);
2284         return err;
2285 }
2286 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2287
2288 /**
2289  * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2290  *
2291  * The control element is supposed to have the private_value field
2292  * set up via HDA_BIND_MUTE*() macros.
2293  */
2294 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2295                                   struct snd_ctl_elem_value *ucontrol)
2296 {
2297         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2298         unsigned long pval;
2299         int i, indices, err = 0, change = 0;
2300
2301         mutex_lock(&codec->control_mutex);
2302         pval = kcontrol->private_value;
2303         indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2304         for (i = 0; i < indices; i++) {
2305                 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2306                         (i << AMP_VAL_IDX_SHIFT);
2307                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2308                 if (err < 0)
2309                         break;
2310                 change |= err;
2311         }
2312         kcontrol->private_value = pval;
2313         mutex_unlock(&codec->control_mutex);
2314         return err < 0 ? err : change;
2315 }
2316 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2317
2318 /**
2319  * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2320  *
2321  * The control element is supposed to have the private_value field
2322  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2323  */
2324 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2325                                  struct snd_ctl_elem_info *uinfo)
2326 {
2327         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2328         struct hda_bind_ctls *c;
2329         int err;
2330
2331         mutex_lock(&codec->control_mutex);
2332         c = (struct hda_bind_ctls *)kcontrol->private_value;
2333         kcontrol->private_value = *c->values;
2334         err = c->ops->info(kcontrol, uinfo);
2335         kcontrol->private_value = (long)c;
2336         mutex_unlock(&codec->control_mutex);
2337         return err;
2338 }
2339 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2340
2341 /**
2342  * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2343  *
2344  * The control element is supposed to have the private_value field
2345  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2346  */
2347 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2348                                 struct snd_ctl_elem_value *ucontrol)
2349 {
2350         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2351         struct hda_bind_ctls *c;
2352         int err;
2353
2354         mutex_lock(&codec->control_mutex);
2355         c = (struct hda_bind_ctls *)kcontrol->private_value;
2356         kcontrol->private_value = *c->values;
2357         err = c->ops->get(kcontrol, ucontrol);
2358         kcontrol->private_value = (long)c;
2359         mutex_unlock(&codec->control_mutex);
2360         return err;
2361 }
2362 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2363
2364 /**
2365  * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2366  *
2367  * The control element is supposed to have the private_value field
2368  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2369  */
2370 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2371                                 struct snd_ctl_elem_value *ucontrol)
2372 {
2373         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2374         struct hda_bind_ctls *c;
2375         unsigned long *vals;
2376         int err = 0, change = 0;
2377
2378         mutex_lock(&codec->control_mutex);
2379         c = (struct hda_bind_ctls *)kcontrol->private_value;
2380         for (vals = c->values; *vals; vals++) {
2381                 kcontrol->private_value = *vals;
2382                 err = c->ops->put(kcontrol, ucontrol);
2383                 if (err < 0)
2384                         break;
2385                 change |= err;
2386         }
2387         kcontrol->private_value = (long)c;
2388         mutex_unlock(&codec->control_mutex);
2389         return err < 0 ? err : change;
2390 }
2391 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2392
2393 /**
2394  * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2395  *
2396  * The control element is supposed to have the private_value field
2397  * set up via HDA_BIND_VOL() macro.
2398  */
2399 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2400                            unsigned int size, unsigned int __user *tlv)
2401 {
2402         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2403         struct hda_bind_ctls *c;
2404         int err;
2405
2406         mutex_lock(&codec->control_mutex);
2407         c = (struct hda_bind_ctls *)kcontrol->private_value;
2408         kcontrol->private_value = *c->values;
2409         err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2410         kcontrol->private_value = (long)c;
2411         mutex_unlock(&codec->control_mutex);
2412         return err;
2413 }
2414 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2415
2416 struct hda_ctl_ops snd_hda_bind_vol = {
2417         .info = snd_hda_mixer_amp_volume_info,
2418         .get = snd_hda_mixer_amp_volume_get,
2419         .put = snd_hda_mixer_amp_volume_put,
2420         .tlv = snd_hda_mixer_amp_tlv
2421 };
2422 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2423
2424 struct hda_ctl_ops snd_hda_bind_sw = {
2425         .info = snd_hda_mixer_amp_switch_info,
2426         .get = snd_hda_mixer_amp_switch_get,
2427         .put = snd_hda_mixer_amp_switch_put,
2428         .tlv = snd_hda_mixer_amp_tlv
2429 };
2430 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2431
2432 /*
2433  * SPDIF out controls
2434  */
2435
2436 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2437                                    struct snd_ctl_elem_info *uinfo)
2438 {
2439         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2440         uinfo->count = 1;
2441         return 0;
2442 }
2443
2444 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2445                                    struct snd_ctl_elem_value *ucontrol)
2446 {
2447         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2448                                            IEC958_AES0_NONAUDIO |
2449                                            IEC958_AES0_CON_EMPHASIS_5015 |
2450                                            IEC958_AES0_CON_NOT_COPYRIGHT;
2451         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2452                                            IEC958_AES1_CON_ORIGINAL;
2453         return 0;
2454 }
2455
2456 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2457                                    struct snd_ctl_elem_value *ucontrol)
2458 {
2459         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2460                                            IEC958_AES0_NONAUDIO |
2461                                            IEC958_AES0_PRO_EMPHASIS_5015;
2462         return 0;
2463 }
2464
2465 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2466                                      struct snd_ctl_elem_value *ucontrol)
2467 {
2468         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2469
2470         ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
2471         ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
2472         ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
2473         ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
2474
2475         return 0;
2476 }
2477
2478 /* convert from SPDIF status bits to HDA SPDIF bits
2479  * bit 0 (DigEn) is always set zero (to be filled later)
2480  */
2481 static unsigned short convert_from_spdif_status(unsigned int sbits)
2482 {
2483         unsigned short val = 0;
2484
2485         if (sbits & IEC958_AES0_PROFESSIONAL)
2486                 val |= AC_DIG1_PROFESSIONAL;
2487         if (sbits & IEC958_AES0_NONAUDIO)
2488                 val |= AC_DIG1_NONAUDIO;
2489         if (sbits & IEC958_AES0_PROFESSIONAL) {
2490                 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2491                     IEC958_AES0_PRO_EMPHASIS_5015)
2492                         val |= AC_DIG1_EMPHASIS;
2493         } else {
2494                 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2495                     IEC958_AES0_CON_EMPHASIS_5015)
2496                         val |= AC_DIG1_EMPHASIS;
2497                 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2498                         val |= AC_DIG1_COPYRIGHT;
2499                 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2500                         val |= AC_DIG1_LEVEL;
2501                 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2502         }
2503         return val;
2504 }
2505
2506 /* convert to SPDIF status bits from HDA SPDIF bits
2507  */
2508 static unsigned int convert_to_spdif_status(unsigned short val)
2509 {
2510         unsigned int sbits = 0;
2511
2512         if (val & AC_DIG1_NONAUDIO)
2513                 sbits |= IEC958_AES0_NONAUDIO;
2514         if (val & AC_DIG1_PROFESSIONAL)
2515                 sbits |= IEC958_AES0_PROFESSIONAL;
2516         if (sbits & IEC958_AES0_PROFESSIONAL) {
2517                 if (sbits & AC_DIG1_EMPHASIS)
2518                         sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2519         } else {
2520                 if (val & AC_DIG1_EMPHASIS)
2521                         sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2522                 if (!(val & AC_DIG1_COPYRIGHT))
2523                         sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2524                 if (val & AC_DIG1_LEVEL)
2525                         sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2526                 sbits |= val & (0x7f << 8);
2527         }
2528         return sbits;
2529 }
2530
2531 /* set digital convert verbs both for the given NID and its slaves */
2532 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2533                         int verb, int val)
2534 {
2535         hda_nid_t *d;
2536
2537         snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2538         d = codec->slave_dig_outs;
2539         if (!d)
2540                 return;
2541         for (; *d; d++)
2542                 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2543 }
2544
2545 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2546                                        int dig1, int dig2)
2547 {
2548         if (dig1 != -1)
2549                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2550         if (dig2 != -1)
2551                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2552 }
2553
2554 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2555                                      struct snd_ctl_elem_value *ucontrol)
2556 {
2557         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2558         hda_nid_t nid = kcontrol->private_value;
2559         unsigned short val;
2560         int change;
2561
2562         mutex_lock(&codec->spdif_mutex);
2563         codec->spdif_status = ucontrol->value.iec958.status[0] |
2564                 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2565                 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2566                 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2567         val = convert_from_spdif_status(codec->spdif_status);
2568         val |= codec->spdif_ctls & 1;
2569         change = codec->spdif_ctls != val;
2570         codec->spdif_ctls = val;
2571
2572         if (change)
2573                 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2574
2575         mutex_unlock(&codec->spdif_mutex);
2576         return change;
2577 }
2578
2579 #define snd_hda_spdif_out_switch_info   snd_ctl_boolean_mono_info
2580
2581 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2582                                         struct snd_ctl_elem_value *ucontrol)
2583 {
2584         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2585
2586         ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
2587         return 0;
2588 }
2589
2590 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2591                                         struct snd_ctl_elem_value *ucontrol)
2592 {
2593         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2594         hda_nid_t nid = kcontrol->private_value;
2595         unsigned short val;
2596         int change;
2597
2598         mutex_lock(&codec->spdif_mutex);
2599         val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2600         if (ucontrol->value.integer.value[0])
2601                 val |= AC_DIG1_ENABLE;
2602         change = codec->spdif_ctls != val;
2603         if (change) {
2604                 codec->spdif_ctls = val;
2605                 set_dig_out_convert(codec, nid, val & 0xff, -1);
2606                 /* unmute amp switch (if any) */
2607                 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2608                     (val & AC_DIG1_ENABLE))
2609                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2610                                                  HDA_AMP_MUTE, 0);
2611         }
2612         mutex_unlock(&codec->spdif_mutex);
2613         return change;
2614 }
2615
2616 static struct snd_kcontrol_new dig_mixes[] = {
2617         {
2618                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2619                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2620                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
2621                 .info = snd_hda_spdif_mask_info,
2622                 .get = snd_hda_spdif_cmask_get,
2623         },
2624         {
2625                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2626                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2627                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
2628                 .info = snd_hda_spdif_mask_info,
2629                 .get = snd_hda_spdif_pmask_get,
2630         },
2631         {
2632                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2633                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
2634                 .info = snd_hda_spdif_mask_info,
2635                 .get = snd_hda_spdif_default_get,
2636                 .put = snd_hda_spdif_default_put,
2637         },
2638         {
2639                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2640                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
2641                 .info = snd_hda_spdif_out_switch_info,
2642                 .get = snd_hda_spdif_out_switch_get,
2643                 .put = snd_hda_spdif_out_switch_put,
2644         },
2645         { } /* end */
2646 };
2647
2648 #define SPDIF_MAX_IDX   4       /* 4 instances should be enough to probe */
2649
2650 /**
2651  * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2652  * @codec: the HDA codec
2653  * @nid: audio out widget NID
2654  *
2655  * Creates controls related with the SPDIF output.
2656  * Called from each patch supporting the SPDIF out.
2657  *
2658  * Returns 0 if successful, or a negative error code.
2659  */
2660 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2661 {
2662         int err;
2663         struct snd_kcontrol *kctl;
2664         struct snd_kcontrol_new *dig_mix;
2665         int idx;
2666
2667         for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2668                 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2669                                              idx))
2670                         break;
2671         }
2672         if (idx >= SPDIF_MAX_IDX) {
2673                 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2674                 return -EBUSY;
2675         }
2676         for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2677                 kctl = snd_ctl_new1(dig_mix, codec);
2678                 if (!kctl)
2679                         return -ENOMEM;
2680                 kctl->id.index = idx;
2681                 kctl->private_value = nid;
2682                 err = snd_hda_ctl_add(codec, nid, kctl);
2683                 if (err < 0)
2684                         return err;
2685         }
2686         codec->spdif_ctls =
2687                 snd_hda_codec_read(codec, nid, 0,
2688                                    AC_VERB_GET_DIGI_CONVERT_1, 0);
2689         codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2690         return 0;
2691 }
2692 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2693
2694 /*
2695  * SPDIF sharing with analog output
2696  */
2697 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2698                               struct snd_ctl_elem_value *ucontrol)
2699 {
2700         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2701         ucontrol->value.integer.value[0] = mout->share_spdif;
2702         return 0;
2703 }
2704
2705 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2706                               struct snd_ctl_elem_value *ucontrol)
2707 {
2708         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2709         mout->share_spdif = !!ucontrol->value.integer.value[0];
2710         return 0;
2711 }
2712
2713 static struct snd_kcontrol_new spdif_share_sw = {
2714         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2715         .name = "IEC958 Default PCM Playback Switch",
2716         .info = snd_ctl_boolean_mono_info,
2717         .get = spdif_share_sw_get,
2718         .put = spdif_share_sw_put,
2719 };
2720
2721 /**
2722  * snd_hda_create_spdif_share_sw - create Default PCM switch
2723  * @codec: the HDA codec
2724  * @mout: multi-out instance
2725  */
2726 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2727                                   struct hda_multi_out *mout)
2728 {
2729         if (!mout->dig_out_nid)
2730                 return 0;
2731         /* ATTENTION: here mout is passed as private_data, instead of codec */
2732         return snd_hda_ctl_add(codec, mout->dig_out_nid,
2733                               snd_ctl_new1(&spdif_share_sw, mout));
2734 }
2735 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2736
2737 /*
2738  * SPDIF input
2739  */
2740
2741 #define snd_hda_spdif_in_switch_info    snd_hda_spdif_out_switch_info
2742
2743 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2744                                        struct snd_ctl_elem_value *ucontrol)
2745 {
2746         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2747
2748         ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2749         return 0;
2750 }
2751
2752 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2753                                        struct snd_ctl_elem_value *ucontrol)
2754 {
2755         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2756         hda_nid_t nid = kcontrol->private_value;
2757         unsigned int val = !!ucontrol->value.integer.value[0];
2758         int change;
2759
2760         mutex_lock(&codec->spdif_mutex);
2761         change = codec->spdif_in_enable != val;
2762         if (change) {
2763                 codec->spdif_in_enable = val;
2764                 snd_hda_codec_write_cache(codec, nid, 0,
2765                                           AC_VERB_SET_DIGI_CONVERT_1, val);
2766         }
2767         mutex_unlock(&codec->spdif_mutex);
2768         return change;
2769 }
2770
2771 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2772                                        struct snd_ctl_elem_value *ucontrol)
2773 {
2774         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2775         hda_nid_t nid = kcontrol->private_value;
2776         unsigned short val;
2777         unsigned int sbits;
2778
2779         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2780         sbits = convert_to_spdif_status(val);
2781         ucontrol->value.iec958.status[0] = sbits;
2782         ucontrol->value.iec958.status[1] = sbits >> 8;
2783         ucontrol->value.iec958.status[2] = sbits >> 16;
2784         ucontrol->value.iec958.status[3] = sbits >> 24;
2785         return 0;
2786 }
2787
2788 static struct snd_kcontrol_new dig_in_ctls[] = {
2789         {
2790                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2791                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
2792                 .info = snd_hda_spdif_in_switch_info,
2793                 .get = snd_hda_spdif_in_switch_get,
2794                 .put = snd_hda_spdif_in_switch_put,
2795         },
2796         {
2797                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2798                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2799                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
2800                 .info = snd_hda_spdif_mask_info,
2801                 .get = snd_hda_spdif_in_status_get,
2802         },
2803         { } /* end */
2804 };
2805
2806 /**
2807  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2808  * @codec: the HDA codec
2809  * @nid: audio in widget NID
2810  *
2811  * Creates controls related with the SPDIF input.
2812  * Called from each patch supporting the SPDIF in.
2813  *
2814  * Returns 0 if successful, or a negative error code.
2815  */
2816 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2817 {
2818         int err;
2819         struct snd_kcontrol *kctl;
2820         struct snd_kcontrol_new *dig_mix;
2821         int idx;
2822
2823         for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2824                 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2825                                              idx))
2826                         break;
2827         }
2828         if (idx >= SPDIF_MAX_IDX) {
2829                 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2830                 return -EBUSY;
2831         }
2832         for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2833                 kctl = snd_ctl_new1(dig_mix, codec);
2834                 if (!kctl)
2835                         return -ENOMEM;
2836                 kctl->private_value = nid;
2837                 err = snd_hda_ctl_add(codec, nid, kctl);
2838                 if (err < 0)
2839                         return err;
2840         }
2841         codec->spdif_in_enable =
2842                 snd_hda_codec_read(codec, nid, 0,
2843                                    AC_VERB_GET_DIGI_CONVERT_1, 0) &
2844                 AC_DIG1_ENABLE;
2845         return 0;
2846 }
2847 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2848
2849 #ifdef SND_HDA_NEEDS_RESUME
2850 /*
2851  * command cache
2852  */
2853
2854 /* build a 32bit cache key with the widget id and the command parameter */
2855 #define build_cmd_cache_key(nid, verb)  ((verb << 8) | nid)
2856 #define get_cmd_cache_nid(key)          ((key) & 0xff)
2857 #define get_cmd_cache_cmd(key)          (((key) >> 8) & 0xffff)
2858
2859 /**
2860  * snd_hda_codec_write_cache - send a single command with caching
2861  * @codec: the HDA codec
2862  * @nid: NID to send the command
2863  * @direct: direct flag
2864  * @verb: the verb to send
2865  * @parm: the parameter for the verb
2866  *
2867  * Send a single command without waiting for response.
2868  *
2869  * Returns 0 if successful, or a negative error code.
2870  */
2871 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2872                               int direct, unsigned int verb, unsigned int parm)
2873 {
2874         int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2875         struct hda_cache_head *c;
2876         u32 key;
2877
2878         if (err < 0)
2879                 return err;
2880         /* parm may contain the verb stuff for get/set amp */
2881         verb = verb | (parm >> 8);
2882         parm &= 0xff;
2883         key = build_cmd_cache_key(nid, verb);
2884         mutex_lock(&codec->bus->cmd_mutex);
2885         c = get_alloc_hash(&codec->cmd_cache, key);
2886         if (c)
2887                 c->val = parm;
2888         mutex_unlock(&codec->bus->cmd_mutex);
2889         return 0;
2890 }
2891 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2892
2893 /**
2894  * snd_hda_codec_update_cache - check cache and write the cmd only when needed
2895  * @codec: the HDA codec
2896  * @nid: NID to send the command
2897  * @direct: direct flag
2898  * @verb: the verb to send
2899  * @parm: the parameter for the verb
2900  *
2901  * This function works like snd_hda_codec_write_cache(), but it doesn't send
2902  * command if the parameter is already identical with the cached value.
2903  * If not, it sends the command and refreshes the cache.
2904  *
2905  * Returns 0 if successful, or a negative error code.
2906  */
2907 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
2908                                int direct, unsigned int verb, unsigned int parm)
2909 {
2910         struct hda_cache_head *c;
2911         u32 key;
2912
2913         /* parm may contain the verb stuff for get/set amp */
2914         verb = verb | (parm >> 8);
2915         parm &= 0xff;
2916         key = build_cmd_cache_key(nid, verb);
2917         mutex_lock(&codec->bus->cmd_mutex);
2918         c = get_hash(&codec->cmd_cache, key);
2919         if (c && c->val == parm) {
2920                 mutex_unlock(&codec->bus->cmd_mutex);
2921                 return 0;
2922         }
2923         mutex_unlock(&codec->bus->cmd_mutex);
2924         return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
2925 }
2926 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
2927
2928 /**
2929  * snd_hda_codec_resume_cache - Resume the all commands from the cache
2930  * @codec: HD-audio codec
2931  *
2932  * Execute all verbs recorded in the command caches to resume.
2933  */
2934 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2935 {
2936         struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2937         int i;
2938
2939         for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2940                 u32 key = buffer->key;
2941                 if (!key)
2942                         continue;
2943                 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2944                                     get_cmd_cache_cmd(key), buffer->val);
2945         }
2946 }
2947 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2948
2949 /**
2950  * snd_hda_sequence_write_cache - sequence writes with caching
2951  * @codec: the HDA codec
2952  * @seq: VERB array to send
2953  *
2954  * Send the commands sequentially from the given array.
2955  * Thte commands are recorded on cache for power-save and resume.
2956  * The array must be terminated with NID=0.
2957  */
2958 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2959                                   const struct hda_verb *seq)
2960 {
2961         for (; seq->nid; seq++)
2962                 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2963                                           seq->param);
2964 }
2965 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2966 #endif /* SND_HDA_NEEDS_RESUME */
2967
2968 /*
2969  * set power state of the codec
2970  */
2971 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2972                                 unsigned int power_state)
2973 {
2974         hda_nid_t nid;
2975         int i;
2976
2977         /* this delay seems necessary to avoid click noise at power-down */
2978         if (power_state == AC_PWRST_D3)
2979                 msleep(100);
2980         snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2981                             power_state);
2982         /* partial workaround for "azx_get_response timeout" */
2983         if (power_state == AC_PWRST_D0 &&
2984             (codec->vendor_id & 0xffff0000) == 0x14f10000)
2985                 msleep(10);
2986
2987         nid = codec->start_nid;
2988         for (i = 0; i < codec->num_nodes; i++, nid++) {
2989                 unsigned int wcaps = get_wcaps(codec, nid);
2990                 if (wcaps & AC_WCAP_POWER) {
2991                         unsigned int wid_type = get_wcaps_type(wcaps);
2992                         if (power_state == AC_PWRST_D3 &&
2993                             wid_type == AC_WID_PIN) {
2994                                 unsigned int pincap;
2995                                 /*
2996                                  * don't power down the widget if it controls
2997                                  * eapd and EAPD_BTLENABLE is set.
2998                                  */
2999                                 pincap = snd_hda_query_pin_caps(codec, nid);
3000                                 if (pincap & AC_PINCAP_EAPD) {
3001                                         int eapd = snd_hda_codec_read(codec,
3002                                                 nid, 0,
3003                                                 AC_VERB_GET_EAPD_BTLENABLE, 0);
3004                                         eapd &= 0x02;
3005                                         if (eapd)
3006                                                 continue;
3007                                 }
3008                         }
3009                         snd_hda_codec_write(codec, nid, 0,
3010                                             AC_VERB_SET_POWER_STATE,
3011                                             power_state);
3012                 }
3013         }
3014
3015         if (power_state == AC_PWRST_D0) {
3016                 unsigned long end_time;
3017                 int state;
3018                 /* wait until the codec reachs to D0 */
3019                 end_time = jiffies + msecs_to_jiffies(500);
3020                 do {
3021                         state = snd_hda_codec_read(codec, fg, 0,
3022                                                    AC_VERB_GET_POWER_STATE, 0);
3023                         if (state == power_state)
3024                                 break;
3025                         msleep(1);
3026                 } while (time_after_eq(end_time, jiffies));
3027         }
3028 }
3029
3030 #ifdef CONFIG_SND_HDA_HWDEP
3031 /* execute additional init verbs */
3032 static void hda_exec_init_verbs(struct hda_codec *codec)
3033 {
3034         if (codec->init_verbs.list)
3035                 snd_hda_sequence_write(codec, codec->init_verbs.list);
3036 }
3037 #else
3038 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3039 #endif
3040
3041 #ifdef SND_HDA_NEEDS_RESUME
3042 /*
3043  * call suspend and power-down; used both from PM and power-save
3044  */
3045 static void hda_call_codec_suspend(struct hda_codec *codec)
3046 {
3047         if (codec->patch_ops.suspend)
3048                 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
3049         hda_cleanup_all_streams(codec);
3050         hda_set_power_state(codec,
3051                             codec->afg ? codec->afg : codec->mfg,
3052                             AC_PWRST_D3);
3053 #ifdef CONFIG_SND_HDA_POWER_SAVE
3054         snd_hda_update_power_acct(codec);
3055         cancel_delayed_work(&codec->power_work);
3056         codec->power_on = 0;
3057         codec->power_transition = 0;
3058         codec->power_jiffies = jiffies;
3059 #endif
3060 }
3061
3062 /*
3063  * kick up codec; used both from PM and power-save
3064  */
3065 static void hda_call_codec_resume(struct hda_codec *codec)
3066 {
3067         hda_set_power_state(codec,
3068                             codec->afg ? codec->afg : codec->mfg,
3069                             AC_PWRST_D0);
3070         restore_pincfgs(codec); /* restore all current pin configs */
3071         restore_shutup_pins(codec);
3072         hda_exec_init_verbs(codec);
3073         if (codec->patch_ops.resume)
3074                 codec->patch_ops.resume(codec);
3075         else {
3076                 if (codec->patch_ops.init)
3077                         codec->patch_ops.init(codec);
3078                 snd_hda_codec_resume_amp(codec);
3079                 snd_hda_codec_resume_cache(codec);
3080         }
3081 }
3082 #endif /* SND_HDA_NEEDS_RESUME */
3083
3084
3085 /**
3086  * snd_hda_build_controls - build mixer controls
3087  * @bus: the BUS
3088  *
3089  * Creates mixer controls for each codec included in the bus.
3090  *
3091  * Returns 0 if successful, otherwise a negative error code.
3092  */
3093 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
3094 {
3095         struct hda_codec *codec;
3096
3097         list_for_each_entry(codec, &bus->codec_list, list) {
3098                 int err = snd_hda_codec_build_controls(codec);
3099                 if (err < 0) {
3100                         printk(KERN_ERR "hda_codec: cannot build controls "
3101                                "for #%d (error %d)\n", codec->addr, err);
3102                         err = snd_hda_codec_reset(codec);
3103                         if (err < 0) {
3104                                 printk(KERN_ERR
3105                                        "hda_codec: cannot revert codec\n");
3106                                 return err;
3107                         }
3108                 }
3109         }
3110         return 0;
3111 }
3112 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3113
3114 int snd_hda_codec_build_controls(struct hda_codec *codec)
3115 {
3116         int err = 0;
3117         hda_exec_init_verbs(codec);
3118         /* continue to initialize... */
3119         if (codec->patch_ops.init)
3120                 err = codec->patch_ops.init(codec);
3121         if (!err && codec->patch_ops.build_controls)
3122                 err = codec->patch_ops.build_controls(codec);
3123         if (err < 0)
3124                 return err;
3125         return 0;
3126 }
3127
3128 /*
3129  * stream formats
3130  */
3131 struct hda_rate_tbl {
3132         unsigned int hz;
3133         unsigned int alsa_bits;
3134         unsigned int hda_fmt;
3135 };
3136
3137 /* rate = base * mult / div */
3138 #define HDA_RATE(base, mult, div) \
3139         (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3140          (((div) - 1) << AC_FMT_DIV_SHIFT))
3141
3142 static struct hda_rate_tbl rate_bits[] = {
3143         /* rate in Hz, ALSA rate bitmask, HDA format value */
3144
3145         /* autodetected value used in snd_hda_query_supported_pcm */
3146         { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3147         { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3148         { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3149         { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3150         { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3151         { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3152         { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3153         { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3154         { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3155         { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3156         { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3157 #define AC_PAR_PCM_RATE_BITS    11
3158         /* up to bits 10, 384kHZ isn't supported properly */
3159
3160         /* not autodetected value */
3161         { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3162
3163         { 0 } /* terminator */
3164 };
3165
3166 /**
3167  * snd_hda_calc_stream_format - calculate format bitset
3168  * @rate: the sample rate
3169  * @channels: the number of channels
3170  * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3171  * @maxbps: the max. bps
3172  *
3173  * Calculate the format bitset from the given rate, channels and th PCM format.
3174  *
3175  * Return zero if invalid.
3176  */
3177 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3178                                         unsigned int channels,
3179                                         unsigned int format,
3180                                         unsigned int maxbps,
3181                                         unsigned short spdif_ctls)
3182 {
3183         int i;
3184         unsigned int val = 0;
3185
3186         for (i = 0; rate_bits[i].hz; i++)
3187                 if (rate_bits[i].hz == rate) {
3188                         val = rate_bits[i].hda_fmt;
3189                         break;
3190                 }
3191         if (!rate_bits[i].hz) {
3192                 snd_printdd("invalid rate %d\n", rate);
3193                 return 0;
3194         }
3195
3196         if (channels == 0 || channels > 8) {
3197                 snd_printdd("invalid channels %d\n", channels);
3198                 return 0;
3199         }
3200         val |= channels - 1;
3201
3202         switch (snd_pcm_format_width(format)) {
3203         case 8:
3204                 val |= AC_FMT_BITS_8;
3205                 break;
3206         case 16:
3207                 val |= AC_FMT_BITS_16;
3208                 break;
3209         case 20:
3210         case 24:
3211         case 32:
3212                 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3213                         val |= AC_FMT_BITS_32;
3214                 else if (maxbps >= 24)
3215                         val |= AC_FMT_BITS_24;
3216                 else
3217                         val |= AC_FMT_BITS_20;
3218                 break;
3219         default:
3220                 snd_printdd("invalid format width %d\n",
3221                             snd_pcm_format_width(format));
3222                 return 0;
3223         }
3224
3225         if (spdif_ctls & AC_DIG1_NONAUDIO)
3226                 val |= AC_FMT_TYPE_NON_PCM;
3227
3228         return val;
3229 }
3230 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3231
3232 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3233 {
3234         unsigned int val = 0;
3235         if (nid != codec->afg &&
3236             (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3237                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3238         if (!val || val == -1)
3239                 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3240         if (!val || val == -1)
3241                 return 0;
3242         return val;
3243 }
3244
3245 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3246 {
3247         return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3248                                get_pcm_param);
3249 }
3250
3251 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3252 {
3253         unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3254         if (!streams || streams == -1)
3255                 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3256         if (!streams || streams == -1)
3257                 return 0;
3258         return streams;
3259 }
3260
3261 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3262 {
3263         return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3264                                get_stream_param);
3265 }
3266
3267 /**
3268  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3269  * @codec: the HDA codec
3270  * @nid: NID to query
3271  * @ratesp: the pointer to store the detected rate bitflags
3272  * @formatsp: the pointer to store the detected formats
3273  * @bpsp: the pointer to store the detected format widths
3274  *
3275  * Queries the supported PCM rates and formats.  The NULL @ratesp, @formatsp
3276  * or @bsps argument is ignored.
3277  *
3278  * Returns 0 if successful, otherwise a negative error code.
3279  */
3280 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3281                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3282 {
3283         unsigned int i, val, wcaps;
3284
3285         wcaps = get_wcaps(codec, nid);
3286         val = query_pcm_param(codec, nid);
3287
3288         if (ratesp) {
3289                 u32 rates = 0;
3290                 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3291                         if (val & (1 << i))
3292                                 rates |= rate_bits[i].alsa_bits;
3293                 }
3294                 if (rates == 0) {
3295                         snd_printk(KERN_ERR "hda_codec: rates == 0 "
3296                                    "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3297                                         nid, val,
3298                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3299                         return -EIO;
3300                 }
3301                 *ratesp = rates;
3302         }
3303
3304         if (formatsp || bpsp) {
3305                 u64 formats = 0;
3306                 unsigned int streams, bps;
3307
3308                 streams = query_stream_param(codec, nid);
3309                 if (!streams)
3310                         return -EIO;
3311
3312                 bps = 0;
3313                 if (streams & AC_SUPFMT_PCM) {
3314                         if (val & AC_SUPPCM_BITS_8) {
3315                                 formats |= SNDRV_PCM_FMTBIT_U8;
3316                                 bps = 8;
3317                         }
3318                         if (val & AC_SUPPCM_BITS_16) {
3319                                 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3320                                 bps = 16;
3321                         }
3322                         if (wcaps & AC_WCAP_DIGITAL) {
3323                                 if (val & AC_SUPPCM_BITS_32)
3324                                         formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3325                                 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3326                                         formats |= SNDRV_PCM_FMTBIT_S32_LE;
3327                                 if (val & AC_SUPPCM_BITS_24)
3328                                         bps = 24;
3329                                 else if (val & AC_SUPPCM_BITS_20)
3330                                         bps = 20;
3331                         } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3332                                           AC_SUPPCM_BITS_32)) {
3333                                 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3334                                 if (val & AC_SUPPCM_BITS_32)
3335                                         bps = 32;
3336                                 else if (val & AC_SUPPCM_BITS_24)
3337                                         bps = 24;
3338                                 else if (val & AC_SUPPCM_BITS_20)
3339                                         bps = 20;
3340                         }
3341                 }
3342                 if (streams & AC_SUPFMT_FLOAT32) {
3343                         formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3344                         if (!bps)
3345                                 bps = 32;
3346                 }
3347                 if (streams == AC_SUPFMT_AC3) {
3348                         /* should be exclusive */
3349                         /* temporary hack: we have still no proper support
3350                          * for the direct AC3 stream...
3351                          */
3352                         formats |= SNDRV_PCM_FMTBIT_U8;
3353                         bps = 8;
3354                 }
3355                 if (formats == 0) {
3356                         snd_printk(KERN_ERR "hda_codec: formats == 0 "
3357                                    "(nid=0x%x, val=0x%x, ovrd=%i, "
3358                                    "streams=0x%x)\n",