ALSA: hda - Fix multi-headphone handling for Realtek codecs
[linux-2.6.git] / sound / pci / hda / hda_codec.c
1 /*
2  * Universal Interface for Intel High Definition Audio Codec
3  *
4  * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
5  *
6  *
7  *  This driver is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License as published by
9  *  the Free Software Foundation; either version 2 of the License, or
10  *  (at your option) any later version.
11  *
12  *  This driver is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *  GNU General Public License for more details.
16  *
17  *  You should have received a copy of the GNU General Public License
18  *  along with this program; if not, write to the Free Software
19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
20  */
21
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/pci.h>
26 #include <linux/mutex.h>
27 #include <sound/core.h>
28 #include "hda_codec.h"
29 #include <sound/asoundef.h>
30 #include <sound/tlv.h>
31 #include <sound/initval.h>
32 #include "hda_local.h"
33 #include "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 type;
1220         int i;
1221
1222         if (!nid)
1223                 return;
1224
1225         snd_printdd("hda_codec_setup_stream: "
1226                     "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1227                     nid, stream_tag, channel_id, format);
1228         p = get_hda_cvt_setup(codec, nid);
1229         if (!p)
1230                 return;
1231         /* update the stream-id if changed */
1232         if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1233                 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1234                 newval = (stream_tag << 4) | channel_id;
1235                 if (oldval != newval)
1236                         snd_hda_codec_write(codec, nid, 0,
1237                                             AC_VERB_SET_CHANNEL_STREAMID,
1238                                             newval);
1239                 p->stream_tag = stream_tag;
1240                 p->channel_id = channel_id;
1241         }
1242         /* update the format-id if changed */
1243         if (p->format_id != format) {
1244                 oldval = snd_hda_codec_read(codec, nid, 0,
1245                                             AC_VERB_GET_STREAM_FORMAT, 0);
1246                 if (oldval != format) {
1247                         msleep(1);
1248                         snd_hda_codec_write(codec, nid, 0,
1249                                             AC_VERB_SET_STREAM_FORMAT,
1250                                             format);
1251                 }
1252                 p->format_id = format;
1253         }
1254         p->active = 1;
1255         p->dirty = 0;
1256
1257         /* make other inactive cvts with the same stream-tag dirty */
1258         type = get_wcaps_type(get_wcaps(codec, nid));
1259         list_for_each_entry(c, &codec->bus->codec_list, list) {
1260                 for (i = 0; i < c->cvt_setups.used; i++) {
1261                         p = snd_array_elem(&c->cvt_setups, i);
1262                         if (!p->active && p->stream_tag == stream_tag &&
1263                             get_wcaps_type(get_wcaps(codec, p->nid)) == type)
1264                                 p->dirty = 1;
1265                 }
1266         }
1267 }
1268 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1269
1270 static void really_cleanup_stream(struct hda_codec *codec,
1271                                   struct hda_cvt_setup *q);
1272
1273 /**
1274  * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1275  * @codec: the CODEC to clean up
1276  * @nid: the NID to clean up
1277  * @do_now: really clean up the stream instead of clearing the active flag
1278  */
1279 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1280                                     int do_now)
1281 {
1282         struct hda_cvt_setup *p;
1283
1284         if (!nid)
1285                 return;
1286
1287         if (codec->no_sticky_stream)
1288                 do_now = 1;
1289
1290         snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1291         p = get_hda_cvt_setup(codec, nid);
1292         if (p) {
1293                 /* here we just clear the active flag when do_now isn't set;
1294                  * actual clean-ups will be done later in
1295                  * purify_inactive_streams() called from snd_hda_codec_prpapre()
1296                  */
1297                 if (do_now)
1298                         really_cleanup_stream(codec, p);
1299                 else
1300                         p->active = 0;
1301         }
1302 }
1303 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1304
1305 static void really_cleanup_stream(struct hda_codec *codec,
1306                                   struct hda_cvt_setup *q)
1307 {
1308         hda_nid_t nid = q->nid;
1309         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1310         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1311         memset(q, 0, sizeof(*q));
1312         q->nid = nid;
1313 }
1314
1315 /* clean up the all conflicting obsolete streams */
1316 static void purify_inactive_streams(struct hda_codec *codec)
1317 {
1318         struct hda_codec *c;
1319         int i;
1320
1321         list_for_each_entry(c, &codec->bus->codec_list, list) {
1322                 for (i = 0; i < c->cvt_setups.used; i++) {
1323                         struct hda_cvt_setup *p;
1324                         p = snd_array_elem(&c->cvt_setups, i);
1325                         if (p->dirty)
1326                                 really_cleanup_stream(c, p);
1327                 }
1328         }
1329 }
1330
1331 /* clean up all streams; called from suspend */
1332 static void hda_cleanup_all_streams(struct hda_codec *codec)
1333 {
1334         int i;
1335
1336         for (i = 0; i < codec->cvt_setups.used; i++) {
1337                 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1338                 if (p->stream_tag)
1339                         really_cleanup_stream(codec, p);
1340         }
1341 }
1342
1343 /*
1344  * amp access functions
1345  */
1346
1347 /* FIXME: more better hash key? */
1348 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1349 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1350 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1351 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1352 #define INFO_AMP_CAPS   (1<<0)
1353 #define INFO_AMP_VOL(ch)        (1 << (1 + (ch)))
1354
1355 /* initialize the hash table */
1356 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1357                                      unsigned int record_size)
1358 {
1359         memset(cache, 0, sizeof(*cache));
1360         memset(cache->hash, 0xff, sizeof(cache->hash));
1361         snd_array_init(&cache->buf, record_size, 64);
1362 }
1363
1364 static void free_hda_cache(struct hda_cache_rec *cache)
1365 {
1366         snd_array_free(&cache->buf);
1367 }
1368
1369 /* query the hash.  allocate an entry if not found. */
1370 static struct hda_cache_head  *get_hash(struct hda_cache_rec *cache, u32 key)
1371 {
1372         u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1373         u16 cur = cache->hash[idx];
1374         struct hda_cache_head *info;
1375
1376         while (cur != 0xffff) {
1377                 info = snd_array_elem(&cache->buf, cur);
1378                 if (info->key == key)
1379                         return info;
1380                 cur = info->next;
1381         }
1382         return NULL;
1383 }
1384
1385 /* query the hash.  allocate an entry if not found. */
1386 static struct hda_cache_head  *get_alloc_hash(struct hda_cache_rec *cache,
1387                                               u32 key)
1388 {
1389         struct hda_cache_head *info = get_hash(cache, key);
1390         if (!info) {
1391                 u16 idx, cur;
1392                 /* add a new hash entry */
1393                 info = snd_array_new(&cache->buf);
1394                 if (!info)
1395                         return NULL;
1396                 cur = snd_array_index(&cache->buf, info);
1397                 info->key = key;
1398                 info->val = 0;
1399                 idx = key % (u16)ARRAY_SIZE(cache->hash);
1400                 info->next = cache->hash[idx];
1401                 cache->hash[idx] = cur;
1402         }
1403         return info;
1404 }
1405
1406 /* query and allocate an amp hash entry */
1407 static inline struct hda_amp_info *
1408 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1409 {
1410         return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1411 }
1412
1413 /**
1414  * query_amp_caps - query AMP capabilities
1415  * @codec: the HD-auio codec
1416  * @nid: the NID to query
1417  * @direction: either #HDA_INPUT or #HDA_OUTPUT
1418  *
1419  * Query AMP capabilities for the given widget and direction.
1420  * Returns the obtained capability bits.
1421  *
1422  * When cap bits have been already read, this doesn't read again but
1423  * returns the cached value.
1424  */
1425 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1426 {
1427         struct hda_amp_info *info;
1428
1429         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1430         if (!info)
1431                 return 0;
1432         if (!(info->head.val & INFO_AMP_CAPS)) {
1433                 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1434                         nid = codec->afg;
1435                 info->amp_caps = snd_hda_param_read(codec, nid,
1436                                                     direction == HDA_OUTPUT ?
1437                                                     AC_PAR_AMP_OUT_CAP :
1438                                                     AC_PAR_AMP_IN_CAP);
1439                 if (info->amp_caps)
1440                         info->head.val |= INFO_AMP_CAPS;
1441         }
1442         return info->amp_caps;
1443 }
1444 EXPORT_SYMBOL_HDA(query_amp_caps);
1445
1446 /**
1447  * snd_hda_override_amp_caps - Override the AMP capabilities
1448  * @codec: the CODEC to clean up
1449  * @nid: the NID to clean up
1450  * @direction: either #HDA_INPUT or #HDA_OUTPUT
1451  * @caps: the capability bits to set
1452  *
1453  * Override the cached AMP caps bits value by the given one.
1454  * This function is useful if the driver needs to adjust the AMP ranges,
1455  * e.g. limit to 0dB, etc.
1456  *
1457  * Returns zero if successful or a negative error code.
1458  */
1459 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1460                               unsigned int caps)
1461 {
1462         struct hda_amp_info *info;
1463
1464         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1465         if (!info)
1466                 return -EINVAL;
1467         info->amp_caps = caps;
1468         info->head.val |= INFO_AMP_CAPS;
1469         return 0;
1470 }
1471 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1472
1473 static unsigned int
1474 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1475                 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1476 {
1477         struct hda_amp_info *info;
1478
1479         info = get_alloc_amp_hash(codec, key);
1480         if (!info)
1481                 return 0;
1482         if (!info->head.val) {
1483                 info->head.val |= INFO_AMP_CAPS;
1484                 info->amp_caps = func(codec, nid);
1485         }
1486         return info->amp_caps;
1487 }
1488
1489 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1490 {
1491         return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1492 }
1493
1494 /**
1495  * snd_hda_query_pin_caps - Query PIN capabilities
1496  * @codec: the HD-auio codec
1497  * @nid: the NID to query
1498  *
1499  * Query PIN capabilities for the given widget.
1500  * Returns the obtained capability bits.
1501  *
1502  * When cap bits have been already read, this doesn't read again but
1503  * returns the cached value.
1504  */
1505 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1506 {
1507         return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1508                                read_pin_cap);
1509 }
1510 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1511
1512 /**
1513  * snd_hda_pin_sense - execute pin sense measurement
1514  * @codec: the CODEC to sense
1515  * @nid: the pin NID to sense
1516  *
1517  * Execute necessary pin sense measurement and return its Presence Detect,
1518  * Impedance, ELD Valid etc. status bits.
1519  */
1520 u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
1521 {
1522         u32 pincap;
1523
1524         if (!codec->no_trigger_sense) {
1525                 pincap = snd_hda_query_pin_caps(codec, nid);
1526                 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
1527                         snd_hda_codec_read(codec, nid, 0,
1528                                         AC_VERB_SET_PIN_SENSE, 0);
1529         }
1530         return snd_hda_codec_read(codec, nid, 0,
1531                                   AC_VERB_GET_PIN_SENSE, 0);
1532 }
1533 EXPORT_SYMBOL_HDA(snd_hda_pin_sense);
1534
1535 /**
1536  * snd_hda_jack_detect - query pin Presence Detect status
1537  * @codec: the CODEC to sense
1538  * @nid: the pin NID to sense
1539  *
1540  * Query and return the pin's Presence Detect status.
1541  */
1542 int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
1543 {
1544         u32 sense = snd_hda_pin_sense(codec, nid);
1545         return !!(sense & AC_PINSENSE_PRESENCE);
1546 }
1547 EXPORT_SYMBOL_HDA(snd_hda_jack_detect);
1548
1549 /*
1550  * read the current volume to info
1551  * if the cache exists, read the cache value.
1552  */
1553 static unsigned int get_vol_mute(struct hda_codec *codec,
1554                                  struct hda_amp_info *info, hda_nid_t nid,
1555                                  int ch, int direction, int index)
1556 {
1557         u32 val, parm;
1558
1559         if (info->head.val & INFO_AMP_VOL(ch))
1560                 return info->vol[ch];
1561
1562         parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1563         parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1564         parm |= index;
1565         val = snd_hda_codec_read(codec, nid, 0,
1566                                  AC_VERB_GET_AMP_GAIN_MUTE, parm);
1567         info->vol[ch] = val & 0xff;
1568         info->head.val |= INFO_AMP_VOL(ch);
1569         return info->vol[ch];
1570 }
1571
1572 /*
1573  * write the current volume in info to the h/w and update the cache
1574  */
1575 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1576                          hda_nid_t nid, int ch, int direction, int index,
1577                          int val)
1578 {
1579         u32 parm;
1580
1581         parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1582         parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1583         parm |= index << AC_AMP_SET_INDEX_SHIFT;
1584         parm |= val;
1585         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1586         info->vol[ch] = val;
1587 }
1588
1589 /**
1590  * snd_hda_codec_amp_read - Read AMP value
1591  * @codec: HD-audio codec
1592  * @nid: NID to read the AMP value
1593  * @ch: channel (left=0 or right=1)
1594  * @direction: #HDA_INPUT or #HDA_OUTPUT
1595  * @index: the index value (only for input direction)
1596  *
1597  * Read AMP value.  The volume is between 0 to 0x7f, 0x80 = mute bit.
1598  */
1599 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1600                            int direction, int index)
1601 {
1602         struct hda_amp_info *info;
1603         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1604         if (!info)
1605                 return 0;
1606         return get_vol_mute(codec, info, nid, ch, direction, index);
1607 }
1608 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1609
1610 /**
1611  * snd_hda_codec_amp_update - update the AMP value
1612  * @codec: HD-audio codec
1613  * @nid: NID to read the AMP value
1614  * @ch: channel (left=0 or right=1)
1615  * @direction: #HDA_INPUT or #HDA_OUTPUT
1616  * @idx: the index value (only for input direction)
1617  * @mask: bit mask to set
1618  * @val: the bits value to set
1619  *
1620  * Update the AMP value with a bit mask.
1621  * Returns 0 if the value is unchanged, 1 if changed.
1622  */
1623 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1624                              int direction, int idx, int mask, int val)
1625 {
1626         struct hda_amp_info *info;
1627
1628         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1629         if (!info)
1630                 return 0;
1631         if (snd_BUG_ON(mask & ~0xff))
1632                 mask &= 0xff;
1633         val &= mask;
1634         val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1635         if (info->vol[ch] == val)
1636                 return 0;
1637         put_vol_mute(codec, info, nid, ch, direction, idx, val);
1638         return 1;
1639 }
1640 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1641
1642 /**
1643  * snd_hda_codec_amp_stereo - update the AMP stereo values
1644  * @codec: HD-audio codec
1645  * @nid: NID to read the AMP value
1646  * @direction: #HDA_INPUT or #HDA_OUTPUT
1647  * @idx: the index value (only for input direction)
1648  * @mask: bit mask to set
1649  * @val: the bits value to set
1650  *
1651  * Update the AMP values like snd_hda_codec_amp_update(), but for a
1652  * stereo widget with the same mask and value.
1653  */
1654 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1655                              int direction, int idx, int mask, int val)
1656 {
1657         int ch, ret = 0;
1658
1659         if (snd_BUG_ON(mask & ~0xff))
1660                 mask &= 0xff;
1661         for (ch = 0; ch < 2; ch++)
1662                 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1663                                                 idx, mask, val);
1664         return ret;
1665 }
1666 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1667
1668 #ifdef SND_HDA_NEEDS_RESUME
1669 /**
1670  * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1671  * @codec: HD-audio codec
1672  *
1673  * Resume the all amp commands from the cache.
1674  */
1675 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1676 {
1677         struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1678         int i;
1679
1680         for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1681                 u32 key = buffer->head.key;
1682                 hda_nid_t nid;
1683                 unsigned int idx, dir, ch;
1684                 if (!key)
1685                         continue;
1686                 nid = key & 0xff;
1687                 idx = (key >> 16) & 0xff;
1688                 dir = (key >> 24) & 0xff;
1689                 for (ch = 0; ch < 2; ch++) {
1690                         if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1691                                 continue;
1692                         put_vol_mute(codec, buffer, nid, ch, dir, idx,
1693                                      buffer->vol[ch]);
1694                 }
1695         }
1696 }
1697 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1698 #endif /* SND_HDA_NEEDS_RESUME */
1699
1700 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1701                              unsigned int ofs)
1702 {
1703         u32 caps = query_amp_caps(codec, nid, dir);
1704         /* get num steps */
1705         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1706         if (ofs < caps)
1707                 caps -= ofs;
1708         return caps;
1709 }
1710
1711 /**
1712  * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1713  *
1714  * The control element is supposed to have the private_value field
1715  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1716  */
1717 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1718                                   struct snd_ctl_elem_info *uinfo)
1719 {
1720         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1721         u16 nid = get_amp_nid(kcontrol);
1722         u8 chs = get_amp_channels(kcontrol);
1723         int dir = get_amp_direction(kcontrol);
1724         unsigned int ofs = get_amp_offset(kcontrol);
1725
1726         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1727         uinfo->count = chs == 3 ? 2 : 1;
1728         uinfo->value.integer.min = 0;
1729         uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1730         if (!uinfo->value.integer.max) {
1731                 printk(KERN_WARNING "hda_codec: "
1732                        "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1733                        kcontrol->id.name);
1734                 return -EINVAL;
1735         }
1736         return 0;
1737 }
1738 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1739
1740
1741 static inline unsigned int
1742 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1743                int ch, int dir, int idx, unsigned int ofs)
1744 {
1745         unsigned int val;
1746         val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1747         val &= HDA_AMP_VOLMASK;
1748         if (val >= ofs)
1749                 val -= ofs;
1750         else
1751                 val = 0;
1752         return val;
1753 }
1754
1755 static inline int
1756 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1757                  int ch, int dir, int idx, unsigned int ofs,
1758                  unsigned int val)
1759 {
1760         unsigned int maxval;
1761
1762         if (val > 0)
1763                 val += ofs;
1764         /* ofs = 0: raw max value */
1765         maxval = get_amp_max_value(codec, nid, dir, 0);
1766         if (val > maxval)
1767                 val = maxval;
1768         return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1769                                         HDA_AMP_VOLMASK, val);
1770 }
1771
1772 /**
1773  * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1774  *
1775  * The control element is supposed to have the private_value field
1776  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1777  */
1778 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1779                                  struct snd_ctl_elem_value *ucontrol)
1780 {
1781         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1782         hda_nid_t nid = get_amp_nid(kcontrol);
1783         int chs = get_amp_channels(kcontrol);
1784         int dir = get_amp_direction(kcontrol);
1785         int idx = get_amp_index(kcontrol);
1786         unsigned int ofs = get_amp_offset(kcontrol);
1787         long *valp = ucontrol->value.integer.value;
1788
1789         if (chs & 1)
1790                 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1791         if (chs & 2)
1792                 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1793         return 0;
1794 }
1795 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1796
1797 /**
1798  * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1799  *
1800  * The control element is supposed to have the private_value field
1801  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1802  */
1803 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1804                                  struct snd_ctl_elem_value *ucontrol)
1805 {
1806         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1807         hda_nid_t nid = get_amp_nid(kcontrol);
1808         int chs = get_amp_channels(kcontrol);
1809         int dir = get_amp_direction(kcontrol);
1810         int idx = get_amp_index(kcontrol);
1811         unsigned int ofs = get_amp_offset(kcontrol);
1812         long *valp = ucontrol->value.integer.value;
1813         int change = 0;
1814
1815         snd_hda_power_up(codec);
1816         if (chs & 1) {
1817                 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1818                 valp++;
1819         }
1820         if (chs & 2)
1821                 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1822         snd_hda_power_down(codec);
1823         return change;
1824 }
1825 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1826
1827 /**
1828  * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
1829  *
1830  * The control element is supposed to have the private_value field
1831  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1832  */
1833 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1834                           unsigned int size, unsigned int __user *_tlv)
1835 {
1836         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1837         hda_nid_t nid = get_amp_nid(kcontrol);
1838         int dir = get_amp_direction(kcontrol);
1839         unsigned int ofs = get_amp_offset(kcontrol);
1840         bool min_mute = get_amp_min_mute(kcontrol);
1841         u32 caps, val1, val2;
1842
1843         if (size < 4 * sizeof(unsigned int))
1844                 return -ENOMEM;
1845         caps = query_amp_caps(codec, nid, dir);
1846         val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1847         val2 = (val2 + 1) * 25;
1848         val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1849         val1 += ofs;
1850         val1 = ((int)val1) * ((int)val2);
1851         if (min_mute)
1852                 val2 |= TLV_DB_SCALE_MUTE;
1853         if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1854                 return -EFAULT;
1855         if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1856                 return -EFAULT;
1857         if (put_user(val1, _tlv + 2))
1858                 return -EFAULT;
1859         if (put_user(val2, _tlv + 3))
1860                 return -EFAULT;
1861         return 0;
1862 }
1863 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1864
1865 /**
1866  * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1867  * @codec: HD-audio codec
1868  * @nid: NID of a reference widget
1869  * @dir: #HDA_INPUT or #HDA_OUTPUT
1870  * @tlv: TLV data to be stored, at least 4 elements
1871  *
1872  * Set (static) TLV data for a virtual master volume using the AMP caps
1873  * obtained from the reference NID.
1874  * The volume range is recalculated as if the max volume is 0dB.
1875  */
1876 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1877                              unsigned int *tlv)
1878 {
1879         u32 caps;
1880         int nums, step;
1881
1882         caps = query_amp_caps(codec, nid, dir);
1883         nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1884         step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1885         step = (step + 1) * 25;
1886         tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1887         tlv[1] = 2 * sizeof(unsigned int);
1888         tlv[2] = -nums * step;
1889         tlv[3] = step;
1890 }
1891 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1892
1893 /* find a mixer control element with the given name */
1894 static struct snd_kcontrol *
1895 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1896                         const char *name, int idx)
1897 {
1898         struct snd_ctl_elem_id id;
1899         memset(&id, 0, sizeof(id));
1900         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1901         id.index = idx;
1902         if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1903                 return NULL;
1904         strcpy(id.name, name);
1905         return snd_ctl_find_id(codec->bus->card, &id);
1906 }
1907
1908 /**
1909  * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1910  * @codec: HD-audio codec
1911  * @name: ctl id name string
1912  *
1913  * Get the control element with the given id string and IFACE_MIXER.
1914  */
1915 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1916                                             const char *name)
1917 {
1918         return _snd_hda_find_mixer_ctl(codec, name, 0);
1919 }
1920 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1921
1922 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name)
1923 {
1924         int idx;
1925         for (idx = 0; idx < 16; idx++) { /* 16 ctlrs should be large enough */
1926                 if (!_snd_hda_find_mixer_ctl(codec, name, idx))
1927                         return idx;
1928         }
1929         return -EBUSY;
1930 }
1931
1932 /**
1933  * snd_hda_ctl_add - Add a control element and assign to the codec
1934  * @codec: HD-audio codec
1935  * @nid: corresponding NID (optional)
1936  * @kctl: the control element to assign
1937  *
1938  * Add the given control element to an array inside the codec instance.
1939  * All control elements belonging to a codec are supposed to be added
1940  * by this function so that a proper clean-up works at the free or
1941  * reconfiguration time.
1942  *
1943  * If non-zero @nid is passed, the NID is assigned to the control element.
1944  * The assignment is shown in the codec proc file.
1945  *
1946  * snd_hda_ctl_add() checks the control subdev id field whether
1947  * #HDA_SUBDEV_NID_FLAG bit is set.  If set (and @nid is zero), the lower
1948  * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
1949  * specifies if kctl->private_value is a HDA amplifier value.
1950  */
1951 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
1952                     struct snd_kcontrol *kctl)
1953 {
1954         int err;
1955         unsigned short flags = 0;
1956         struct hda_nid_item *item;
1957
1958         if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
1959                 flags |= HDA_NID_ITEM_AMP;
1960                 if (nid == 0)
1961                         nid = get_amp_nid_(kctl->private_value);
1962         }
1963         if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
1964                 nid = kctl->id.subdevice & 0xffff;
1965         if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
1966                 kctl->id.subdevice = 0;
1967         err = snd_ctl_add(codec->bus->card, kctl);
1968         if (err < 0)
1969                 return err;
1970         item = snd_array_new(&codec->mixers);
1971         if (!item)
1972                 return -ENOMEM;
1973         item->kctl = kctl;
1974         item->nid = nid;
1975         item->flags = flags;
1976         return 0;
1977 }
1978 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1979
1980 /**
1981  * snd_hda_add_nid - Assign a NID to a control element
1982  * @codec: HD-audio codec
1983  * @nid: corresponding NID (optional)
1984  * @kctl: the control element to assign
1985  * @index: index to kctl
1986  *
1987  * Add the given control element to an array inside the codec instance.
1988  * This function is used when #snd_hda_ctl_add cannot be used for 1:1
1989  * NID:KCTL mapping - for example "Capture Source" selector.
1990  */
1991 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
1992                     unsigned int index, hda_nid_t nid)
1993 {
1994         struct hda_nid_item *item;
1995
1996         if (nid > 0) {
1997                 item = snd_array_new(&codec->nids);
1998                 if (!item)
1999                         return -ENOMEM;
2000                 item->kctl = kctl;
2001                 item->index = index;
2002                 item->nid = nid;
2003                 return 0;
2004         }
2005         printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2006                kctl->id.name, kctl->id.index, index);
2007         return -EINVAL;
2008 }
2009 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2010
2011 /**
2012  * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2013  * @codec: HD-audio codec
2014  */
2015 void snd_hda_ctls_clear(struct hda_codec *codec)
2016 {
2017         int i;
2018         struct hda_nid_item *items = codec->mixers.list;
2019         for (i = 0; i < codec->mixers.used; i++)
2020                 snd_ctl_remove(codec->bus->card, items[i].kctl);
2021         snd_array_free(&codec->mixers);
2022         snd_array_free(&codec->nids);
2023 }
2024
2025 /* pseudo device locking
2026  * toggle card->shutdown to allow/disallow the device access (as a hack)
2027  */
2028 static int hda_lock_devices(struct snd_card *card)
2029 {
2030         spin_lock(&card->files_lock);
2031         if (card->shutdown) {
2032                 spin_unlock(&card->files_lock);
2033                 return -EINVAL;
2034         }
2035         card->shutdown = 1;
2036         spin_unlock(&card->files_lock);
2037         return 0;
2038 }
2039
2040 static void hda_unlock_devices(struct snd_card *card)
2041 {
2042         spin_lock(&card->files_lock);
2043         card->shutdown = 0;
2044         spin_unlock(&card->files_lock);
2045 }
2046
2047 /**
2048  * snd_hda_codec_reset - Clear all objects assigned to the codec
2049  * @codec: HD-audio codec
2050  *
2051  * This frees the all PCM and control elements assigned to the codec, and
2052  * clears the caches and restores the pin default configurations.
2053  *
2054  * When a device is being used, it returns -EBSY.  If successfully freed,
2055  * returns zero.
2056  */
2057 int snd_hda_codec_reset(struct hda_codec *codec)
2058 {
2059         struct snd_card *card = codec->bus->card;
2060         int i, pcm;
2061
2062         if (hda_lock_devices(card) < 0)
2063                 return -EBUSY;
2064         /* check whether the codec isn't used by any mixer or PCM streams */
2065         if (!list_empty(&card->ctl_files)) {
2066                 hda_unlock_devices(card);
2067                 return -EBUSY;
2068         }
2069         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2070                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2071                 if (!cpcm->pcm)
2072                         continue;
2073                 if (cpcm->pcm->streams[0].substream_opened ||
2074                     cpcm->pcm->streams[1].substream_opened) {
2075                         hda_unlock_devices(card);
2076                         return -EBUSY;
2077                 }
2078         }
2079
2080         /* OK, let it free */
2081
2082 #ifdef CONFIG_SND_HDA_POWER_SAVE
2083         cancel_delayed_work(&codec->power_work);
2084         flush_workqueue(codec->bus->workq);
2085 #endif
2086         snd_hda_ctls_clear(codec);
2087         /* relase PCMs */
2088         for (i = 0; i < codec->num_pcms; i++) {
2089                 if (codec->pcm_info[i].pcm) {
2090                         snd_device_free(card, codec->pcm_info[i].pcm);
2091                         clear_bit(codec->pcm_info[i].device,
2092                                   codec->bus->pcm_dev_bits);
2093                 }
2094         }
2095         if (codec->patch_ops.free)
2096                 codec->patch_ops.free(codec);
2097         codec->proc_widget_hook = NULL;
2098         codec->spec = NULL;
2099         free_hda_cache(&codec->amp_cache);
2100         free_hda_cache(&codec->cmd_cache);
2101         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2102         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2103         /* free only driver_pins so that init_pins + user_pins are restored */
2104         snd_array_free(&codec->driver_pins);
2105         restore_pincfgs(codec);
2106         codec->num_pcms = 0;
2107         codec->pcm_info = NULL;
2108         codec->preset = NULL;
2109         memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2110         codec->slave_dig_outs = NULL;
2111         codec->spdif_status_reset = 0;
2112         module_put(codec->owner);
2113         codec->owner = NULL;
2114
2115         /* allow device access again */
2116         hda_unlock_devices(card);
2117         return 0;
2118 }
2119
2120 /**
2121  * snd_hda_add_vmaster - create a virtual master control and add slaves
2122  * @codec: HD-audio codec
2123  * @name: vmaster control name
2124  * @tlv: TLV data (optional)
2125  * @slaves: slave control names (optional)
2126  *
2127  * Create a virtual master control with the given name.  The TLV data
2128  * must be either NULL or a valid data.
2129  *
2130  * @slaves is a NULL-terminated array of strings, each of which is a
2131  * slave control name.  All controls with these names are assigned to
2132  * the new virtual master control.
2133  *
2134  * This function returns zero if successful or a negative error code.
2135  */
2136 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2137                         unsigned int *tlv, const char **slaves)
2138 {
2139         struct snd_kcontrol *kctl;
2140         const char **s;
2141         int err;
2142
2143         for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
2144                 ;
2145         if (!*s) {
2146                 snd_printdd("No slave found for %s\n", name);
2147                 return 0;
2148         }
2149         kctl = snd_ctl_make_virtual_master(name, tlv);
2150         if (!kctl)
2151                 return -ENOMEM;
2152         err = snd_hda_ctl_add(codec, 0, kctl);
2153         if (err < 0)
2154                 return err;
2155
2156         for (s = slaves; *s; s++) {
2157                 struct snd_kcontrol *sctl;
2158                 int i = 0;
2159                 for (;;) {
2160                         sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
2161                         if (!sctl) {
2162                                 if (!i)
2163                                         snd_printdd("Cannot find slave %s, "
2164                                                     "skipped\n", *s);
2165                                 break;
2166                         }
2167                         err = snd_ctl_add_slave(kctl, sctl);
2168                         if (err < 0)
2169                                 return err;
2170                         i++;
2171                 }
2172         }
2173         return 0;
2174 }
2175 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
2176
2177 /**
2178  * snd_hda_mixer_amp_switch_info - Info 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_info(struct snd_kcontrol *kcontrol,
2184                                   struct snd_ctl_elem_info *uinfo)
2185 {
2186         int chs = get_amp_channels(kcontrol);
2187
2188         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2189         uinfo->count = chs == 3 ? 2 : 1;
2190         uinfo->value.integer.min = 0;
2191         uinfo->value.integer.max = 1;
2192         return 0;
2193 }
2194 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2195
2196 /**
2197  * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2198  *
2199  * The control element is supposed to have the private_value field
2200  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2201  */
2202 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2203                                  struct snd_ctl_elem_value *ucontrol)
2204 {
2205         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2206         hda_nid_t nid = get_amp_nid(kcontrol);
2207         int chs = get_amp_channels(kcontrol);
2208         int dir = get_amp_direction(kcontrol);
2209         int idx = get_amp_index(kcontrol);
2210         long *valp = ucontrol->value.integer.value;
2211
2212         if (chs & 1)
2213                 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2214                            HDA_AMP_MUTE) ? 0 : 1;
2215         if (chs & 2)
2216                 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2217                          HDA_AMP_MUTE) ? 0 : 1;
2218         return 0;
2219 }
2220 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2221
2222 /**
2223  * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2224  *
2225  * The control element is supposed to have the private_value field
2226  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2227  */
2228 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2229                                  struct snd_ctl_elem_value *ucontrol)
2230 {
2231         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2232         hda_nid_t nid = get_amp_nid(kcontrol);
2233         int chs = get_amp_channels(kcontrol);
2234         int dir = get_amp_direction(kcontrol);
2235         int idx = get_amp_index(kcontrol);
2236         long *valp = ucontrol->value.integer.value;
2237         int change = 0;
2238
2239         snd_hda_power_up(codec);
2240         if (chs & 1) {
2241                 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2242                                                   HDA_AMP_MUTE,
2243                                                   *valp ? 0 : HDA_AMP_MUTE);
2244                 valp++;
2245         }
2246         if (chs & 2)
2247                 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2248                                                    HDA_AMP_MUTE,
2249                                                    *valp ? 0 : HDA_AMP_MUTE);
2250         hda_call_check_power_status(codec, nid);
2251         snd_hda_power_down(codec);
2252         return change;
2253 }
2254 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2255
2256 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2257 /**
2258  * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2259  *
2260  * This function calls snd_hda_enable_beep_device(), which behaves differently
2261  * depending on beep_mode option.
2262  */
2263 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2264                                       struct snd_ctl_elem_value *ucontrol)
2265 {
2266         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2267         long *valp = ucontrol->value.integer.value;
2268
2269         snd_hda_enable_beep_device(codec, *valp);
2270         return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2271 }
2272 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
2273 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2274
2275 /*
2276  * bound volume controls
2277  *
2278  * bind multiple volumes (# indices, from 0)
2279  */
2280
2281 #define AMP_VAL_IDX_SHIFT       19
2282 #define AMP_VAL_IDX_MASK        (0x0f<<19)
2283
2284 /**
2285  * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2286  *
2287  * The control element is supposed to have the private_value field
2288  * set up via HDA_BIND_MUTE*() macros.
2289  */
2290 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2291                                   struct snd_ctl_elem_value *ucontrol)
2292 {
2293         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2294         unsigned long pval;
2295         int err;
2296
2297         mutex_lock(&codec->control_mutex);
2298         pval = kcontrol->private_value;
2299         kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2300         err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2301         kcontrol->private_value = pval;
2302         mutex_unlock(&codec->control_mutex);
2303         return err;
2304 }
2305 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2306
2307 /**
2308  * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2309  *
2310  * The control element is supposed to have the private_value field
2311  * set up via HDA_BIND_MUTE*() macros.
2312  */
2313 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2314                                   struct snd_ctl_elem_value *ucontrol)
2315 {
2316         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2317         unsigned long pval;
2318         int i, indices, err = 0, change = 0;
2319
2320         mutex_lock(&codec->control_mutex);
2321         pval = kcontrol->private_value;
2322         indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2323         for (i = 0; i < indices; i++) {
2324                 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2325                         (i << AMP_VAL_IDX_SHIFT);
2326                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2327                 if (err < 0)
2328                         break;
2329                 change |= err;
2330         }
2331         kcontrol->private_value = pval;
2332         mutex_unlock(&codec->control_mutex);
2333         return err < 0 ? err : change;
2334 }
2335 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2336
2337 /**
2338  * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2339  *
2340  * The control element is supposed to have the private_value field
2341  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2342  */
2343 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2344                                  struct snd_ctl_elem_info *uinfo)
2345 {
2346         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2347         struct hda_bind_ctls *c;
2348         int err;
2349
2350         mutex_lock(&codec->control_mutex);
2351         c = (struct hda_bind_ctls *)kcontrol->private_value;
2352         kcontrol->private_value = *c->values;
2353         err = c->ops->info(kcontrol, uinfo);
2354         kcontrol->private_value = (long)c;
2355         mutex_unlock(&codec->control_mutex);
2356         return err;
2357 }
2358 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2359
2360 /**
2361  * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2362  *
2363  * The control element is supposed to have the private_value field
2364  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2365  */
2366 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2367                                 struct snd_ctl_elem_value *ucontrol)
2368 {
2369         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2370         struct hda_bind_ctls *c;
2371         int err;
2372
2373         mutex_lock(&codec->control_mutex);
2374         c = (struct hda_bind_ctls *)kcontrol->private_value;
2375         kcontrol->private_value = *c->values;
2376         err = c->ops->get(kcontrol, ucontrol);
2377         kcontrol->private_value = (long)c;
2378         mutex_unlock(&codec->control_mutex);
2379         return err;
2380 }
2381 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2382
2383 /**
2384  * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2385  *
2386  * The control element is supposed to have the private_value field
2387  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2388  */
2389 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2390                                 struct snd_ctl_elem_value *ucontrol)
2391 {
2392         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2393         struct hda_bind_ctls *c;
2394         unsigned long *vals;
2395         int err = 0, change = 0;
2396
2397         mutex_lock(&codec->control_mutex);
2398         c = (struct hda_bind_ctls *)kcontrol->private_value;
2399         for (vals = c->values; *vals; vals++) {
2400                 kcontrol->private_value = *vals;
2401                 err = c->ops->put(kcontrol, ucontrol);
2402                 if (err < 0)
2403                         break;
2404                 change |= err;
2405         }
2406         kcontrol->private_value = (long)c;
2407         mutex_unlock(&codec->control_mutex);
2408         return err < 0 ? err : change;
2409 }
2410 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2411
2412 /**
2413  * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2414  *
2415  * The control element is supposed to have the private_value field
2416  * set up via HDA_BIND_VOL() macro.
2417  */
2418 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2419                            unsigned int size, unsigned int __user *tlv)
2420 {
2421         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2422         struct hda_bind_ctls *c;
2423         int err;
2424
2425         mutex_lock(&codec->control_mutex);
2426         c = (struct hda_bind_ctls *)kcontrol->private_value;
2427         kcontrol->private_value = *c->values;
2428         err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2429         kcontrol->private_value = (long)c;
2430         mutex_unlock(&codec->control_mutex);
2431         return err;
2432 }
2433 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2434
2435 struct hda_ctl_ops snd_hda_bind_vol = {
2436         .info = snd_hda_mixer_amp_volume_info,
2437         .get = snd_hda_mixer_amp_volume_get,
2438         .put = snd_hda_mixer_amp_volume_put,
2439         .tlv = snd_hda_mixer_amp_tlv
2440 };
2441 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2442
2443 struct hda_ctl_ops snd_hda_bind_sw = {
2444         .info = snd_hda_mixer_amp_switch_info,
2445         .get = snd_hda_mixer_amp_switch_get,
2446         .put = snd_hda_mixer_amp_switch_put,
2447         .tlv = snd_hda_mixer_amp_tlv
2448 };
2449 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2450
2451 /*
2452  * SPDIF out controls
2453  */
2454
2455 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2456                                    struct snd_ctl_elem_info *uinfo)
2457 {
2458         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2459         uinfo->count = 1;
2460         return 0;
2461 }
2462
2463 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2464                                    struct snd_ctl_elem_value *ucontrol)
2465 {
2466         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2467                                            IEC958_AES0_NONAUDIO |
2468                                            IEC958_AES0_CON_EMPHASIS_5015 |
2469                                            IEC958_AES0_CON_NOT_COPYRIGHT;
2470         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2471                                            IEC958_AES1_CON_ORIGINAL;
2472         return 0;
2473 }
2474
2475 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2476                                    struct snd_ctl_elem_value *ucontrol)
2477 {
2478         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2479                                            IEC958_AES0_NONAUDIO |
2480                                            IEC958_AES0_PRO_EMPHASIS_5015;
2481         return 0;
2482 }
2483
2484 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2485                                      struct snd_ctl_elem_value *ucontrol)
2486 {
2487         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2488
2489         ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
2490         ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
2491         ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
2492         ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
2493
2494         return 0;
2495 }
2496
2497 /* convert from SPDIF status bits to HDA SPDIF bits
2498  * bit 0 (DigEn) is always set zero (to be filled later)
2499  */
2500 static unsigned short convert_from_spdif_status(unsigned int sbits)
2501 {
2502         unsigned short val = 0;
2503
2504         if (sbits & IEC958_AES0_PROFESSIONAL)
2505                 val |= AC_DIG1_PROFESSIONAL;
2506         if (sbits & IEC958_AES0_NONAUDIO)
2507                 val |= AC_DIG1_NONAUDIO;
2508         if (sbits & IEC958_AES0_PROFESSIONAL) {
2509                 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2510                     IEC958_AES0_PRO_EMPHASIS_5015)
2511                         val |= AC_DIG1_EMPHASIS;
2512         } else {
2513                 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2514                     IEC958_AES0_CON_EMPHASIS_5015)
2515                         val |= AC_DIG1_EMPHASIS;
2516                 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2517                         val |= AC_DIG1_COPYRIGHT;
2518                 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2519                         val |= AC_DIG1_LEVEL;
2520                 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2521         }
2522         return val;
2523 }
2524
2525 /* convert to SPDIF status bits from HDA SPDIF bits
2526  */
2527 static unsigned int convert_to_spdif_status(unsigned short val)
2528 {
2529         unsigned int sbits = 0;
2530
2531         if (val & AC_DIG1_NONAUDIO)
2532                 sbits |= IEC958_AES0_NONAUDIO;
2533         if (val & AC_DIG1_PROFESSIONAL)
2534                 sbits |= IEC958_AES0_PROFESSIONAL;
2535         if (sbits & IEC958_AES0_PROFESSIONAL) {
2536                 if (sbits & AC_DIG1_EMPHASIS)
2537                         sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2538         } else {
2539                 if (val & AC_DIG1_EMPHASIS)
2540                         sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2541                 if (!(val & AC_DIG1_COPYRIGHT))
2542                         sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2543                 if (val & AC_DIG1_LEVEL)
2544                         sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2545                 sbits |= val & (0x7f << 8);
2546         }
2547         return sbits;
2548 }
2549
2550 /* set digital convert verbs both for the given NID and its slaves */
2551 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2552                         int verb, int val)
2553 {
2554         hda_nid_t *d;
2555
2556         snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2557         d = codec->slave_dig_outs;
2558         if (!d)
2559                 return;
2560         for (; *d; d++)
2561                 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2562 }
2563
2564 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2565                                        int dig1, int dig2)
2566 {
2567         if (dig1 != -1)
2568                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2569         if (dig2 != -1)
2570                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2571 }
2572
2573 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2574                                      struct snd_ctl_elem_value *ucontrol)
2575 {
2576         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2577         hda_nid_t nid = kcontrol->private_value;
2578         unsigned short val;
2579         int change;
2580
2581         mutex_lock(&codec->spdif_mutex);
2582         codec->spdif_status = ucontrol->value.iec958.status[0] |
2583                 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2584                 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2585                 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2586         val = convert_from_spdif_status(codec->spdif_status);
2587         val |= codec->spdif_ctls & 1;
2588         change = codec->spdif_ctls != val;
2589         codec->spdif_ctls = val;
2590
2591         if (change)
2592                 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2593
2594         mutex_unlock(&codec->spdif_mutex);
2595         return change;
2596 }
2597
2598 #define snd_hda_spdif_out_switch_info   snd_ctl_boolean_mono_info
2599
2600 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2601                                         struct snd_ctl_elem_value *ucontrol)
2602 {
2603         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2604
2605         ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
2606         return 0;
2607 }
2608
2609 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2610                                         struct snd_ctl_elem_value *ucontrol)
2611 {
2612         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2613         hda_nid_t nid = kcontrol->private_value;
2614         unsigned short val;
2615         int change;
2616
2617         mutex_lock(&codec->spdif_mutex);
2618         val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2619         if (ucontrol->value.integer.value[0])
2620                 val |= AC_DIG1_ENABLE;
2621         change = codec->spdif_ctls != val;
2622         if (change) {
2623                 codec->spdif_ctls = val;
2624                 set_dig_out_convert(codec, nid, val & 0xff, -1);
2625                 /* unmute amp switch (if any) */
2626                 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2627                     (val & AC_DIG1_ENABLE))
2628                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2629                                                  HDA_AMP_MUTE, 0);
2630         }
2631         mutex_unlock(&codec->spdif_mutex);
2632         return change;
2633 }
2634
2635 static struct snd_kcontrol_new dig_mixes[] = {
2636         {
2637                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2638                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2639                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
2640                 .info = snd_hda_spdif_mask_info,
2641                 .get = snd_hda_spdif_cmask_get,
2642         },
2643         {
2644                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2645                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2646                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
2647                 .info = snd_hda_spdif_mask_info,
2648                 .get = snd_hda_spdif_pmask_get,
2649         },
2650         {
2651                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2652                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
2653                 .info = snd_hda_spdif_mask_info,
2654                 .get = snd_hda_spdif_default_get,
2655                 .put = snd_hda_spdif_default_put,
2656         },
2657         {
2658                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2659                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
2660                 .info = snd_hda_spdif_out_switch_info,
2661                 .get = snd_hda_spdif_out_switch_get,
2662                 .put = snd_hda_spdif_out_switch_put,
2663         },
2664         { } /* end */
2665 };
2666
2667 /**
2668  * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2669  * @codec: the HDA codec
2670  * @nid: audio out widget NID
2671  *
2672  * Creates controls related with the SPDIF output.
2673  * Called from each patch supporting the SPDIF out.
2674  *
2675  * Returns 0 if successful, or a negative error code.
2676  */
2677 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2678 {
2679         int err;
2680         struct snd_kcontrol *kctl;
2681         struct snd_kcontrol_new *dig_mix;
2682         int idx;
2683
2684         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
2685         if (idx < 0) {
2686                 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2687                 return -EBUSY;
2688         }
2689         for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2690                 kctl = snd_ctl_new1(dig_mix, codec);
2691                 if (!kctl)
2692                         return -ENOMEM;
2693                 kctl->id.index = idx;
2694                 kctl->private_value = nid;
2695                 err = snd_hda_ctl_add(codec, nid, kctl);
2696                 if (err < 0)
2697                         return err;
2698         }
2699         codec->spdif_ctls =
2700                 snd_hda_codec_read(codec, nid, 0,
2701                                    AC_VERB_GET_DIGI_CONVERT_1, 0);
2702         codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2703         return 0;
2704 }
2705 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2706
2707 /*
2708  * SPDIF sharing with analog output
2709  */
2710 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2711                               struct snd_ctl_elem_value *ucontrol)
2712 {
2713         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2714         ucontrol->value.integer.value[0] = mout->share_spdif;
2715         return 0;
2716 }
2717
2718 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2719                               struct snd_ctl_elem_value *ucontrol)
2720 {
2721         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2722         mout->share_spdif = !!ucontrol->value.integer.value[0];
2723         return 0;
2724 }
2725
2726 static struct snd_kcontrol_new spdif_share_sw = {
2727         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2728         .name = "IEC958 Default PCM Playback Switch",
2729         .info = snd_ctl_boolean_mono_info,
2730         .get = spdif_share_sw_get,
2731         .put = spdif_share_sw_put,
2732 };
2733
2734 /**
2735  * snd_hda_create_spdif_share_sw - create Default PCM switch
2736  * @codec: the HDA codec
2737  * @mout: multi-out instance
2738  */
2739 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2740                                   struct hda_multi_out *mout)
2741 {
2742         if (!mout->dig_out_nid)
2743                 return 0;
2744         /* ATTENTION: here mout is passed as private_data, instead of codec */
2745         return snd_hda_ctl_add(codec, mout->dig_out_nid,
2746                               snd_ctl_new1(&spdif_share_sw, mout));
2747 }
2748 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2749
2750 /*
2751  * SPDIF input
2752  */
2753
2754 #define snd_hda_spdif_in_switch_info    snd_hda_spdif_out_switch_info
2755
2756 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2757                                        struct snd_ctl_elem_value *ucontrol)
2758 {
2759         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2760
2761         ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2762         return 0;
2763 }
2764
2765 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2766                                        struct snd_ctl_elem_value *ucontrol)
2767 {
2768         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2769         hda_nid_t nid = kcontrol->private_value;
2770         unsigned int val = !!ucontrol->value.integer.value[0];
2771         int change;
2772
2773         mutex_lock(&codec->spdif_mutex);
2774         change = codec->spdif_in_enable != val;
2775         if (change) {
2776                 codec->spdif_in_enable = val;
2777                 snd_hda_codec_write_cache(codec, nid, 0,
2778                                           AC_VERB_SET_DIGI_CONVERT_1, val);
2779         }
2780         mutex_unlock(&codec->spdif_mutex);
2781         return change;
2782 }
2783
2784 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2785                                        struct snd_ctl_elem_value *ucontrol)
2786 {
2787         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2788         hda_nid_t nid = kcontrol->private_value;
2789         unsigned short val;
2790         unsigned int sbits;
2791
2792         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2793         sbits = convert_to_spdif_status(val);
2794         ucontrol->value.iec958.status[0] = sbits;
2795         ucontrol->value.iec958.status[1] = sbits >> 8;
2796         ucontrol->value.iec958.status[2] = sbits >> 16;
2797         ucontrol->value.iec958.status[3] = sbits >> 24;
2798         return 0;
2799 }
2800
2801 static struct snd_kcontrol_new dig_in_ctls[] = {
2802         {
2803                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2804                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
2805                 .info = snd_hda_spdif_in_switch_info,
2806                 .get = snd_hda_spdif_in_switch_get,
2807                 .put = snd_hda_spdif_in_switch_put,
2808         },
2809         {
2810                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2811                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2812                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
2813                 .info = snd_hda_spdif_mask_info,
2814                 .get = snd_hda_spdif_in_status_get,
2815         },
2816         { } /* end */
2817 };
2818
2819 /**
2820  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2821  * @codec: the HDA codec
2822  * @nid: audio in widget NID
2823  *
2824  * Creates controls related with the SPDIF input.
2825  * Called from each patch supporting the SPDIF in.
2826  *
2827  * Returns 0 if successful, or a negative error code.
2828  */
2829 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2830 {
2831         int err;
2832         struct snd_kcontrol *kctl;
2833         struct snd_kcontrol_new *dig_mix;
2834         int idx;
2835
2836         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
2837         if (idx < 0) {
2838                 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2839                 return -EBUSY;
2840         }
2841         for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2842                 kctl = snd_ctl_new1(dig_mix, codec);
2843                 if (!kctl)
2844                         return -ENOMEM;
2845                 kctl->private_value = nid;
2846                 err = snd_hda_ctl_add(codec, nid, kctl);
2847                 if (err < 0)
2848                         return err;
2849         }
2850         codec->spdif_in_enable =
2851                 snd_hda_codec_read(codec, nid, 0,
2852                                    AC_VERB_GET_DIGI_CONVERT_1, 0) &
2853                 AC_DIG1_ENABLE;
2854         return 0;
2855 }
2856 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2857
2858 #ifdef SND_HDA_NEEDS_RESUME
2859 /*
2860  * command cache
2861  */
2862
2863 /* build a 32bit cache key with the widget id and the command parameter */
2864 #define build_cmd_cache_key(nid, verb)  ((verb << 8) | nid)
2865 #define get_cmd_cache_nid(key)          ((key) & 0xff)
2866 #define get_cmd_cache_cmd(key)          (((key) >> 8) & 0xffff)
2867
2868 /**
2869  * snd_hda_codec_write_cache - send a single command with caching
2870  * @codec: the HDA codec
2871  * @nid: NID to send the command
2872  * @direct: direct flag
2873  * @verb: the verb to send
2874  * @parm: the parameter for the verb
2875  *
2876  * Send a single command without waiting for response.
2877  *
2878  * Returns 0 if successful, or a negative error code.
2879  */
2880 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2881                               int direct, unsigned int verb, unsigned int parm)
2882 {
2883         int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2884         struct hda_cache_head *c;
2885         u32 key;
2886
2887         if (err < 0)
2888                 return err;
2889         /* parm may contain the verb stuff for get/set amp */
2890         verb = verb | (parm >> 8);
2891         parm &= 0xff;
2892         key = build_cmd_cache_key(nid, verb);
2893         mutex_lock(&codec->bus->cmd_mutex);
2894         c = get_alloc_hash(&codec->cmd_cache, key);
2895         if (c)
2896                 c->val = parm;
2897         mutex_unlock(&codec->bus->cmd_mutex);
2898         return 0;
2899 }
2900 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2901
2902 /**
2903  * snd_hda_codec_update_cache - check cache and write the cmd only when needed
2904  * @codec: the HDA codec
2905  * @nid: NID to send the command
2906  * @direct: direct flag
2907  * @verb: the verb to send
2908  * @parm: the parameter for the verb
2909  *
2910  * This function works like snd_hda_codec_write_cache(), but it doesn't send
2911  * command if the parameter is already identical with the cached value.
2912  * If not, it sends the command and refreshes the cache.
2913  *
2914  * Returns 0 if successful, or a negative error code.
2915  */
2916 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
2917                                int direct, unsigned int verb, unsigned int parm)
2918 {
2919         struct hda_cache_head *c;
2920         u32 key;
2921
2922         /* parm may contain the verb stuff for get/set amp */
2923         verb = verb | (parm >> 8);
2924         parm &= 0xff;
2925         key = build_cmd_cache_key(nid, verb);
2926         mutex_lock(&codec->bus->cmd_mutex);
2927         c = get_hash(&codec->cmd_cache, key);
2928         if (c && c->val == parm) {
2929                 mutex_unlock(&codec->bus->cmd_mutex);
2930                 return 0;
2931         }
2932         mutex_unlock(&codec->bus->cmd_mutex);
2933         return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
2934 }
2935 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
2936
2937 /**
2938  * snd_hda_codec_resume_cache - Resume the all commands from the cache
2939  * @codec: HD-audio codec
2940  *
2941  * Execute all verbs recorded in the command caches to resume.
2942  */
2943 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2944 {
2945         struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2946         int i;
2947
2948         for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2949                 u32 key = buffer->key;
2950                 if (!key)
2951                         continue;
2952                 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2953                                     get_cmd_cache_cmd(key), buffer->val);
2954         }
2955 }
2956 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2957
2958 /**
2959  * snd_hda_sequence_write_cache - sequence writes with caching
2960  * @codec: the HDA codec
2961  * @seq: VERB array to send
2962  *
2963  * Send the commands sequentially from the given array.
2964  * Thte commands are recorded on cache for power-save and resume.
2965  * The array must be terminated with NID=0.
2966  */
2967 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2968                                   const struct hda_verb *seq)
2969 {
2970         for (; seq->nid; seq++)
2971                 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2972                                           seq->param);
2973 }
2974 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2975 #endif /* SND_HDA_NEEDS_RESUME */
2976
2977 /*
2978  * set power state of the codec
2979  */
2980 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2981                                 unsigned int power_state)
2982 {
2983         hda_nid_t nid;
2984         int i;
2985
2986         /* this delay seems necessary to avoid click noise at power-down */
2987         if (power_state == AC_PWRST_D3)
2988                 msleep(100);
2989         snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2990                             power_state);
2991         /* partial workaround for "azx_get_response timeout" */
2992         if (power_state == AC_PWRST_D0 &&
2993             (codec->vendor_id & 0xffff0000) == 0x14f10000)
2994                 msleep(10);
2995
2996         nid = codec->start_nid;
2997         for (i = 0; i < codec->num_nodes; i++, nid++) {
2998                 unsigned int wcaps = get_wcaps(codec, nid);
2999                 if (wcaps & AC_WCAP_POWER) {
3000                         unsigned int wid_type = get_wcaps_type(wcaps);
3001                         if (power_state == AC_PWRST_D3 &&
3002                             wid_type == AC_WID_PIN) {
3003                                 unsigned int pincap;
3004                                 /*
3005                                  * don't power down the widget if it controls
3006                                  * eapd and EAPD_BTLENABLE is set.
3007                                  */
3008                                 pincap = snd_hda_query_pin_caps(codec, nid);
3009                                 if (pincap & AC_PINCAP_EAPD) {
3010                                         int eapd = snd_hda_codec_read(codec,
3011                                                 nid, 0,
3012                                                 AC_VERB_GET_EAPD_BTLENABLE, 0);
3013                                         eapd &= 0x02;
3014                                         if (eapd)
3015                                                 continue;
3016                                 }
3017                         }
3018                         snd_hda_codec_write(codec, nid, 0,
3019                                             AC_VERB_SET_POWER_STATE,
3020                                             power_state);
3021                 }
3022         }
3023
3024         if (power_state == AC_PWRST_D0) {
3025                 unsigned long end_time;
3026                 int state;
3027                 /* wait until the codec reachs to D0 */
3028                 end_time = jiffies + msecs_to_jiffies(500);
3029                 do {
3030                         state = snd_hda_codec_read(codec, fg, 0,
3031                                                    AC_VERB_GET_POWER_STATE, 0);
3032                         if (state == power_state)
3033                                 break;
3034                         msleep(1);
3035                 } while (time_after_eq(end_time, jiffies));
3036         }
3037 }
3038
3039 #ifdef CONFIG_SND_HDA_HWDEP
3040 /* execute additional init verbs */
3041 static void hda_exec_init_verbs(struct hda_codec *codec)
3042 {
3043         if (codec->init_verbs.list)
3044                 snd_hda_sequence_write(codec, codec->init_verbs.list);
3045 }
3046 #else
3047 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3048 #endif
3049
3050 #ifdef SND_HDA_NEEDS_RESUME
3051 /*
3052  * call suspend and power-down; used both from PM and power-save
3053  */
3054 static void hda_call_codec_suspend(struct hda_codec *codec)
3055 {
3056         if (codec->patch_ops.suspend)
3057                 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
3058         hda_cleanup_all_streams(codec);
3059         hda_set_power_state(codec,
3060                             codec->afg ? codec->afg : codec->mfg,
3061                             AC_PWRST_D3);
3062 #ifdef CONFIG_SND_HDA_POWER_SAVE
3063         snd_hda_update_power_acct(codec);
3064         cancel_delayed_work(&codec->power_work);
3065         codec->power_on = 0;
3066         codec->power_transition = 0;
3067         codec->power_jiffies = jiffies;
3068 #endif
3069 }
3070
3071 /*
3072  * kick up codec; used both from PM and power-save
3073  */
3074 static void hda_call_codec_resume(struct hda_codec *codec)
3075 {
3076         hda_set_power_state(codec,
3077                             codec->afg ? codec->afg : codec->mfg,
3078                             AC_PWRST_D0);
3079         restore_pincfgs(codec); /* restore all current pin configs */
3080         restore_shutup_pins(codec);
3081         hda_exec_init_verbs(codec);
3082         if (codec->patch_ops.resume)
3083                 codec->patch_ops.resume(codec);
3084         else {
3085                 if (codec->patch_ops.init)
3086                         codec->patch_ops.init(codec);
3087                 snd_hda_codec_resume_amp(codec);
3088                 snd_hda_codec_resume_cache(codec);
3089         }
3090 }
3091 #endif /* SND_HDA_NEEDS_RESUME */
3092
3093
3094 /**
3095  * snd_hda_build_controls - build mixer controls
3096  * @bus: the BUS
3097  *
3098  * Creates mixer controls for each codec included in the bus.
3099  *
3100  * Returns 0 if successful, otherwise a negative error code.
3101  */
3102 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
3103 {
3104         struct hda_codec *codec;
3105
3106         list_for_each_entry(codec, &bus->codec_list, list) {
3107                 int err = snd_hda_codec_build_controls(codec);
3108                 if (err < 0) {
3109                         printk(KERN_ERR "hda_codec: cannot build controls "
3110                                "for #%d (error %d)\n", codec->addr, err);
3111                         err = snd_hda_codec_reset(codec);
3112                         if (err < 0) {
3113                                 printk(KERN_ERR
3114                                        "hda_codec: cannot revert codec\n");
3115                                 return err;
3116                         }
3117                 }
3118         }
3119         return 0;
3120 }
3121 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3122
3123 int snd_hda_codec_build_controls(struct hda_codec *codec)
3124 {
3125         int err = 0;
3126         hda_exec_init_verbs(codec);
3127         /* continue to initialize... */
3128         if (codec->patch_ops.init)
3129                 err = codec->patch_ops.init(codec);
3130         if (!err && codec->patch_ops.build_controls)
3131                 err = codec->patch_ops.build_controls(codec);
3132         if (err < 0)
3133                 return err;
3134         return 0;
3135 }
3136
3137 /*
3138  * stream formats
3139  */
3140 struct hda_rate_tbl {
3141         unsigned int hz;
3142         unsigned int alsa_bits;
3143         unsigned int hda_fmt;
3144 };
3145
3146 /* rate = base * mult / div */
3147 #define HDA_RATE(base, mult, div) \
3148         (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3149          (((div) - 1) << AC_FMT_DIV_SHIFT))
3150
3151 static struct hda_rate_tbl rate_bits[] = {
3152         /* rate in Hz, ALSA rate bitmask, HDA format value */
3153
3154         /* autodetected value used in snd_hda_query_supported_pcm */
3155         { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3156         { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3157         { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3158         { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3159         { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3160         { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3161         { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3162         { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3163         { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3164         { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3165         { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3166 #define AC_PAR_PCM_RATE_BITS    11
3167         /* up to bits 10, 384kHZ isn't supported properly */
3168
3169         /* not autodetected value */
3170         { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3171
3172         { 0 } /* terminator */
3173 };
3174
3175 /**
3176  * snd_hda_calc_stream_format - calculate format bitset
3177  * @rate: the sample rate
3178  * @channels: the number of channels
3179  * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3180  * @maxbps: the max. bps
3181  *
3182  * Calculate the format bitset from the given rate, channels and th PCM format.
3183  *
3184  * Return zero if invalid.
3185  */
3186 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3187                                         unsigned int channels,
3188                                         unsigned int format,
3189                                         unsigned int maxbps,
3190                                         unsigned short spdif_ctls)
3191 {
3192         int i;
3193         unsigned int val = 0;
3194
3195         for (i = 0; rate_bits[i].hz; i++)
3196                 if (rate_bits[i].hz == rate) {
3197                         val = rate_bits[i].hda_fmt;
3198                         break;
3199                 }
3200         if (!rate_bits[i].hz) {
3201                 snd_printdd("invalid rate %d\n", rate);
3202                 return 0;
3203         }
3204
3205         if (channels == 0 || channels > 8) {
3206                 snd_printdd("invalid channels %d\n", channels);
3207                 return 0;
3208         }
3209         val |= channels - 1;
3210
3211         switch (snd_pcm_format_width(format)) {
3212         case 8:
3213                 val |= AC_FMT_BITS_8;
3214                 break;
3215         case 16:
3216                 val |= AC_FMT_BITS_16;
3217                 break;
3218         case 20:
3219         case 24:
3220         case 32:
3221                 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3222                         val |= AC_FMT_BITS_32;
3223                 else if (maxbps >= 24)
3224                         val |= AC_FMT_BITS_24;
3225                 else
3226                         val |= AC_FMT_BITS_20;
3227                 break;
3228         default:
3229                 snd_printdd("invalid format width %d\n",
3230                             snd_pcm_format_width(format));
3231                 return 0;
3232         }
3233
3234         if (spdif_ctls & AC_DIG1_NONAUDIO)
3235                 val |= AC_FMT_TYPE_NON_PCM;
3236
3237         return val;
3238 }
3239 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3240
3241 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3242 {
3243         unsigned int val = 0;
3244         if (nid != codec->afg &&
3245             (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3246                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3247         if (!val || val == -1)
3248                 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3249         if (!val || val == -1)
3250                 return 0;
3251         return val;
3252 }
3253
3254 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3255 {
3256         return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3257                                get_pcm_param);
3258 }
3259
3260 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3261 {
3262         unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3263         if (!streams || streams == -1)
3264                 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3265         if (!streams || streams == -1)
3266                 return 0;
3267         return streams;
3268 }
3269
3270 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3271 {
3272         return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3273                                get_stream_param);
3274 }
3275
3276 /**
3277  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3278  * @codec: the HDA codec
3279  * @nid: NID to query
3280  * @ratesp: the pointer to store the detected rate bitflags
3281  * @formatsp: the pointer to store the detected formats
3282  * @bpsp: the pointer to store the detected format widths
3283  *
3284  * Queries the supported PCM rates and formats.  The NULL @ratesp, @formatsp
3285  * or @bsps argument is ignored.
3286  *
3287  * Returns 0 if successful, otherwise a negative error code.
3288  */
3289 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3290                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3291 {
3292         unsigned int i, val, wcaps;
3293
3294         wcaps = get_wcaps(codec, nid);
3295         val = query_pcm_param(codec, nid);
3296
3297         if (ratesp) {
3298                 u32 rates = 0;
3299                 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3300                         if (val & (1 << i))
3301                                 rates |= rate_bits[i].alsa_bits;
3302                 }
3303                 if (rates == 0) {
3304                         snd_printk(KERN_ERR "hda_codec: rates == 0 "
3305                                    "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3306                                         nid, val,
3307                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3308                         return -EIO;
3309                 }
3310                 *ratesp = rates;
3311         }
3312
3313         if (formatsp || bpsp) {
3314                 u64 formats = 0;
3315                 unsigned int streams, bps;
3316
3317                 streams = query_stream_param(codec, nid);
3318                 if (!streams)
3319                         return -EIO;
3320
3321                 bps = 0;
3322                 if (streams & AC_SUPFMT_PCM) {
3323                         if (val & AC_SUPPCM_BITS_8) {
3324                                 formats |= SNDRV_PCM_FMTBIT_U8;
3325                                 bps = 8;
3326                         }
3327                         if (val & AC_SUPPCM_BITS_16) {
3328                                 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3329                                 bps = 16;
3330                         }
3331                         if (wcaps & AC_WCAP_DIGITAL) {
3332                                 if (val & AC_SUPPCM_BITS_32)
3333                                         formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3334                                 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3335                                         formats |= SNDRV_PCM_FMTBIT_S32_LE;
3336                                 if (val & AC_SUPPCM_BITS_24)
3337                                         bps = 24;
3338                                 else if (val & AC_SUPPCM_BITS_20)
3339                                         bps = 20;
3340                         } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3341                                           AC_SUPPCM_BITS_32)) {
3342                                 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3343                                 if (val & AC_SUPPCM_BITS_32)
3344                                         bps = 32;
3345                                 else if (val & AC_SUPPCM_BITS_24)
3346                                         bps = 24;
3347                                 else if (val & AC_SUPPCM_BITS_20)
3348                                         bps = 20;
3349                         }
3350                 }
3351                 if (streams & AC_SUPFMT_FLOAT32) {
3352                         formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3353                         if (!bps)
3354                                 bps = 32;
3355                 }
3356                 if (streams == AC_SUPFMT_AC3) {
3357                         /* should be exclusive */
3358                         /* temporary hack: we have still no proper support
3359                          * for the direct AC3 stream...
3360                          */
3361                         formats |= SNDRV_PCM_FMTBIT_U8;
3362                         bps = 8;
3363                 }
3364                 if (formats == 0) {
3365                         snd_printk(KERN_ERR "hda_codec: formats == 0 "
3366                                    "(nid=0x%x, val=0x%x, ovrd=%i, "
3367                                    "streams=0x%x)\n",
3368                                         nid, val,
3369                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3370                                         streams);
3371                         return -EIO;
3372                 }
3373                 if (formatsp)
3374                         *formatsp = formats;
3375                 if (bpsp)
3376                         *bpsp = bps;
3377         }
3378
3379         return 0;
3380 }
3381
3382 /**
3383  * snd_hda_is_supported_format - Check the validity of the format
3384  * @codec: HD-audio codec
3385  * @nid: NID to check
3386  * @format: the HD-audio format value to check
3387  *
3388  * Check whether the given node supports the format value.
3389  *
3390  * Returns 1 if supported, 0 if not.
3391  */
3392 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3393                                 unsigned int format)
3394 {
3395         int i;
3396         unsigned int val = 0, rate, stream;
3397
3398         val = query_pcm_param(codec, nid);
3399         if (!val)
3400                 return 0;
3401
3402         rate = format & 0xff00;
3403         for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3404                 if (rate_bits[i].hda_fmt == rate) {
3405                         if (val & (1 << i))
3406                                 break;
3407                         return 0;
3408                 }
3409         if (i >= AC_PAR_PCM_RATE_BITS)
3410                 return 0;
3411
3412         stream = query_stream_param(codec, nid);
3413         if (!stream)
3414                 return 0;
3415
3416         if (stream & AC_SUPFMT_PCM) {
3417                 switch (format & 0xf0) {
3418                 case 0x00:
3419                         if (!(val & AC_SUPPCM_BITS_8))
3420                                 return 0;
3421                         break;
3422                 case 0x10:
3423                         if (!(val & AC_SUPPCM_BITS_16))
3424                                 return 0;
3425                         break;
3426                 case 0x20:
3427                         if (!(val & AC_SUPPCM_BITS_20))
3428                                 return 0;
3429                         break;
3430                 case 0x30:
3431                         if (!(val & AC_SUPPCM_BITS_24))
3432                                 return 0;
3433                         break;
3434                 case 0x40:
3435                         if (!(val & AC_SUPPCM_BITS_32))
3436                                 return 0;
3437                         break;
3438                 default:
3439                         return 0;
3440                 }
3441         } else {
3442                 /* FIXME: check for float32 and AC3? */
3443         }
3444
3445         return 1;
3446 }
3447 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3448
3449 /*
3450  * PCM stuff
3451  */
3452 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3453                                       struct hda_codec *codec,
3454                                       struct snd_pcm_substream *substream)
3455 {
3456         return 0;
3457 }
3458
3459 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3460                                    struct hda_codec *codec,
3461                                    unsigned int stream_tag,
3462                                    unsigned int format,
3463                                    struct snd_pcm_substream *substream)
3464 {
3465         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3466         return 0;
3467 }
3468
3469 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3470                                    struct hda_codec *codec,
3471                                    struct snd_pcm_substream *substream)
3472 {
3473         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3474         return 0;
3475 }
3476
3477 static int set_pcm_default_values(struct hda_codec *codec,
3478                                   struct hda_pcm_stream *info)
3479 {
3480         int err;
3481
3482         /* query support PCM information from the given NID */
3483         if (info->nid && (!info->rates || !info->formats)) {
3484                 err = snd_hda_query_supported_pcm(codec, info->nid,
3485                                 info->rates ? NULL : &info->rates,
3486                                 info->formats ? NULL : &info->formats,
3487                                 info->maxbps ? NULL : &info->maxbps);
3488                 if (err < 0)
3489                         return err;
3490         }
3491         if (info->ops.open == NULL)
3492                 info->ops.open = hda_pcm_default_open_close;
3493         if (info->ops.close == NULL)
3494                 info->ops.close = hda_pcm_default_open_close;
3495         if (info->ops.prepare == NULL) {
3496                 if (snd_BUG_ON(!info->nid))
3497                         return -EINVAL;
3498                 info->ops.prepare = hda_pcm_default_prepare;
3499         }
3500         if (info->ops.cleanup == NULL) {
3501                 if (snd_BUG_ON(!info->nid))
3502                         return -EINVAL;
3503                 info->ops.cleanup = hda_pcm_default_cleanup;
3504         }
3505         return 0;
3506 }
3507
3508 /*
3509  * codec prepare/cleanup entries
3510  */
3511 int snd_hda_codec_prepare(struct hda_codec *codec,
3512                           struct hda_pcm_stream *hinfo,
3513                           unsigned int stream,
3514                           unsigned int format,
3515                           struct snd_pcm_substream *substream)
3516 {
3517         int ret;
3518         mutex_lock(&codec->bus->prepare_mutex);
3519         ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
3520         if (ret >= 0)
3521                 purify_inactive_streams(codec);
3522         mutex_unlock(&codec->bus->prepare_mutex);
3523         return ret;
3524 }
3525 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
3526
3527 void snd_hda_codec_cleanup(struct hda_codec *codec,
3528                            struct hda_pcm_stream *hinfo,
3529                            struct snd_pcm_substream *substream)
3530 {
3531         mutex_lock(&codec->bus->prepare_mutex);
3532         hinfo->ops.cleanup(hinfo, codec, substream);
3533         mutex_unlock(&codec->bus->prepare_mutex);
3534 }
3535 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
3536
3537 /* global */
3538 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3539         "Audio", "SPDIF", "HDMI", "Modem"
3540 };
3541
3542 /*
3543  * get the empty PCM device number to assign
3544  *
3545  * note the max device number is limited by HDA_MAX_PCMS, currently 10
3546  */
3547 static int get_empty_pcm_device(struct hda_bus *bus, int type)
3548 {
3549         /* audio device indices; not linear to keep compatibility */
3550         static int audio_idx[HDA_PCM_NTYPES][5] = {
3551                 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3552                 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3553                 [HDA_PCM_TYPE_HDMI]  = { 3, 7, 8, 9, -1 },
3554                 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
3555         };
3556         int i;
3557
3558         if (type >= HDA_PCM_NTYPES) {
3559                 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3560                 return -EINVAL;
3561         }
3562
3563         for (i = 0; audio_idx[type][i] >= 0 ; i++)
3564                 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3565                         return audio_idx[type][i];
3566
3567         snd_printk(KERN_WARNING "Too many %s devices\n",
3568                 snd_hda_pcm_type_name[type]);
3569         return -EAGAIN;
3570 }
3571
3572 /*
3573  * attach a new PCM stream
3574  */
3575 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
3576 {
3577         struct hda_bus *bus = codec->bus;
3578         struct hda_pcm_stream *info;
3579         int stream, err;
3580
3581         if (snd_BUG_ON(!pcm->name))
3582                 return -EINVAL;
3583         for (stream = 0; stream < 2; stream++) {
3584                 info = &pcm->stream[stream];
3585                 if (info->substreams) {
3586                         err = set_pcm_default_values(codec, info);
3587                         if (err < 0)
3588                                 return err;
3589                 }
3590         }
3591         return bus->ops.attach_pcm(bus, codec, pcm);
3592 }
3593
3594 /* assign all PCMs of the given codec */
3595 int snd_hda_codec_build_pcms(struct hda_codec *codec)
3596 {
3597         unsigned int pcm;
3598         int err;
3599
3600         if (!codec->num_pcms) {
3601                 if (!codec->patch_ops.build_pcms)
3602                         return 0;
3603                 err = codec->patch_ops.build_pcms(codec);
3604                 if (err < 0) {
3605                         printk(KERN_ERR "hda_codec: cannot build PCMs"
3606                                "for #%d (error %d)\n", codec->addr, err);
3607                         err = snd_hda_codec_reset(codec);
3608                         if (err < 0) {
3609                                 printk(KERN_ERR
3610                                        "hda_codec: cannot revert codec\n");
3611                                 return err;
3612                         }
3613                 }
3614         }
3615         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
3616                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
3617                 int dev;
3618
3619                 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
3620                         continue; /* no substreams assigned */
3621
3622                 if (!cpcm->pcm) {
3623                         dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
3624                         if (dev < 0)
3625                                 continue; /* no fatal error */
3626                         cpcm->device = dev;
3627                         err = snd_hda_attach_pcm(codec, cpcm);
3628                         if (err < 0) {
3629                                 printk(KERN_ERR "hda_codec: cannot attach "
3630                                        "PCM stream %d for codec #%d\n",
3631                                        dev, codec->addr);
3632                                 continue; /* no fatal error */
3633                         }
3634                 }
3635         }
3636         return 0;
3637 }
3638
3639 /**
3640  * snd_hda_build_pcms - build PCM information
3641  * @bus: the BUS
3642  *
3643  * Create PCM information for each codec included in the bus.
3644  *
3645  * The build_pcms codec patch is requested to set up codec->num_pcms and
3646  * codec->pcm_info properly.  The array is referred by the top-level driver
3647  * to create its PCM instances.
3648  * The allocated codec->pcm_info should be released in codec->patch_ops.free
3649  * callback.
3650  *
3651  * At least, substreams, channels_min and channels_max must be filled for
3652  * each stream.  substreams = 0 indicates that the stream doesn't exist.
3653  * When rates and/or formats are zero, the supported values are queried
3654  * from the given nid.  The nid is used also by the default ops.prepare
3655  * and ops.cleanup callbacks.
3656  *
3657  * The driver needs to call ops.open in its open callback.  Similarly,
3658  * ops.close is supposed to be called in the close callback.
3659  * ops.prepare should be called in the prepare or hw_params callback
3660  * with the proper parameters for set up.
3661  * ops.cleanup should be called in hw_free for clean up of streams.
3662  *
3663  * This function returns 0 if successfull, or a negative error code.
3664  */
3665 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
3666 {
3667         struct hda_codec *codec;
3668
3669         list_for_each_entry(codec, &bus->codec_list, list) {
3670                 int err = snd_hda_codec_build_pcms(codec);
3671                 if (err < 0)
3672                         return err;
3673         }
3674         return 0;
3675 }
3676 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
3677
3678 /**
3679  * snd_hda_check_board_config - compare the current codec with the config table
3680  * @codec: the HDA codec
3681  * @num_configs: number of config enums
3682  * @models: array of model name strings
3683  * @tbl: configuration table, terminated by null entries
3684  *
3685  * Compares the modelname or PCI subsystem id of the current codec with the
3686  * given configuration table.  If a matching entry is found, returns its
3687  * config value (supposed to be 0 or positive).
3688  *
3689  * If no entries are matching, the function returns a negative value.
3690  */
3691 int snd_hda_check_board_config(struct hda_codec *codec,
3692                                int num_configs, const char **models,
3693                                const struct snd_pci_quirk *tbl)
3694 {
3695         if (codec->modelname && models) {
3696                 int i;
3697                 for (i = 0; i < num_configs; i++) {
3698                         if (models[i] &&
3699                             !strcmp(codec->modelname, models[i])) {
3700                                 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3701                                            "selected\n", models[i]);
3702                                 return i;
3703                         }
3704                 }
3705         }
3706
3707         if (!codec->bus->pci || !tbl)
3708                 return -1;
3709
3710         tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3711         if (!tbl)
3712                 return -1;
3713         if (tbl->value >= 0 && tbl->value < num_configs) {
3714 #ifdef CONFIG_SND_DEBUG_VERBOSE
3715                 char tmp[10];
3716                 const char *model = NULL;
3717                 if (models)
3718                         model = models[tbl->value];
3719                 if (!model) {
3720                         sprintf(tmp, "#%d", tbl->value);
3721                         model = tmp;
3722                 }
3723                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3724                             "for config %x:%x (%s)\n",
3725                             model, tbl->subvendor, tbl->subdevice,
3726                             (tbl->name ? tbl->name : "Unknown device"));
3727 #endif
3728                 return tbl->value;
3729         }
3730         return -1;
3731 }
3732 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3733
3734 /**
3735  * snd_hda_check_board_codec_sid_config - compare the current codec
3736                                         subsystem ID with the
3737                                         config table
3738
3739            This is important for Gateway notebooks with SB450 HDA Audio
3740            where the vendor ID of the PCI device is:
3741                 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3742            and the vendor/subvendor are found only at the codec.
3743
3744  * @codec: the HDA codec
3745  * @num_configs: number of config enums
3746  * @models: array of model name strings
3747  * @tbl: configuration table, terminated by null entries
3748  *
3749  * Compares the modelname or PCI subsystem id of the current codec with the
3750  * given configuration table.  If a matching entry is found, returns its
3751  * config value (supposed to be 0 or positive).
3752  *
3753  * If no entries are matching, the function returns a negative value.
3754  */
3755 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3756                                int num_configs, const char **models,
3757                                const struct snd_pci_quirk *tbl)
3758 {
3759         const struct snd_pci_quirk *q;
3760
3761         /* Search for codec ID */
3762         for (q = tbl; q->subvendor; q++) {
3763                 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3764
3765                 if (vendorid == codec->subsystem_id)
3766                         break;
3767         }
3768
3769         if (!q->subvendor)
3770                 return -1;
3771
3772         tbl = q;
3773
3774         if (tbl->value >= 0 && tbl->value < num_configs) {
3775 #ifdef CONFIG_SND_DEBUG_VERBOSE
3776                 char tmp[10];
3777                 const char *model = NULL;
3778                 if (models)
3779                         model = models[tbl->value];
3780                 if (!model) {
3781                         sprintf(tmp, "#%d", tbl->value);
3782                         model = tmp;
3783                 }
3784                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3785                             "for config %x:%x (%s)\n",
3786                             model, tbl->subvendor, tbl->subdevice,
3787                             (tbl->name ? tbl->name : "Unknown device"));
3788 #endif
3789                 return tbl->value;
3790         }
3791         return -1;
3792 }
3793 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3794
3795 /**
3796  * snd_hda_add_new_ctls - create controls from the array
3797  * @codec: the HDA codec
3798  * @knew: the array of struct snd_kcontrol_new
3799  *
3800  * This helper function creates and add new controls in the given array.
3801  * The array must be terminated with an empty entry as terminator.
3802  *
3803  * Returns 0 if successful, or a negative error code.
3804  */
3805 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3806 {
3807         int err;
3808
3809         for (; knew->name; knew++) {
3810                 struct snd_kcontrol *kctl;
3811                 int addr = 0, idx = 0;
3812                 if (knew->iface == -1)  /* skip this codec private value */
3813                         continue;
3814                 for (;;) {
3815                         kctl = snd_ctl_new1(knew, codec);
3816                         if (!kctl)
3817                                 return -ENOMEM;
3818                         if (addr > 0)
3819                                 kctl->id.device = addr;
3820                         if (idx > 0)
3821                                 kctl->id.index = idx;
3822                         err = snd_hda_ctl_add(codec, 0, kctl);
3823                         if (!err)
3824                                 break;
3825                         /* try first with another device index corresponding to
3826                          * the codec addr; if it still fails (or it's the
3827                          * primary codec), then try another control index
3828                          */
3829                         if (!addr && codec->addr)
3830                                 addr = codec->addr;
3831                         else if (!idx && !knew->index) {
3832                                 idx = find_empty_mixer_ctl_idx(codec,
3833                                                                knew->name);
3834                                 if (idx <= 0)
3835                                         return err;
3836                         } else
3837                                 return err;
3838                 }
3839         }
3840         return 0;
3841 }
3842 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3843
3844 #ifdef CONFIG_SND_HDA_POWER_SAVE
3845 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3846                                 unsigned int power_state);
3847
3848 static void hda_power_work(struct work_struct *work)
3849 {
3850         struct hda_codec *codec =
3851                 container_of(work, struct hda_codec, power_work.work);
3852         struct hda_bus *bus = codec->bus;
3853
3854         if (!codec->power_on || codec->power_count) {
3855                 codec->power_transition = 0;
3856                 return;
3857         }
3858
3859         hda_call_codec_suspend(codec);
3860         if (bus->ops.pm_notify)
3861                 bus->ops.pm_notify(bus);
3862 }
3863
3864 static void hda_keep_power_on(struct hda_codec *codec)
3865 {
3866         codec->power_count++;
3867         codec->power_on = 1;
3868         codec->power_jiffies = jiffies;
3869 }
3870
3871 /* update the power on/off account with the current jiffies */
3872 void snd_hda_update_power_acct(struct hda_codec *codec)
3873 {
3874         unsigned long delta = jiffies - codec->power_jiffies;
3875         if (codec->power_on)
3876                 codec->power_on_acct += delta;
3877         else
3878                 codec->power_off_acct += delta;
3879         codec->power_jiffies += delta;
3880 }
3881
3882 /**
3883  * snd_hda_power_up - Power-up the codec
3884  * @codec: HD-audio codec
3885  *
3886  * Increment the power-up counter and power up the hardware really when
3887  * not turned on yet.
3888  */
3889 void snd_hda_power_up(struct hda_codec *codec)
3890 {
3891         struct hda_bus *bus = codec->bus;
3892
3893         codec->power_count++;
3894         if (codec->power_on || codec->power_transition)
3895                 return;
3896
3897         snd_hda_update_power_acct(codec);
3898         codec->power_on = 1;
3899         codec->power_jiffies = jiffies;
3900         if (bus->ops.pm_notify)
3901                 bus->ops.pm_notify(bus);
3902         hda_call_codec_resume(codec);
3903         cancel_delayed_work(&codec->power_work);
3904         codec->power_transition = 0;
3905 }
3906 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3907
3908 #define power_save(codec)       \
3909         ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3910
3911 /**
3912  * snd_hda_power_down - Power-down the codec
3913  * @codec: HD-audio codec
3914  *
3915  * Decrement the power-up counter and schedules the power-off work if
3916  * the counter rearches to zero.
3917  */
3918 void snd_hda_power_down(struct hda_codec *codec)
3919 {
3920         --codec->power_count;
3921         if (!codec->power_on || codec->power_count || codec->power_transition)
3922                 return;
3923         if (power_save(codec)) {
3924                 codec->power_transition = 1; /* avoid reentrance */
3925                 queue_delayed_work(codec->bus->workq, &codec->power_work,
3926                                 msecs_to_jiffies(power_save(codec) * 1000));
3927         }
3928 }
3929 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3930
3931 /**
3932  * snd_hda_check_amp_list_power - Check the amp list and update the power
3933  * @codec: HD-audio codec
3934  * @check: the object containing an AMP list and the status
3935  * @nid: NID to check / update
3936  *
3937  * Check whether the given NID is in the amp list.  If it's in the list,
3938  * check the current AMP status, and update the the power-status according
3939  * to the mute status.
3940  *
3941  * This function is supposed to be set or called from the check_power_status
3942  * patch ops.
3943  */
3944 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3945                                  struct hda_loopback_check *check,
3946                                  hda_nid_t nid)
3947 {
3948         struct hda_amp_list *p;
3949         int ch, v;
3950
3951         if (!check->amplist)
3952                 return 0;
3953         for (p = check->amplist; p->nid; p++) {
3954                 if (p->nid == nid)
3955                         break;
3956         }
3957         if (!p->nid)
3958                 return 0; /* nothing changed */
3959
3960         for (p = check->amplist; p->nid; p++) {
3961                 for (ch = 0; ch < 2; ch++) {
3962                         v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3963                                                    p->idx);
3964                         if (!(v & HDA_AMP_MUTE) && v > 0) {
3965                                 if (!check->power_on) {
3966                                         check->power_on = 1;
3967                                         snd_hda_power_up(codec);
3968                                 }
3969                                 return 1;
3970                         }
3971                 }
3972         }
3973         if (check->power_on) {
3974                 check->power_on = 0;
3975                 snd_hda_power_down(codec);
3976         }
3977         return 0;
3978 }
3979 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3980 #endif
3981
3982 /*
3983  * Channel mode helper
3984  */
3985
3986 /**
3987  * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
3988  */
3989 int snd_hda_ch_mode_info(struct hda_codec *codec,
3990                          struct snd_ctl_elem_info *uinfo,
3991                          const struct hda_channel_mode *chmode,
3992                          int num_chmodes)
3993 {
3994         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3995         uinfo->count = 1;
3996         uinfo->value.enumerated.items = num_chmodes;
3997         if (uinfo->value.enumerated.item >= num_chmodes)
3998                 uinfo->value.enumerated.item = num_chmodes - 1;
3999         sprintf(uinfo->value.enumerated.name, "%dch",
4000                 chmode[uinfo->value.enumerated.item].channels);
4001         return 0;
4002 }
4003 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4004
4005 /**
4006  * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4007  */
4008 int snd_hda_ch_mode_get(struct hda_codec *codec,
4009                         struct snd_ctl_elem_value *ucontrol,
4010                         const struct hda_channel_mode *chmode,
4011                         int num_chmodes,
4012                         int max_channels)
4013 {
4014         int i;
4015
4016         for (i = 0; i < num_chmodes; i++) {
4017                 if (max_channels == chmode[i].channels) {
4018                         ucontrol->value.enumerated.item[0] = i;
4019                         break;
4020                 }
4021         }
4022         return 0;
4023 }
4024 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4025
4026 /**
4027  * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4028  */
4029 int snd_hda_ch_mode_put(struct hda_codec *codec,
4030                         struct snd_ctl_elem_value *ucontrol,
4031                         const struct hda_channel_mode *chmode,
4032                         int num_chmodes,
4033                         int *max_channelsp)
4034 {
4035         unsigned int mode;
4036
4037         mode = ucontrol->value.enumerated.item[0];
4038         if (mode >= num_chmodes)
4039                 return -EINVAL;
4040         if (*max_channelsp == chmode[mode].channels)
4041                 return 0;
4042         /* change the current channel setting */
4043         *max_channelsp = chmode[mode].channels;
4044         if (chmode[mode].sequence)
4045                 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4046         return 1;
4047 }
4048 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4049
4050 /*
4051  * input MUX helper
4052  */
4053
4054 /**
4055  * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4056  */
4057 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4058                            struct snd_ctl_elem_info *uinfo)
4059 {
4060         unsigned int index;
4061
4062         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4063         uinfo->count = 1;
4064         uinfo->value.enumerated.items = imux->num_items;
4065         if (!imux->num_items)
4066                 return 0;
4067         index = uinfo->value.enumerated.item;
4068         if (index >= imux->num_items)
4069                 index = imux->num_items - 1;
4070         strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4071         return 0;
4072 }
4073 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4074
4075 /**
4076  * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4077  */
4078 int snd_hda_input_mux_put(struct hda_codec *codec,
4079                           const struct hda_input_mux *imux,
4080                           struct snd_ctl_elem_value *ucontrol,
4081                           hda_nid_t nid,
4082                           unsigned int *cur_val)
4083 {
4084         unsigned int idx;
4085
4086         if (!imux->num_items)
4087                 return 0;
4088         idx = ucontrol->value.enumerated.item[0];
4089         if (idx >= imux->num_items)
4090                 idx = imux->num_items - 1;
4091         if (*cur_val == idx)
4092                 return 0;
4093         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4094                                   imux->items[idx].index);
4095         *cur_val = idx;
4096         return 1;
4097 }
4098 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4099
4100
4101 /*
4102  * Multi-channel / digital-out PCM helper functions
4103  */
4104
4105 /* setup SPDIF output stream */
4106 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4107                                  unsigned int stream_tag, unsigned int format)
4108 {
4109         /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4110         if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
4111                 set_dig_out_convert(codec, nid,
4112                                     codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
4113                                     -1);
4114         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4115         if (codec->slave_dig_outs) {
4116                 hda_nid_t *d;
4117                 for (d = codec->slave_dig_outs; *d; d++)
4118                         snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4119                                                    format);
4120         }
4121         /* turn on again (if needed) */
4122         if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
4123                 set_dig_out_convert(codec, nid,
4124                                     codec->spdif_ctls & 0xff, -1);
4125 }
4126
4127 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4128 {
4129         snd_hda_codec_cleanup_stream(codec, nid);
4130         if (codec->slave_dig_outs) {
4131                 hda_nid_t *d;
4132                 for (d = codec->slave_dig_outs; *d; d++)
4133                         snd_hda_codec_cleanup_stream(codec, *d);
4134         }
4135 }
4136
4137 /**
4138  * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4139  * @bus: HD-audio bus
4140  */
4141 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4142 {
4143         struct hda_codec *codec;
4144
4145         if (!bus)
4146                 return;
4147         list_for_each_entry(codec, &bus->codec_list, list) {
4148 #ifdef CONFIG_SND_HDA_POWER_SAVE
4149                 if (!codec->power_on)
4150                         continue;
4151 #endif
4152                 if (codec->patch_ops.reboot_notify)
4153                         codec->patch_ops.reboot_notify(codec);
4154         }
4155 }
4156 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
4157
4158 /**
4159  * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4160  */
4161 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4162                                struct hda_multi_out *mout)
4163 {
4164         mutex_lock(&codec->spdif_mutex);
4165         if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4166                 /* already opened as analog dup; reset it once */
4167                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4168         mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4169         mutex_unlock(&codec->spdif_mutex);
4170         return 0;
4171 }
4172 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
4173
4174 /**
4175  * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4176  */
4177 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4178                                   struct hda_multi_out *mout,
4179                                   unsigned int stream_tag,
4180                                   unsigned int format,
4181                                   struct snd_pcm_substream *substream)
4182 {
4183         mutex_lock(&codec->spdif_mutex);
4184         setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4185         mutex_unlock(&codec->spdif_mutex);
4186         return 0;
4187 }
4188 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
4189
4190 /**
4191  * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4192  */
4193 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4194                                   struct hda_multi_out *mout)
4195 {
4196         mutex_lock(&codec->spdif_mutex);
4197         cleanup_dig_out_stream(codec, mout->dig_out_nid);
4198         mutex_unlock(&codec->spdif_mutex);
4199         return 0;
4200 }
4201 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4202
4203 /**
4204  * snd_hda_multi_out_dig_close - release the digital out stream
4205  */
4206 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4207                                 struct hda_multi_out *mout)
4208 {
4209         mutex_lock(&codec->spdif_mutex);
4210         mout->dig_out_used = 0;
4211         mutex_unlock(&codec->spdif_mutex);
4212         return 0;
4213 }
4214 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
4215
4216 /**
4217  * snd_hda_multi_out_analog_open - open analog outputs
4218  *
4219  * Open analog outputs and set up the hw-constraints.
4220  * If the digital outputs can be opened as slave, open the digital
4221  * outputs, too.
4222  */
4223 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4224                                   struct hda_multi_out *mout,
4225                                   struct snd_pcm_substream *substream,
4226                                   struct hda_pcm_stream *hinfo)
4227 {
4228         struct snd_pcm_runtime *runtime = substream->runtime;
4229         runtime->hw.channels_max = mout->max_channels;
4230         if (mout->dig_out_nid) {
4231                 if (!mout->analog_rates) {
4232                         mout->analog_rates = hinfo->rates;
4233                         mout->analog_formats = hinfo->formats;
4234                         mout->analog_maxbps = hinfo->maxbps;
4235                 } else {
4236                         runtime->hw.rates = mout->analog_rates;
4237                         runtime->hw.formats = mout->analog_formats;
4238                         hinfo->maxbps = mout->analog_maxbps;
4239                 }
4240                 if (!mout->spdif_rates) {
4241                         snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4242                                                     &mout->spdif_rates,
4243                                                     &mout->spdif_formats,
4244                                                     &mout->spdif_maxbps);
4245                 }
4246                 mutex_lock(&codec->spdif_mutex);
4247                 if (mout->share_spdif) {
4248                         if ((runtime->hw.rates & mout->spdif_rates) &&
4249                             (runtime->hw.formats & mout->spdif_formats)) {
4250                                 runtime->hw.rates &= mout->spdif_rates;
4251                                 runtime->hw.formats &= mout->spdif_formats;
4252                                 if (mout->spdif_maxbps < hinfo->maxbps)
4253                                         hinfo->maxbps = mout->spdif_maxbps;
4254                         } else {
4255                                 mout->share_spdif = 0;
4256                                 /* FIXME: need notify? */
4257                         }
4258                 }
4259                 mutex_unlock(&codec->spdif_mutex);
4260         }
4261         return snd_pcm_hw_constraint_step(substream->runtime, 0,
4262                                           SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4263 }
4264 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
4265
4266 /**
4267  * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4268  *
4269  * Set up the i/o for analog out.
4270  * When the digital out is available, copy the front out to digital out, too.
4271  */
4272 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4273                                      struct hda_multi_out *mout,
4274                                      unsigned int stream_tag,
4275                                      unsigned int format,
4276                                      struct snd_pcm_substream *substream)
4277 {
4278         hda_nid_t *nids = mout->dac_nids;
4279         int chs = substream->runtime->channels;
4280         int i;
4281
4282         mutex_lock(&codec->spdif_mutex);
4283         if (mout->dig_out_nid && mout->share_spdif &&
4284             mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4285                 if (chs == 2 &&
4286                     snd_hda_is_supported_format(codec, mout->dig_out_nid,
4287                                                 format) &&
4288                     !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
4289                         mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4290                         setup_dig_out_stream(codec, mout->dig_out_nid,
4291                                              stream_tag, format);
4292                 } else {
4293                         mout->dig_out_used = 0;
4294                         cleanup_dig_out_stream(codec, mout->dig_out_nid);
4295                 }
4296         }
4297         mutex_unlock(&codec->spdif_mutex);
4298
4299         /* front */
4300         snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4301                                    0, format);
4302         if (!mout->no_share_stream &&
4303             mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4304                 /* headphone out will just decode front left/right (stereo) */
4305                 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4306                                            0, format);
4307         /* extra outputs copied from front */
4308         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4309                 if (!mout->no_share_stream && mout->extra_out_nid[i])
4310                         snd_hda_codec_setup_stream(codec,
4311                                                    mout->extra_out_nid[i],
4312                                                    stream_tag, 0, format);
4313
4314         /* surrounds */
4315         for (i = 1; i < mout->num_dacs; i++) {
4316                 if (chs >= (i + 1) * 2) /* independent out */
4317                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4318                                                    i * 2, format);
4319                 else if (!mout->no_share_stream) /* copy front */
4320                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4321                                                    0, format);
4322         }
4323         return 0;
4324 }
4325 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
4326
4327 /**
4328  * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4329  */
4330 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4331                                      struct hda_multi_out *mout)
4332 {
4333         hda_nid_t *nids = mout->dac_nids;
4334         int i;
4335
4336         for (i = 0; i < mout->num_dacs; i++)
4337                 snd_hda_codec_cleanup_stream(codec, nids[i]);
4338         if (mout->hp_nid)
4339                 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4340         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4341                 if (mout->extra_out_nid[i])
4342                         snd_hda_codec_cleanup_stream(codec,
4343                                                      mout->extra_out_nid[i]);
4344         mutex_lock(&codec->spdif_mutex);
4345         if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4346                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4347                 mout->dig_out_used = 0;
4348         }
4349         mutex_unlock(&codec->spdif_mutex);
4350         return 0;
4351 }
4352 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4353
4354 /*
4355  * Helper for automatic pin configuration
4356  */
4357
4358 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
4359 {
4360         for (; *list; list++)
4361                 if (*list == nid)
4362                         return 1;
4363         return 0;
4364 }
4365
4366
4367 /*
4368  * Sort an associated group of pins according to their sequence numbers.
4369  */
4370 static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences,
4371                                   int num_pins)
4372 {
4373         int i, j;
4374         short seq;
4375         hda_nid_t nid;
4376
4377         for (i = 0; i < num_pins; i++) {
4378                 for (j = i + 1; j < num_pins; j++) {
4379                         if (sequences[i] > sequences[j]) {
4380                                 seq = sequences[i];
4381                                 sequences[i] = sequences[j];
4382                                 sequences[j] = seq;
4383                                 nid = pins[i];
4384                                 pins[i] = pins[j];
4385                                 pins[j] = nid;
4386                         }
4387                 }
4388         }
4389 }
4390
4391
4392 /* add the found input-pin to the cfg->inputs[] table */
4393 static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid,
4394                                    int type)
4395 {
4396         if (cfg->num_inputs < AUTO_CFG_MAX_INS) {
4397                 cfg->inputs[cfg->num_inputs].pin = nid;
4398                 cfg->inputs[cfg->num_inputs].type = type;
4399                 cfg->num_inputs++;
4400         }
4401 }
4402
4403 /* sort inputs in the order of AUTO_PIN_* type */
4404 static void sort_autocfg_input_pins(struct auto_pin_cfg *cfg)
4405 {
4406         int i, j;
4407
4408         for (i = 0; i < cfg->num_inputs; i++) {
4409                 for (j = i + 1; j < cfg->num_inputs; j++) {
4410                         if (cfg->inputs[i].type > cfg->inputs[j].type) {
4411                                 struct auto_pin_cfg_item tmp;
4412                                 tmp = cfg->inputs[i];
4413                                 cfg->inputs[i] = cfg->inputs[j];
4414                                 cfg->inputs[j] = tmp;
4415                         }
4416                 }
4417         }
4418 }
4419
4420 /*
4421  * Parse all pin widgets and store the useful pin nids to cfg
4422  *
4423  * The number of line-outs or any primary output is stored in line_outs,
4424  * and the corresponding output pins are assigned to line_out_pins[],
4425  * in the order of front, rear, CLFE, side, ...
4426  *
4427  * If more extra outputs (speaker and headphone) are found, the pins are
4428  * assisnged to hp_pins[] and speaker_pins[], respectively.  If no line-out jack
4429  * is detected, one of speaker of HP pins is assigned as the primary
4430  * output, i.e. to line_out_pins[0].  So, line_outs is always positive
4431  * if any analog output exists.
4432  *
4433  * The analog input pins are assigned to inputs array.
4434  * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4435  * respectively.
4436  */
4437 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
4438                                  struct auto_pin_cfg *cfg,
4439                                  hda_nid_t *ignore_nids)
4440 {
4441         hda_nid_t nid, end_nid;
4442         short seq, assoc_line_out, assoc_speaker;
4443         short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4444         short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
4445         short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
4446         int i;
4447
4448         memset(cfg, 0, sizeof(*cfg));
4449
4450         memset(sequences_line_out, 0, sizeof(sequences_line_out));
4451         memset(sequences_speaker, 0, sizeof(sequences_speaker));
4452         memset(sequences_hp, 0, sizeof(sequences_hp));
4453         assoc_line_out = assoc_speaker = 0;
4454
4455         end_nid = codec->start_nid + codec->num_nodes;
4456         for (nid = codec->start_nid; nid < end_nid; nid++) {
4457                 unsigned int wid_caps = get_wcaps(codec, nid);
4458                 unsigned int wid_type = get_wcaps_type(wid_caps);
4459                 unsigned int def_conf;
4460                 short assoc, loc;
4461
4462                 /* read all default configuration for pin complex */
4463                 if (wid_type != AC_WID_PIN)
4464                         continue;
4465                 /* ignore the given nids (e.g. pc-beep returns error) */
4466                 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4467                         continue;
4468
4469                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4470                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
4471                         continue;
4472                 loc = get_defcfg_location(def_conf);
4473                 switch (get_defcfg_device(def_conf)) {
4474                 case AC_JACK_LINE_OUT:
4475                         seq = get_defcfg_sequence(def_conf);
4476                         assoc = get_defcfg_association(def_conf);
4477
4478                         if (!(wid_caps & AC_WCAP_STEREO))
4479                                 if (!cfg->mono_out_pin)
4480                                         cfg->mono_out_pin = nid;
4481                         if (!assoc)
4482                                 continue;
4483                         if (!assoc_line_out)
4484                                 assoc_line_out = assoc;
4485                         else if (assoc_line_out != assoc)
4486                                 continue;
4487                         if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4488                                 continue;
4489                         cfg->line_out_pins[cfg->line_outs] = nid;
4490                         sequences_line_out[cfg->line_outs] = seq;
4491                         cfg->line_outs++;
4492                         break;
4493                 case AC_JACK_SPEAKER:
4494                         seq = get_defcfg_sequence(def_conf);
4495                         assoc = get_defcfg_association(def_conf);
4496                         if (!assoc)
4497                                 continue;
4498                         if (!assoc_speaker)
4499                                 assoc_speaker = assoc;
4500                         else if (assoc_speaker != assoc)
4501                                 continue;
4502                         if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4503                                 continue;
4504                         cfg->speaker_pins[cfg->speaker_outs] = nid;
4505                         sequences_speaker[cfg->speaker_outs] = seq;
4506                         cfg->speaker_outs++;
4507                         break;
4508                 case AC_JACK_HP_OUT:
4509                         seq = get_defcfg_sequence(def_conf);
4510                         assoc = get_defcfg_association(def_conf);
4511                         if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4512                                 continue;
4513                         cfg->hp_pins[cfg->hp_outs] = nid;
4514                         sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
4515                         cfg->hp_outs++;
4516                         break;
4517                 case AC_JACK_MIC_IN:
4518                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_MIC);
4519                         break;
4520                 case AC_JACK_LINE_IN:
4521                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_LINE_IN);
4522                         break;
4523                 case AC_JACK_CD:
4524                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD);
4525                         break;
4526                 case AC_JACK_AUX:
4527                         add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX);
4528                         break;
4529                 case AC_JACK_SPDIF_OUT:
4530                 case AC_JACK_DIG_OTHER_OUT:
4531                         if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
4532                                 continue;
4533                         cfg->dig_out_pins[cfg->dig_outs] = nid;
4534                         cfg->dig_out_type[cfg->dig_outs] =
4535                                 (loc == AC_JACK_LOC_HDMI) ?
4536                                 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
4537                         cfg->dig_outs++;
4538                         break;
4539                 case AC_JACK_SPDIF_IN:
4540                 case AC_JACK_DIG_OTHER_IN:
4541                         cfg->dig_in_pin = nid;
4542                         if (loc == AC_JACK_LOC_HDMI)
4543                                 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
4544                         else
4545                                 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
4546                         break;
4547                 }
4548         }
4549
4550         /* FIX-UP:
4551          * If no line-out is defined but multiple HPs are found,
4552          * some of them might be the real line-outs.
4553          */
4554         if (!cfg->line_outs && cfg->hp_outs > 1) {
4555                 int i = 0;
4556                 while (i < cfg->hp_outs) {
4557                         /* The real HPs should have the sequence 0x0f */
4558                         if ((sequences_hp[i] & 0x0f) == 0x0f) {
4559                                 i++;
4560                                 continue;
4561                         }
4562                         /* Move it to the line-out table */
4563                         cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
4564                         sequences_line_out[cfg->line_outs] = sequences_hp[i];
4565                         cfg->line_outs++;
4566                         cfg->hp_outs--;
4567                         memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
4568                                 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
4569                         memmove(sequences_hp + i, sequences_hp + i + 1,
4570                                 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
4571                 }
4572                 memset(cfg->hp_pins + cfg->hp_outs, 0,
4573                        sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs));
4574                 if (!cfg->hp_outs)
4575                         cfg->line_out_type = AUTO_PIN_HP_OUT;
4576
4577         }
4578
4579         /* sort by sequence */
4580         sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
4581                               cfg->line_outs);
4582         sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
4583                               cfg->speaker_outs);
4584         sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
4585                               cfg->hp_outs);
4586
4587         /*
4588          * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4589          * as a primary output
4590          */
4591         if (!cfg->line_outs) {
4592                 if (cfg->speaker_outs) {
4593                         cfg->line_outs = cfg->speaker_outs;
4594                         memcpy(cfg->line_out_pins, cfg->speaker_pins,
4595                                sizeof(cfg->speaker_pins));
4596                         cfg->speaker_outs = 0;
4597                         memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
4598                         cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
4599                 } else if (cfg->hp_outs) {
4600                         cfg->line_outs = cfg->hp_outs;
4601                         memcpy(cfg->line_out_pins, cfg->hp_pins,
4602                                sizeof(cfg->hp_pins));
4603                         cfg->hp_outs = 0;
4604                         memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4605                         cfg->line_out_type = AUTO_PIN_HP_OUT;
4606                 }
4607         }
4608
4609         /* Reorder the surround channels
4610          * ALSA sequence is front/surr/clfe/side
4611          * HDA sequence is:
4612          *    4-ch: front/surr  =>  OK as it is
4613          *    6-ch: front/clfe/surr
4614          *    8-ch: front/clfe/rear/side|fc
4615          */
4616         switch (cfg->line_outs) {
4617         case 3:
4618         case 4:
4619                 nid = cfg->line_out_pins[1];
4620                 cfg->line_out_pins[1] = cfg->line_out_pins[2];
4621                 cfg->line_out_pins[2] = nid;
4622                 break;
4623         }
4624
4625         sort_autocfg_input_pins(cfg);
4626
4627         /*
4628          * debug prints of the parsed results
4629          */
4630         snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4631                    cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
4632                    cfg->line_out_pins[2], cfg->line_out_pins[3],
4633                    cfg->line_out_pins[4]);
4634         snd_printd("   speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4635                    cfg->speaker_outs, cfg->speaker_pins[0],
4636                    cfg->speaker_pins[1], cfg->speaker_pins[2],
4637                    cfg->speaker_pins[3], cfg->speaker_pins[4]);
4638         snd_printd("   hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4639                    cfg->hp_outs, cfg->hp_pins[0],
4640                    cfg->hp_pins[1], cfg->hp_pins[2],
4641                    cfg->hp_pins[3], cfg->hp_pins[4]);
4642         snd_printd("   mono: mono_out=0x%x\n", cfg->mono_out_pin);
4643         if (cfg->dig_outs)
4644                 snd_printd("   dig-out=0x%x/0x%x\n",
4645                            cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
4646         snd_printd("   inputs:");
4647         for (i = 0; i < cfg->num_inputs; i++) {
4648                 snd_printdd(" %s=0x%x",
4649                             hda_get_autocfg_input_label(codec, cfg, i),
4650                             cfg->inputs[i].pin);
4651         }
4652         snd_printd("\n");
4653         if (cfg->dig_in_pin)
4654                 snd_printd("   dig-in=0x%x\n", cfg->dig_in_pin);
4655
4656         return 0;
4657 }
4658 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
4659
4660 int snd_hda_get_input_pin_attr(unsigned int def_conf)
4661 {
4662         unsigned int loc = get_defcfg_location(def_conf);
4663         unsigned int conn = get_defcfg_connect(def_conf);
4664         if (conn == AC_JACK_PORT_NONE)
4665                 return INPUT_PIN_ATTR_UNUSED;
4666         /* Windows may claim the internal mic to be BOTH, too */
4667         if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH)
4668                 return INPUT_PIN_ATTR_INT;
4669         if ((loc & 0x30) == AC_JACK_LOC_INTERNAL)
4670                 return INPUT_PIN_ATTR_INT;
4671         if ((loc & 0x30) == AC_JACK_LOC_SEPARATE)
4672                 return INPUT_PIN_ATTR_DOCK;
4673         if (loc == AC_JACK_LOC_REAR)
4674                 return INPUT_PIN_ATTR_REAR;
4675         if (loc == AC_JACK_LOC_FRONT)
4676                 return INPUT_PIN_ATTR_FRONT;
4677         return INPUT_PIN_ATTR_NORMAL;
4678 }
4679 EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
4680
4681 /**
4682  * hda_get_input_pin_label - Give a label for the given input pin
4683  *
4684  * When check_location is true, the function checks the pin location
4685  * for mic and line-in pins, and set an appropriate prefix like "Front",
4686  * "Rear", "Internal".
4687  */
4688
4689 const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin,
4690                                         int check_location)
4691 {
4692         unsigned int def_conf;
4693         static const char *mic_names[] = {
4694                 "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic",
4695         };
4696         int attr;
4697
4698         def_conf = snd_hda_codec_get_pincfg(codec, pin);
4699
4700         switch (get_defcfg_device(def_conf)) {
4701         case AC_JACK_MIC_IN:
4702                 if (!check_location)
4703                         return "Mic";
4704                 attr = snd_hda_get_input_pin_attr(def_conf);
4705                 if (!attr)
4706                         return "None";
4707                 return mic_names[attr - 1];
4708         case AC_JACK_LINE_IN:
4709                 if (!check_location)
4710                         return "Line";
4711                 attr = snd_hda_get_input_pin_attr(def_conf);
4712                 if (!attr)
4713                         return "None";
4714                 if (attr == INPUT_PIN_ATTR_DOCK)
4715                         return "Dock Line";
4716                 return "Line";
4717         case AC_JACK_AUX:
4718                 return "Aux";
4719         case AC_JACK_CD:
4720                 return "CD";
4721         case AC_JACK_SPDIF_IN:
4722                 return "SPDIF In";
4723         case AC_JACK_DIG_OTHER_IN:
4724                 return "Digital In";
4725         default:
4726                 return "Misc";
4727         }
4728 }
4729 EXPORT_SYMBOL_HDA(hda_get_input_pin_label);
4730
4731 /* Check whether the location prefix needs to be added to the label.
4732  * If all mic-jacks are in the same location (e.g. rear panel), we don't
4733  * have to put "Front" prefix to each label.  In such a case, returns false.
4734  */
4735 static int check_mic_location_need(struct hda_codec *codec,
4736                                    const struct auto_pin_cfg *cfg,
4737                                    int input)
4738 {
4739         unsigned int defc;
4740         int i, attr, attr2;
4741
4742         defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin);
4743         attr = snd_hda_get_input_pin_attr(defc);
4744         /* for internal or docking mics, we need locations */
4745         if (attr <= INPUT_PIN_ATTR_NORMAL)
4746                 return 1;
4747
4748         attr = 0;
4749         for (i = 0; i < cfg->num_inputs; i++) {
4750                 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin);
4751                 attr2 = snd_hda_get_input_pin_attr(defc);
4752                 if (attr2 >= INPUT_PIN_ATTR_NORMAL) {
4753                         if (attr && attr != attr2)
4754                                 return 1; /* different locations found */
4755                         attr = attr2;
4756                 }
4757         }
4758         return 0;
4759 }
4760
4761 /**
4762  * hda_get_autocfg_input_label - Get a label for the given input
4763  *
4764  * Get a label for the given input pin defined by the autocfg item.
4765  * Unlike hda_get_input_pin_label(), this function checks all inputs
4766  * defined in autocfg and avoids the redundant mic/line prefix as much as
4767  * possible.
4768  */
4769 const char *hda_get_autocfg_input_label(struct hda_codec *codec,
4770                                         const struct auto_pin_cfg *cfg,
4771                                         int input)
4772 {
4773         int type = cfg->inputs[input].type;
4774         int has_multiple_pins = 0;
4775
4776         if ((input > 0 && cfg->inputs[input - 1].type == type) ||
4777             (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type))
4778                 has_multiple_pins = 1;
4779         if (has_multiple_pins && type == AUTO_PIN_MIC)
4780                 has_multiple_pins &= check_mic_location_need(codec, cfg, input);
4781         return hda_get_input_pin_label(codec, cfg->inputs[input].pin,
4782                                        has_multiple_pins);
4783 }
4784 EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
4785
4786 /**
4787  * snd_hda_add_imux_item - Add an item to input_mux
4788  *
4789  * When the same label is used already in the existing items, the number
4790  * suffix is appended to the label.  This label index number is stored
4791  * to type_idx when non-NULL pointer is given.
4792  */
4793 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
4794                           int index, int *type_idx)
4795 {
4796         int i, label_idx = 0;
4797         if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
4798                 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
4799                 return -EINVAL;
4800         }
4801         for (i = 0; i < imux->num_items; i++) {
4802                 if (!strncmp(label, imux->items[i].label, strlen(label)))
4803                         label_idx++;
4804         }
4805         if (type_idx)
4806                 *type_idx = label_idx;
4807         if (label_idx > 0)
4808                 snprintf(imux->items[imux->num_items].label,
4809                          sizeof(imux->items[imux->num_items].label),
4810                          "%s %d", label, label_idx);
4811         else
4812                 strlcpy(imux->items[imux->num_items].label, label,
4813                         sizeof(imux->items[imux->num_items].label));
4814         imux->items[imux->num_items].index = index;
4815         imux->num_items++;
4816         return 0;
4817 }
4818 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
4819
4820
4821 #ifdef CONFIG_PM
4822 /*
4823  * power management
4824  */
4825
4826 /**
4827  * snd_hda_suspend - suspend the codecs
4828  * @bus: the HDA bus
4829  *
4830  * Returns 0 if successful.
4831  */
4832 int snd_hda_suspend(struct hda_bus *bus)
4833 {
4834         struct hda_codec *codec;
4835
4836         list_for_each_entry(codec, &bus->codec_list, list) {
4837 #ifdef CONFIG_SND_HDA_POWER_SAVE
4838                 if (!codec->power_on)
4839                         continue;
4840 #endif
4841                 hda_call_codec_suspend(codec);
4842         }
4843         return 0;
4844 }
4845 EXPORT_SYMBOL_HDA(snd_hda_suspend);
4846
4847 /**
4848  * snd_hda_resume - resume the codecs
4849  * @bus: the HDA bus
4850  *
4851  * Returns 0 if successful.
4852  *
4853  * This fucntion is defined only when POWER_SAVE isn't set.
4854  * In the power-save mode, the codec is resumed dynamically.
4855  */
4856 int snd_hda_resume(struct hda_bus *bus)
4857 {
4858         struct hda_codec *codec;
4859
4860         list_for_each_entry(codec, &bus->codec_list, list) {
4861                 if (snd_hda_codec_needs_resume(codec))
4862                         hda_call_codec_resume(codec);
4863         }
4864         return 0;
4865 }
4866 EXPORT_SYMBOL_HDA(snd_hda_resume);
4867 #endif /* CONFIG_PM */
4868
4869 /*
4870  * generic arrays
4871  */
4872
4873 /**
4874  * snd_array_new - get a new element from the given array
4875  * @array: the array object
4876  *
4877  * Get a new element from the given array.  If it exceeds the
4878  * pre-allocated array size, re-allocate the array.
4879  *
4880  * Returns NULL if allocation failed.
4881  */
4882 void *snd_array_new(struct snd_array *array)
4883 {
4884         if (array->used >= array->alloced) {
4885                 int num = array->alloced + array->alloc_align;
4886                 void *nlist;
4887                 if (snd_BUG_ON(num >= 4096))
4888                         return NULL;
4889                 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
4890                 if (!nlist)
4891                         return NULL;
4892                 if (array->list) {
4893                         memcpy(nlist, array->list,
4894                                array->elem_size * array->alloced);
4895                         kfree(array->list);
4896                 }
4897                 array->list = nlist;
4898                 array->alloced = num;
4899         }
4900         return snd_array_elem(array, array->used++);
4901 }
4902 EXPORT_SYMBOL_HDA(snd_array_new);
4903
4904 /**
4905  * snd_array_free - free the given array elements
4906  * @array: the array object
4907  */
4908 void snd_array_free(struct snd_array *array)
4909 {
4910         kfree(array->list);
4911         array->used = 0;
4912         array->alloced = 0;
4913         array->list = NULL;
4914 }
4915 EXPORT_SYMBOL_HDA(snd_array_free);
4916
4917 /**
4918  * snd_print_pcm_rates - Print the supported PCM rates to the string buffer
4919  * @pcm: PCM caps bits
4920  * @buf: the string buffer to write
4921  * @buflen: the max buffer length
4922  *
4923  * used by hda_proc.c and hda_eld.c
4924  */
4925 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
4926 {
4927         static unsigned int rates[] = {
4928                 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
4929                 96000, 176400, 192000, 384000
4930         };
4931         int i, j;
4932
4933         for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
4934                 if (pcm & (1 << i))
4935                         j += snprintf(buf + j, buflen - j,  " %d", rates[i]);
4936
4937         buf[j] = '\0'; /* necessary when j == 0 */
4938 }
4939 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
4940
4941 /**
4942  * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4943  * @pcm: PCM caps bits
4944  * @buf: the string buffer to write
4945  * @buflen: the max buffer length
4946  *
4947  * used by hda_proc.c and hda_eld.c
4948  */
4949 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4950 {
4951         static unsigned int bits[] = { 8, 16, 20, 24, 32 };
4952         int i, j;
4953
4954         for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4955                 if (pcm & (AC_SUPPCM_BITS_8 << i))
4956                         j += snprintf(buf + j, buflen - j,  " %d", bits[i]);
4957
4958         buf[j] = '\0'; /* necessary when j == 0 */
4959 }
4960 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
4961
4962 MODULE_DESCRIPTION("HDA codec core");
4963 MODULE_LICENSE("GPL");