Merge linux-3.10.67 into dev-kernel-3.10
[linux-3.10.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/mm.h>
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/slab.h>
26 #include <linux/pci.h>
27 #include <linux/mutex.h>
28 #include <linux/module.h>
29 #include <sound/core.h>
30 #include "hda_codec.h"
31 #include <sound/asoundef.h>
32 #include <sound/tlv.h>
33 #include <sound/initval.h>
34 #include <sound/jack.h>
35 #include "hda_local.h"
36 #include "hda_beep.h"
37 #include "hda_jack.h"
38 #include <sound/hda_hwdep.h>
39
40 #define CREATE_TRACE_POINTS
41 #include "hda_trace.h"
42
43 /*
44  * vendor / preset table
45  */
46
47 struct hda_vendor_id {
48         unsigned int id;
49         const char *name;
50 };
51
52 /* codec vendor labels */
53 static struct hda_vendor_id hda_vendor_ids[] = {
54         { 0x1002, "ATI" },
55         { 0x1013, "Cirrus Logic" },
56         { 0x1057, "Motorola" },
57         { 0x1095, "Silicon Image" },
58         { 0x10de, "Nvidia" },
59         { 0x10ec, "Realtek" },
60         { 0x1102, "Creative" },
61         { 0x1106, "VIA" },
62         { 0x111d, "IDT" },
63         { 0x11c1, "LSI" },
64         { 0x11d4, "Analog Devices" },
65         { 0x13f6, "C-Media" },
66         { 0x14f1, "Conexant" },
67         { 0x17e8, "Chrontel" },
68         { 0x1854, "LG" },
69         { 0x1aec, "Wolfson Microelectronics" },
70         { 0x434d, "C-Media" },
71         { 0x8086, "Intel" },
72         { 0x8384, "SigmaTel" },
73         {} /* terminator */
74 };
75
76 static DEFINE_MUTEX(preset_mutex);
77 static LIST_HEAD(hda_preset_tables);
78
79 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
80 {
81         mutex_lock(&preset_mutex);
82         list_add_tail(&preset->list, &hda_preset_tables);
83         mutex_unlock(&preset_mutex);
84         return 0;
85 }
86 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
87
88 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
89 {
90         mutex_lock(&preset_mutex);
91         list_del(&preset->list);
92         mutex_unlock(&preset_mutex);
93         return 0;
94 }
95 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
96
97 #ifdef CONFIG_PM
98 #define codec_in_pm(codec)      ((codec)->in_pm)
99 static void hda_power_work(struct work_struct *work);
100 static void hda_keep_power_on(struct hda_codec *codec);
101 #define hda_codec_is_power_on(codec)    ((codec)->power_on)
102 static inline void hda_call_pm_notify(struct hda_bus *bus, bool power_up)
103 {
104         if (bus->ops.pm_notify)
105                 bus->ops.pm_notify(bus, power_up);
106 }
107 #else
108 #define codec_in_pm(codec)      0
109 static inline void hda_keep_power_on(struct hda_codec *codec) {}
110 #define hda_codec_is_power_on(codec)    1
111 #define hda_call_pm_notify(bus, state) {}
112 #endif
113
114 /**
115  * snd_hda_get_jack_location - Give a location string of the jack
116  * @cfg: pin default config value
117  *
118  * Parse the pin default config value and returns the string of the
119  * jack location, e.g. "Rear", "Front", etc.
120  */
121 const char *snd_hda_get_jack_location(u32 cfg)
122 {
123         static char *bases[7] = {
124                 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
125         };
126         static unsigned char specials_idx[] = {
127                 0x07, 0x08,
128                 0x17, 0x18, 0x19,
129                 0x37, 0x38
130         };
131         static char *specials[] = {
132                 "Rear Panel", "Drive Bar",
133                 "Riser", "HDMI", "ATAPI",
134                 "Mobile-In", "Mobile-Out"
135         };
136         int i;
137         cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
138         if ((cfg & 0x0f) < 7)
139                 return bases[cfg & 0x0f];
140         for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
141                 if (cfg == specials_idx[i])
142                         return specials[i];
143         }
144         return "UNKNOWN";
145 }
146 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
147
148 /**
149  * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
150  * @cfg: pin default config value
151  *
152  * Parse the pin default config value and returns the string of the
153  * jack connectivity, i.e. external or internal connection.
154  */
155 const char *snd_hda_get_jack_connectivity(u32 cfg)
156 {
157         static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
158
159         return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
160 }
161 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
162
163 /**
164  * snd_hda_get_jack_type - Give a type string of the jack
165  * @cfg: pin default config value
166  *
167  * Parse the pin default config value and returns the string of the
168  * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
169  */
170 const char *snd_hda_get_jack_type(u32 cfg)
171 {
172         static char *jack_types[16] = {
173                 "Line Out", "Speaker", "HP Out", "CD",
174                 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
175                 "Line In", "Aux", "Mic", "Telephony",
176                 "SPDIF In", "Digital In", "Reserved", "Other"
177         };
178
179         return jack_types[(cfg & AC_DEFCFG_DEVICE)
180                                 >> AC_DEFCFG_DEVICE_SHIFT];
181 }
182 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
183
184 /*
185  * Compose a 32bit command word to be sent to the HD-audio controller
186  */
187 static inline unsigned int
188 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
189                unsigned int verb, unsigned int parm)
190 {
191         u32 val;
192
193         if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
194             (verb & ~0xfff) || (parm & ~0xffff)) {
195                 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
196                        codec->addr, direct, nid, verb, parm);
197                 return ~0;
198         }
199
200         val = (u32)codec->addr << 28;
201         val |= (u32)direct << 27;
202         val |= (u32)nid << 20;
203         val |= verb << 8;
204         val |= parm;
205         return val;
206 }
207
208 /*
209  * Send and receive a verb
210  */
211 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
212                            unsigned int *res)
213 {
214         struct hda_bus *bus = codec->bus;
215         int err;
216
217         if (cmd == ~0)
218                 return -1;
219
220         if (res)
221                 *res = -1;
222  again:
223         snd_hda_power_up(codec);
224         mutex_lock(&bus->cmd_mutex);
225         for (;;) {
226                 trace_hda_send_cmd(codec, cmd);
227                 err = bus->ops.command(bus, cmd);
228                 if (err != -EAGAIN)
229                         break;
230                 /* process pending verbs */
231                 bus->ops.get_response(bus, codec->addr);
232         }
233         if (!err && res) {
234                 *res = bus->ops.get_response(bus, codec->addr);
235                 trace_hda_get_response(codec, *res);
236         }
237         mutex_unlock(&bus->cmd_mutex);
238         snd_hda_power_down(codec);
239         if (!codec_in_pm(codec) && res && *res == -1 && bus->rirb_error) {
240                 if (bus->response_reset) {
241                         snd_printd("hda_codec: resetting BUS due to "
242                                    "fatal communication error\n");
243                         trace_hda_bus_reset(bus);
244                         bus->ops.bus_reset(bus);
245                 }
246                 goto again;
247         }
248         /* clear reset-flag when the communication gets recovered */
249         if (!err || codec_in_pm(codec))
250                 bus->response_reset = 0;
251         return err;
252 }
253
254 /**
255  * snd_hda_codec_read - send a command and get the response
256  * @codec: the HDA codec
257  * @nid: NID to send the command
258  * @direct: direct flag
259  * @verb: the verb to send
260  * @parm: the parameter for the verb
261  *
262  * Send a single command and read the corresponding response.
263  *
264  * Returns the obtained response value, or -1 for an error.
265  */
266 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
267                                 int direct,
268                                 unsigned int verb, unsigned int parm)
269 {
270         unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
271         unsigned int res;
272         if (codec_exec_verb(codec, cmd, &res))
273                 return -1;
274         return res;
275 }
276 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
277
278 /**
279  * snd_hda_codec_write - send a single command without waiting for response
280  * @codec: the HDA codec
281  * @nid: NID to send the command
282  * @direct: direct flag
283  * @verb: the verb to send
284  * @parm: the parameter for the verb
285  *
286  * Send a single command without waiting for response.
287  *
288  * Returns 0 if successful, or a negative error code.
289  */
290 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
291                          unsigned int verb, unsigned int parm)
292 {
293         unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
294         unsigned int res;
295         return codec_exec_verb(codec, cmd,
296                                codec->bus->sync_write ? &res : NULL);
297 }
298 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
299
300 /**
301  * snd_hda_sequence_write - sequence writes
302  * @codec: the HDA codec
303  * @seq: VERB array to send
304  *
305  * Send the commands sequentially from the given array.
306  * The array must be terminated with NID=0.
307  */
308 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
309 {
310         for (; seq->nid; seq++)
311                 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
312 }
313 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
314
315 /**
316  * snd_hda_get_sub_nodes - get the range of sub nodes
317  * @codec: the HDA codec
318  * @nid: NID to parse
319  * @start_id: the pointer to store the start NID
320  *
321  * Parse the NID and store the start NID of its sub-nodes.
322  * Returns the number of sub-nodes.
323  */
324 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
325                           hda_nid_t *start_id)
326 {
327         unsigned int parm;
328
329         parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
330         if (parm == -1) {
331                 *start_id = 0;
332                 return 0;
333         }
334         *start_id = (parm >> 16) & 0x7fff;
335         return (int)(parm & 0x7fff);
336 }
337 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
338
339 /* connection list element */
340 struct hda_conn_list {
341         struct list_head list;
342         int len;
343         hda_nid_t nid;
344         hda_nid_t conns[0];
345 };
346
347 /* look up the cached results */
348 static struct hda_conn_list *
349 lookup_conn_list(struct hda_codec *codec, hda_nid_t nid)
350 {
351         struct hda_conn_list *p;
352         list_for_each_entry(p, &codec->conn_list, list) {
353                 if (p->nid == nid)
354                         return p;
355         }
356         return NULL;
357 }
358
359 static int add_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
360                          const hda_nid_t *list)
361 {
362         struct hda_conn_list *p;
363
364         p = kmalloc(sizeof(*p) + len * sizeof(hda_nid_t), GFP_KERNEL);
365         if (!p)
366                 return -ENOMEM;
367         p->len = len;
368         p->nid = nid;
369         memcpy(p->conns, list, len * sizeof(hda_nid_t));
370         list_add(&p->list, &codec->conn_list);
371         return 0;
372 }
373
374 static void remove_conn_list(struct hda_codec *codec)
375 {
376         while (!list_empty(&codec->conn_list)) {
377                 struct hda_conn_list *p;
378                 p = list_first_entry(&codec->conn_list, typeof(*p), list);
379                 list_del(&p->list);
380                 kfree(p);
381         }
382 }
383
384 /* read the connection and add to the cache */
385 static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
386 {
387         hda_nid_t list[32];
388         hda_nid_t *result = list;
389         int len;
390
391         len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
392         if (len == -ENOSPC) {
393                 len = snd_hda_get_num_raw_conns(codec, nid);
394                 result = kmalloc(sizeof(hda_nid_t) * len, GFP_KERNEL);
395                 if (!result)
396                         return -ENOMEM;
397                 len = snd_hda_get_raw_connections(codec, nid, result, len);
398         }
399         if (len >= 0)
400                 len = snd_hda_override_conn_list(codec, nid, len, result);
401         if (result != list)
402                 kfree(result);
403         return len;
404 }
405
406 /**
407  * snd_hda_get_conn_list - get connection list
408  * @codec: the HDA codec
409  * @nid: NID to parse
410  * @len: number of connection list entries
411  * @listp: the pointer to store NID list
412  *
413  * Parses the connection list of the given widget and stores the pointer
414  * to the list of NIDs.
415  *
416  * Returns the number of connections, or a negative error code.
417  *
418  * Note that the returned pointer isn't protected against the list
419  * modification.  If snd_hda_override_conn_list() might be called
420  * concurrently, protect with a mutex appropriately.
421  */
422 int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
423                           const hda_nid_t **listp)
424 {
425         bool added = false;
426
427         for (;;) {
428                 int err;
429                 const struct hda_conn_list *p;
430
431                 /* if the connection-list is already cached, read it */
432                 p = lookup_conn_list(codec, nid);
433                 if (p) {
434                         if (listp)
435                                 *listp = p->conns;
436                         return p->len;
437                 }
438                 if (snd_BUG_ON(added))
439                         return -EINVAL;
440
441                 err = read_and_add_raw_conns(codec, nid);
442                 if (err < 0)
443                         return err;
444                 added = true;
445         }
446 }
447 EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
448
449 /**
450  * snd_hda_get_connections - copy connection list
451  * @codec: the HDA codec
452  * @nid: NID to parse
453  * @conn_list: connection list array; when NULL, checks only the size
454  * @max_conns: max. number of connections to store
455  *
456  * Parses the connection list of the given widget and stores the list
457  * of NIDs.
458  *
459  * Returns the number of connections, or a negative error code.
460  */
461 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
462                             hda_nid_t *conn_list, int max_conns)
463 {
464         const hda_nid_t *list;
465         int len = snd_hda_get_conn_list(codec, nid, &list);
466
467         if (len > 0 && conn_list) {
468                 if (len > max_conns) {
469                         snd_printk(KERN_ERR "hda_codec: "
470                                    "Too many connections %d for NID 0x%x\n",
471                                    len, nid);
472                         return -EINVAL;
473                 }
474                 memcpy(conn_list, list, len * sizeof(hda_nid_t));
475         }
476
477         return len;
478 }
479 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
480
481 /* return CONNLIST_LEN parameter of the given widget */
482 static unsigned int get_num_conns(struct hda_codec *codec, hda_nid_t nid)
483 {
484         unsigned int wcaps = get_wcaps(codec, nid);
485         unsigned int parm;
486
487         if (!(wcaps & AC_WCAP_CONN_LIST) &&
488             get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
489                 return 0;
490
491         parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
492         if (parm == -1)
493                 parm = 0;
494         return parm;
495 }
496
497 int snd_hda_get_num_raw_conns(struct hda_codec *codec, hda_nid_t nid)
498 {
499         return snd_hda_get_raw_connections(codec, nid, NULL, 0);
500 }
501
502 /**
503  * snd_hda_get_raw_connections - copy connection list without cache
504  * @codec: the HDA codec
505  * @nid: NID to parse
506  * @conn_list: connection list array
507  * @max_conns: max. number of connections to store
508  *
509  * Like snd_hda_get_connections(), copy the connection list but without
510  * checking through the connection-list cache.
511  * Currently called only from hda_proc.c, so not exported.
512  */
513 int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
514                                 hda_nid_t *conn_list, int max_conns)
515 {
516         unsigned int parm;
517         int i, conn_len, conns;
518         unsigned int shift, num_elems, mask;
519         hda_nid_t prev_nid;
520         int null_count = 0;
521
522         parm = get_num_conns(codec, nid);
523         if (!parm)
524                 return 0;
525
526         if (parm & AC_CLIST_LONG) {
527                 /* long form */
528                 shift = 16;
529                 num_elems = 2;
530         } else {
531                 /* short form */
532                 shift = 8;
533                 num_elems = 4;
534         }
535         conn_len = parm & AC_CLIST_LENGTH;
536         mask = (1 << (shift-1)) - 1;
537
538         if (!conn_len)
539                 return 0; /* no connection */
540
541         if (conn_len == 1) {
542                 /* single connection */
543                 parm = snd_hda_codec_read(codec, nid, 0,
544                                           AC_VERB_GET_CONNECT_LIST, 0);
545                 if (parm == -1 && codec->bus->rirb_error)
546                         return -EIO;
547                 if (conn_list)
548                         conn_list[0] = parm & mask;
549                 return 1;
550         }
551
552         /* multi connection */
553         conns = 0;
554         prev_nid = 0;
555         for (i = 0; i < conn_len; i++) {
556                 int range_val;
557                 hda_nid_t val, n;
558
559                 if (i % num_elems == 0) {
560                         parm = snd_hda_codec_read(codec, nid, 0,
561                                                   AC_VERB_GET_CONNECT_LIST, i);
562                         if (parm == -1 && codec->bus->rirb_error)
563                                 return -EIO;
564                 }
565                 range_val = !!(parm & (1 << (shift-1))); /* ranges */
566                 val = parm & mask;
567                 if (val == 0 && null_count++) {  /* no second chance */
568                         snd_printk(KERN_WARNING "hda_codec: "
569                                    "invalid CONNECT_LIST verb %x[%i]:%x\n",
570                                     nid, i, parm);
571                         return 0;
572                 }
573                 parm >>= shift;
574                 if (range_val) {
575                         /* ranges between the previous and this one */
576                         if (!prev_nid || prev_nid >= val) {
577                                 snd_printk(KERN_WARNING "hda_codec: "
578                                            "invalid dep_range_val %x:%x\n",
579                                            prev_nid, val);
580                                 continue;
581                         }
582                         for (n = prev_nid + 1; n <= val; n++) {
583                                 if (conn_list) {
584                                         if (conns >= max_conns)
585                                                 return -ENOSPC;
586                                         conn_list[conns] = n;
587                                 }
588                                 conns++;
589                         }
590                 } else {
591                         if (conn_list) {
592                                 if (conns >= max_conns)
593                                         return -ENOSPC;
594                                 conn_list[conns] = val;
595                         }
596                         conns++;
597                 }
598                 prev_nid = val;
599         }
600         return conns;
601 }
602
603 /**
604  * snd_hda_override_conn_list - add/modify the connection-list to cache
605  * @codec: the HDA codec
606  * @nid: NID to parse
607  * @len: number of connection list entries
608  * @list: the list of connection entries
609  *
610  * Add or modify the given connection-list to the cache.  If the corresponding
611  * cache already exists, invalidate it and append a new one.
612  *
613  * Returns zero or a negative error code.
614  */
615 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
616                                const hda_nid_t *list)
617 {
618         struct hda_conn_list *p;
619
620         p = lookup_conn_list(codec, nid);
621         if (p) {
622                 list_del(&p->list);
623                 kfree(p);
624         }
625
626         return add_conn_list(codec, nid, len, list);
627 }
628 EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
629
630 /**
631  * snd_hda_get_conn_index - get the connection index of the given NID
632  * @codec: the HDA codec
633  * @mux: NID containing the list
634  * @nid: NID to select
635  * @recursive: 1 when searching NID recursively, otherwise 0
636  *
637  * Parses the connection list of the widget @mux and checks whether the
638  * widget @nid is present.  If it is, return the connection index.
639  * Otherwise it returns -1.
640  */
641 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
642                            hda_nid_t nid, int recursive)
643 {
644         const hda_nid_t *conn;
645         int i, nums;
646
647         nums = snd_hda_get_conn_list(codec, mux, &conn);
648         for (i = 0; i < nums; i++)
649                 if (conn[i] == nid)
650                         return i;
651         if (!recursive)
652                 return -1;
653         if (recursive > 10) {
654                 snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
655                 return -1;
656         }
657         recursive++;
658         for (i = 0; i < nums; i++) {
659                 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
660                 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
661                         continue;
662                 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
663                         return i;
664         }
665         return -1;
666 }
667 EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
668
669 /**
670  * snd_hda_queue_unsol_event - add an unsolicited event to queue
671  * @bus: the BUS
672  * @res: unsolicited event (lower 32bit of RIRB entry)
673  * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
674  *
675  * Adds the given event to the queue.  The events are processed in
676  * the workqueue asynchronously.  Call this function in the interrupt
677  * hanlder when RIRB receives an unsolicited event.
678  *
679  * Returns 0 if successful, or a negative error code.
680  */
681 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
682 {
683         struct hda_bus_unsolicited *unsol;
684         unsigned int wp;
685
686         if (!bus || !bus->workq)
687                 return 0;
688
689         trace_hda_unsol_event(bus, res, res_ex);
690         unsol = bus->unsol;
691         if (!unsol)
692                 return 0;
693
694         wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
695         unsol->wp = wp;
696
697         wp <<= 1;
698         unsol->queue[wp] = res;
699         unsol->queue[wp + 1] = res_ex;
700
701         queue_work(bus->workq, &unsol->work);
702
703         return 0;
704 }
705 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
706
707 /*
708  * process queued unsolicited events
709  */
710 static void process_unsol_events(struct work_struct *work)
711 {
712         struct hda_bus_unsolicited *unsol =
713                 container_of(work, struct hda_bus_unsolicited, work);
714         struct hda_bus *bus = unsol->bus;
715         struct hda_codec *codec;
716         unsigned int rp, caddr, res;
717
718         while (unsol->rp != unsol->wp) {
719                 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
720                 unsol->rp = rp;
721                 rp <<= 1;
722                 res = unsol->queue[rp];
723                 caddr = unsol->queue[rp + 1];
724                 if (!(caddr & (1 << 4))) /* no unsolicited event? */
725                         continue;
726                 codec = bus->caddr_tbl[caddr & 0x0f];
727                 if (codec && codec->patch_ops.unsol_event)
728                         codec->patch_ops.unsol_event(codec, res);
729         }
730 }
731
732 /*
733  * initialize unsolicited queue
734  */
735 static int init_unsol_queue(struct hda_bus *bus)
736 {
737         struct hda_bus_unsolicited *unsol;
738
739         if (bus->unsol) /* already initialized */
740                 return 0;
741
742         unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
743         if (!unsol) {
744                 snd_printk(KERN_ERR "hda_codec: "
745                            "can't allocate unsolicited queue\n");
746                 return -ENOMEM;
747         }
748         INIT_WORK(&unsol->work, process_unsol_events);
749         unsol->bus = bus;
750         bus->unsol = unsol;
751         return 0;
752 }
753
754 /*
755  * destructor
756  */
757 static void snd_hda_codec_free(struct hda_codec *codec);
758
759 static int snd_hda_bus_free(struct hda_bus *bus)
760 {
761         struct hda_codec *codec, *n;
762
763         if (!bus)
764                 return 0;
765         if (bus->workq)
766                 flush_workqueue(bus->workq);
767         if (bus->unsol)
768                 kfree(bus->unsol);
769         list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
770                 snd_hda_codec_free(codec);
771         }
772         if (bus->ops.private_free)
773                 bus->ops.private_free(bus);
774         if (bus->workq)
775                 destroy_workqueue(bus->workq);
776         kfree(bus);
777         return 0;
778 }
779
780 static int snd_hda_bus_dev_free(struct snd_device *device)
781 {
782         struct hda_bus *bus = device->device_data;
783         bus->shutdown = 1;
784         return snd_hda_bus_free(bus);
785 }
786
787 #ifdef CONFIG_SND_HDA_HWDEP
788 static int snd_hda_bus_dev_register(struct snd_device *device)
789 {
790         struct hda_bus *bus = device->device_data;
791         struct hda_codec *codec;
792         list_for_each_entry(codec, &bus->codec_list, list) {
793                 snd_hda_hwdep_add_sysfs(codec);
794                 snd_hda_hwdep_add_power_sysfs(codec);
795         }
796         return 0;
797 }
798 #else
799 #define snd_hda_bus_dev_register        NULL
800 #endif
801
802 /**
803  * snd_hda_bus_new - create a HDA bus
804  * @card: the card entry
805  * @temp: the template for hda_bus information
806  * @busp: the pointer to store the created bus instance
807  *
808  * Returns 0 if successful, or a negative error code.
809  */
810 int snd_hda_bus_new(struct snd_card *card,
811                               const struct hda_bus_template *temp,
812                               struct hda_bus **busp)
813 {
814         struct hda_bus *bus;
815         int err;
816         static struct snd_device_ops dev_ops = {
817                 .dev_register = snd_hda_bus_dev_register,
818                 .dev_free = snd_hda_bus_dev_free,
819         };
820
821         if (snd_BUG_ON(!temp))
822                 return -EINVAL;
823         if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
824                 return -EINVAL;
825
826         if (busp)
827                 *busp = NULL;
828
829         bus = kzalloc(sizeof(*bus), GFP_KERNEL);
830         if (bus == NULL) {
831                 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
832                 return -ENOMEM;
833         }
834
835         bus->card = card;
836         bus->private_data = temp->private_data;
837         bus->pci = temp->pci;
838         bus->modelname = temp->modelname;
839         bus->power_save = temp->power_save;
840         bus->ops = temp->ops;
841
842         mutex_init(&bus->cmd_mutex);
843         mutex_init(&bus->prepare_mutex);
844         INIT_LIST_HEAD(&bus->codec_list);
845
846         snprintf(bus->workq_name, sizeof(bus->workq_name),
847                  "hd-audio%d", card->number);
848         bus->workq = create_freezable_workqueue(bus->workq_name);
849         if (!bus->workq) {
850                 snd_printk(KERN_ERR "cannot create workqueue %s\n",
851                            bus->workq_name);
852                 kfree(bus);
853                 return -ENOMEM;
854         }
855
856         err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
857         if (err < 0) {
858                 snd_hda_bus_free(bus);
859                 return err;
860         }
861         if (busp)
862                 *busp = bus;
863         return 0;
864 }
865 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
866
867 #ifdef CONFIG_SND_HDA_GENERIC
868 #define is_generic_config(codec) \
869         (codec->modelname && !strcmp(codec->modelname, "generic"))
870 #else
871 #define is_generic_config(codec)        0
872 #endif
873
874 #ifdef MODULE
875 #define HDA_MODREQ_MAX_COUNT    2       /* two request_modules()'s */
876 #else
877 #define HDA_MODREQ_MAX_COUNT    0       /* all presets are statically linked */
878 #endif
879
880 /*
881  * find a matching codec preset
882  */
883 static const struct hda_codec_preset *
884 find_codec_preset(struct hda_codec *codec)
885 {
886         struct hda_codec_preset_list *tbl;
887         const struct hda_codec_preset *preset;
888         unsigned int mod_requested = 0;
889
890         if (is_generic_config(codec))
891                 return NULL; /* use the generic parser */
892
893  again:
894         mutex_lock(&preset_mutex);
895         list_for_each_entry(tbl, &hda_preset_tables, list) {
896                 if (!try_module_get(tbl->owner)) {
897                         snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
898                         continue;
899                 }
900                 for (preset = tbl->preset; preset->id; preset++) {
901                         u32 mask = preset->mask;
902                         if (preset->afg && preset->afg != codec->afg)
903                                 continue;
904                         if (preset->mfg && preset->mfg != codec->mfg)
905                                 continue;
906                         if (!mask)
907                                 mask = ~0;
908                         if (preset->id == (codec->vendor_id & mask) &&
909                             (!preset->rev ||
910                              preset->rev == codec->revision_id)) {
911                                 mutex_unlock(&preset_mutex);
912                                 codec->owner = tbl->owner;
913                                 return preset;
914                         }
915                 }
916                 module_put(tbl->owner);
917         }
918         mutex_unlock(&preset_mutex);
919
920         if (mod_requested < HDA_MODREQ_MAX_COUNT) {
921                 char name[32];
922                 if (!mod_requested)
923                         snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
924                                  codec->vendor_id);
925                 else
926                         snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
927                                  (codec->vendor_id >> 16) & 0xffff);
928                 request_module(name);
929                 mod_requested++;
930                 goto again;
931         }
932         return NULL;
933 }
934
935 /*
936  * get_codec_name - store the codec name
937  */
938 static int get_codec_name(struct hda_codec *codec)
939 {
940         const struct hda_vendor_id *c;
941         const char *vendor = NULL;
942         u16 vendor_id = codec->vendor_id >> 16;
943         char tmp[16];
944
945         if (codec->vendor_name)
946                 goto get_chip_name;
947
948         for (c = hda_vendor_ids; c->id; c++) {
949                 if (c->id == vendor_id) {
950                         vendor = c->name;
951                         break;
952                 }
953         }
954         if (!vendor) {
955                 sprintf(tmp, "Generic %04x", vendor_id);
956                 vendor = tmp;
957         }
958         codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
959         if (!codec->vendor_name)
960                 return -ENOMEM;
961
962  get_chip_name:
963         if (codec->chip_name)
964                 return 0;
965
966         if (codec->preset && codec->preset->name)
967                 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
968         else {
969                 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
970                 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
971         }
972         if (!codec->chip_name)
973                 return -ENOMEM;
974         return 0;
975 }
976
977 /*
978  * look for an AFG and MFG nodes
979  */
980 static void setup_fg_nodes(struct hda_codec *codec)
981 {
982         int i, total_nodes, function_id;
983         hda_nid_t nid;
984
985         total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
986         for (i = 0; i < total_nodes; i++, nid++) {
987                 function_id = snd_hda_param_read(codec, nid,
988                                                 AC_PAR_FUNCTION_TYPE);
989                 switch (function_id & 0xff) {
990                 case AC_GRP_AUDIO_FUNCTION:
991                         codec->afg = nid;
992                         codec->afg_function_id = function_id & 0xff;
993                         codec->afg_unsol = (function_id >> 8) & 1;
994                         break;
995                 case AC_GRP_MODEM_FUNCTION:
996                         codec->mfg = nid;
997                         codec->mfg_function_id = function_id & 0xff;
998                         codec->mfg_unsol = (function_id >> 8) & 1;
999                         break;
1000                 default:
1001                         break;
1002                 }
1003         }
1004 }
1005
1006 /*
1007  * read widget caps for each widget and store in cache
1008  */
1009 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
1010 {
1011         int i;
1012         hda_nid_t nid;
1013
1014         codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
1015                                                  &codec->start_nid);
1016         codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
1017         if (!codec->wcaps)
1018                 return -ENOMEM;
1019         nid = codec->start_nid;
1020         for (i = 0; i < codec->num_nodes; i++, nid++)
1021                 codec->wcaps[i] = snd_hda_param_read(codec, nid,
1022                                                      AC_PAR_AUDIO_WIDGET_CAP);
1023         return 0;
1024 }
1025
1026 /* read all pin default configurations and save codec->init_pins */
1027 static int read_pin_defaults(struct hda_codec *codec)
1028 {
1029         int i;
1030         hda_nid_t nid = codec->start_nid;
1031
1032         for (i = 0; i < codec->num_nodes; i++, nid++) {
1033                 struct hda_pincfg *pin;
1034                 unsigned int wcaps = get_wcaps(codec, nid);
1035                 unsigned int wid_type = get_wcaps_type(wcaps);
1036                 if (wid_type != AC_WID_PIN)
1037                         continue;
1038                 pin = snd_array_new(&codec->init_pins);
1039                 if (!pin)
1040                         return -ENOMEM;
1041                 pin->nid = nid;
1042                 pin->cfg = snd_hda_codec_read(codec, nid, 0,
1043                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
1044                 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
1045                                                AC_VERB_GET_PIN_WIDGET_CONTROL,
1046                                                0);
1047         }
1048         return 0;
1049 }
1050
1051 /* look up the given pin config list and return the item matching with NID */
1052 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
1053                                          struct snd_array *array,
1054                                          hda_nid_t nid)
1055 {
1056         int i;
1057         for (i = 0; i < array->used; i++) {
1058                 struct hda_pincfg *pin = snd_array_elem(array, i);
1059                 if (pin->nid == nid)
1060                         return pin;
1061         }
1062         return NULL;
1063 }
1064
1065 /* set the current pin config value for the given NID.
1066  * the value is cached, and read via snd_hda_codec_get_pincfg()
1067  */
1068 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1069                        hda_nid_t nid, unsigned int cfg)
1070 {
1071         struct hda_pincfg *pin;
1072
1073         /* the check below may be invalid when pins are added by a fixup
1074          * dynamically (e.g. via snd_hda_codec_update_widgets()), so disabled
1075          * for now
1076          */
1077         /*
1078         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1079                 return -EINVAL;
1080         */
1081
1082         pin = look_up_pincfg(codec, list, nid);
1083         if (!pin) {
1084                 pin = snd_array_new(list);
1085                 if (!pin)
1086                         return -ENOMEM;
1087                 pin->nid = nid;
1088         }
1089         pin->cfg = cfg;
1090         return 0;
1091 }
1092
1093 /**
1094  * snd_hda_codec_set_pincfg - Override a pin default configuration
1095  * @codec: the HDA codec
1096  * @nid: NID to set the pin config
1097  * @cfg: the pin default config value
1098  *
1099  * Override a pin default configuration value in the cache.
1100  * This value can be read by snd_hda_codec_get_pincfg() in a higher
1101  * priority than the real hardware value.
1102  */
1103 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1104                              hda_nid_t nid, unsigned int cfg)
1105 {
1106         return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
1107 }
1108 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
1109
1110 /**
1111  * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1112  * @codec: the HDA codec
1113  * @nid: NID to get the pin config
1114  *
1115  * Get the current pin config value of the given pin NID.
1116  * If the pincfg value is cached or overridden via sysfs or driver,
1117  * returns the cached value.
1118  */
1119 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1120 {
1121         struct hda_pincfg *pin;
1122
1123 #ifdef CONFIG_SND_HDA_HWDEP
1124         {
1125                 unsigned int cfg = 0;
1126                 mutex_lock(&codec->user_mutex);
1127                 pin = look_up_pincfg(codec, &codec->user_pins, nid);
1128                 if (pin)
1129                         cfg = pin->cfg;
1130                 mutex_unlock(&codec->user_mutex);
1131                 if (cfg)
1132                         return cfg;
1133         }
1134 #endif
1135         pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1136         if (pin)
1137                 return pin->cfg;
1138         pin = look_up_pincfg(codec, &codec->init_pins, nid);
1139         if (pin)
1140                 return pin->cfg;
1141         return 0;
1142 }
1143 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
1144
1145 /* remember the current pinctl target value */
1146 int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
1147                                  unsigned int val)
1148 {
1149         struct hda_pincfg *pin;
1150
1151         pin = look_up_pincfg(codec, &codec->init_pins, nid);
1152         if (!pin)
1153                 return -EINVAL;
1154         pin->target = val;
1155         return 0;
1156 }
1157 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pin_target);
1158
1159 /* return the current pinctl target value */
1160 int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
1161 {
1162         struct hda_pincfg *pin;
1163
1164         pin = look_up_pincfg(codec, &codec->init_pins, nid);
1165         if (!pin)
1166                 return 0;
1167         return pin->target;
1168 }
1169 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pin_target);
1170
1171 /**
1172  * snd_hda_shutup_pins - Shut up all pins
1173  * @codec: the HDA codec
1174  *
1175  * Clear all pin controls to shup up before suspend for avoiding click noise.
1176  * The controls aren't cached so that they can be resumed properly.
1177  */
1178 void snd_hda_shutup_pins(struct hda_codec *codec)
1179 {
1180         int i;
1181         /* don't shut up pins when unloading the driver; otherwise it breaks
1182          * the default pin setup at the next load of the driver
1183          */
1184         if (codec->bus->shutdown)
1185                 return;
1186         for (i = 0; i < codec->init_pins.used; i++) {
1187                 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1188                 /* use read here for syncing after issuing each verb */
1189                 snd_hda_codec_read(codec, pin->nid, 0,
1190                                    AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1191         }
1192         codec->pins_shutup = 1;
1193 }
1194 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
1195
1196 #ifdef CONFIG_PM
1197 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1198 static void restore_shutup_pins(struct hda_codec *codec)
1199 {
1200         int i;
1201         if (!codec->pins_shutup)
1202                 return;
1203         if (codec->bus->shutdown)
1204                 return;
1205         for (i = 0; i < codec->init_pins.used; i++) {
1206                 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1207                 snd_hda_codec_write(codec, pin->nid, 0,
1208                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1209                                     pin->ctrl);
1210         }
1211         codec->pins_shutup = 0;
1212 }
1213 #endif
1214
1215 static void hda_jackpoll_work(struct work_struct *work)
1216 {
1217         struct hda_codec *codec =
1218                 container_of(work, struct hda_codec, jackpoll_work.work);
1219         if (!codec->jackpoll_interval)
1220                 return;
1221
1222         snd_hda_jack_set_dirty_all(codec);
1223         snd_hda_jack_poll_all(codec);
1224         queue_delayed_work(codec->bus->workq, &codec->jackpoll_work,
1225                            codec->jackpoll_interval);
1226 }
1227
1228 static void init_hda_cache(struct hda_cache_rec *cache,
1229                            unsigned int record_size);
1230 static void free_hda_cache(struct hda_cache_rec *cache);
1231
1232 /* release all pincfg lists */
1233 static void free_init_pincfgs(struct hda_codec *codec)
1234 {
1235         snd_array_free(&codec->driver_pins);
1236 #ifdef CONFIG_SND_HDA_HWDEP
1237         snd_array_free(&codec->user_pins);
1238 #endif
1239         snd_array_free(&codec->init_pins);
1240 }
1241
1242 /*
1243  * audio-converter setup caches
1244  */
1245 struct hda_cvt_setup {
1246         hda_nid_t nid;
1247         u8 stream_tag;
1248         u8 channel_id;
1249         u16 format_id;
1250         unsigned char active;   /* cvt is currently used */
1251         unsigned char dirty;    /* setups should be cleared */
1252 };
1253
1254 /* get or create a cache entry for the given audio converter NID */
1255 static struct hda_cvt_setup *
1256 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1257 {
1258         struct hda_cvt_setup *p;
1259         int i;
1260
1261         for (i = 0; i < codec->cvt_setups.used; i++) {
1262                 p = snd_array_elem(&codec->cvt_setups, i);
1263                 if (p->nid == nid)
1264                         return p;
1265         }
1266         p = snd_array_new(&codec->cvt_setups);
1267         if (p)
1268                 p->nid = nid;
1269         return p;
1270 }
1271
1272 /*
1273  * codec destructor
1274  */
1275 static void snd_hda_codec_free(struct hda_codec *codec)
1276 {
1277         if (!codec)
1278                 return;
1279         cancel_delayed_work_sync(&codec->jackpoll_work);
1280         snd_hda_jack_tbl_clear(codec);
1281         free_init_pincfgs(codec);
1282 #ifdef CONFIG_PM
1283         cancel_delayed_work(&codec->power_work);
1284         flush_workqueue(codec->bus->workq);
1285 #endif
1286         list_del(&codec->list);
1287         snd_array_free(&codec->mixers);
1288         snd_array_free(&codec->nids);
1289         snd_array_free(&codec->cvt_setups);
1290         snd_array_free(&codec->spdif_out);
1291         remove_conn_list(codec);
1292         codec->bus->caddr_tbl[codec->addr] = NULL;
1293         if (codec->patch_ops.free)
1294                 codec->patch_ops.free(codec);
1295 #ifdef CONFIG_PM
1296         if (!codec->pm_down_notified) /* cancel leftover refcounts */
1297                 hda_call_pm_notify(codec->bus, false);
1298 #endif
1299         module_put(codec->owner);
1300         free_hda_cache(&codec->amp_cache);
1301         free_hda_cache(&codec->cmd_cache);
1302         kfree(codec->vendor_name);
1303         kfree(codec->chip_name);
1304         kfree(codec->modelname);
1305         kfree(codec->wcaps);
1306         kfree(codec);
1307 }
1308
1309 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec,
1310                                 hda_nid_t fg, unsigned int power_state);
1311
1312 static unsigned int hda_set_power_state(struct hda_codec *codec,
1313                                 unsigned int power_state);
1314
1315 /**
1316  * snd_hda_codec_new - create a HDA codec
1317  * @bus: the bus to assign
1318  * @codec_addr: the codec address
1319  * @codecp: the pointer to store the generated codec
1320  *
1321  * Returns 0 if successful, or a negative error code.
1322  */
1323 int snd_hda_codec_new(struct hda_bus *bus,
1324                                 unsigned int codec_addr,
1325                                 struct hda_codec **codecp)
1326 {
1327         struct hda_codec *codec;
1328         char component[31];
1329         hda_nid_t fg;
1330         int err;
1331
1332         if (snd_BUG_ON(!bus))
1333                 return -EINVAL;
1334         if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1335                 return -EINVAL;
1336
1337         if (bus->caddr_tbl[codec_addr]) {
1338                 snd_printk(KERN_ERR "hda_codec: "
1339                            "address 0x%x is already occupied\n", codec_addr);
1340                 return -EBUSY;
1341         }
1342
1343         codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1344         if (codec == NULL) {
1345                 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1346                 return -ENOMEM;
1347         }
1348
1349         codec->bus = bus;
1350         codec->addr = codec_addr;
1351         mutex_init(&codec->spdif_mutex);
1352         mutex_init(&codec->control_mutex);
1353         mutex_init(&codec->hash_mutex);
1354         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1355         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1356         snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1357         snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1358         snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1359         snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1360         snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1361         snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1362         snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
1363         snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
1364         INIT_LIST_HEAD(&codec->conn_list);
1365
1366         INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
1367
1368 #ifdef CONFIG_PM
1369         spin_lock_init(&codec->power_lock);
1370         INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1371         /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1372          * the caller has to power down appropriatley after initialization
1373          * phase.
1374          */
1375         hda_keep_power_on(codec);
1376         hda_call_pm_notify(bus, true);
1377 #endif
1378
1379         if (codec->bus->modelname) {
1380                 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1381                 if (!codec->modelname) {
1382                         snd_hda_codec_free(codec);
1383                         return -ENODEV;
1384                 }
1385         }
1386
1387         list_add_tail(&codec->list, &bus->codec_list);
1388         bus->caddr_tbl[codec_addr] = codec;
1389
1390         codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1391                                               AC_PAR_VENDOR_ID);
1392         if (codec->vendor_id == -1)
1393                 /* read again, hopefully the access method was corrected
1394                  * in the last read...
1395                  */
1396                 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1397                                                       AC_PAR_VENDOR_ID);
1398         codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1399                                                  AC_PAR_SUBSYSTEM_ID);
1400         codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1401                                                 AC_PAR_REV_ID);
1402
1403         setup_fg_nodes(codec);
1404         if (!codec->afg && !codec->mfg) {
1405                 snd_printdd("hda_codec: no AFG or MFG node found\n");
1406                 err = -ENODEV;
1407                 goto error;
1408         }
1409
1410         fg = codec->afg ? codec->afg : codec->mfg;
1411         err = read_widget_caps(codec, fg);
1412         if (err < 0) {
1413                 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1414                 goto error;
1415         }
1416         err = read_pin_defaults(codec);
1417         if (err < 0)
1418                 goto error;
1419
1420         if (!codec->subsystem_id) {
1421                 codec->subsystem_id =
1422                         snd_hda_codec_read(codec, fg, 0,
1423                                            AC_VERB_GET_SUBSYSTEM_ID, 0);
1424         }
1425
1426 #ifdef CONFIG_PM
1427         codec->d3_stop_clk = snd_hda_codec_get_supported_ps(codec, fg,
1428                                         AC_PWRST_CLKSTOP);
1429 #ifndef CONFIG_SND_HDA_PLATFORM_NVIDIA_TEGRA
1430         if (!codec->d3_stop_clk)
1431                 bus->power_keep_link_on = 1;
1432 #endif
1433 #endif
1434         codec->epss = snd_hda_codec_get_supported_ps(codec, fg,
1435                                         AC_PWRST_EPSS);
1436
1437         /* power-up all before initialization */
1438         hda_set_power_state(codec, AC_PWRST_D0);
1439
1440         snd_hda_codec_proc_new(codec);
1441
1442         snd_hda_create_hwdep(codec);
1443
1444         sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1445                 codec->subsystem_id, codec->revision_id);
1446         snd_component_add(codec->bus->card, component);
1447
1448         if (codecp)
1449                 *codecp = codec;
1450         return 0;
1451
1452  error:
1453         snd_hda_codec_free(codec);
1454         return err;
1455 }
1456 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1457
1458 int snd_hda_codec_update_widgets(struct hda_codec *codec)
1459 {
1460         hda_nid_t fg;
1461         int err;
1462
1463         /* Assume the function group node does not change,
1464          * only the widget nodes may change.
1465          */
1466         kfree(codec->wcaps);
1467         fg = codec->afg ? codec->afg : codec->mfg;
1468         err = read_widget_caps(codec, fg);
1469         if (err < 0) {
1470                 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1471                 return err;
1472         }
1473
1474         snd_array_free(&codec->init_pins);
1475         err = read_pin_defaults(codec);
1476
1477         return err;
1478 }
1479 EXPORT_SYMBOL_HDA(snd_hda_codec_update_widgets);
1480
1481
1482 /**
1483  * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1484  * @codec: the HDA codec
1485  *
1486  * Start parsing of the given codec tree and (re-)initialize the whole
1487  * patch instance.
1488  *
1489  * Returns 0 if successful or a negative error code.
1490  */
1491 int snd_hda_codec_configure(struct hda_codec *codec)
1492 {
1493         int err;
1494
1495         codec->preset = find_codec_preset(codec);
1496         if (!codec->vendor_name || !codec->chip_name) {
1497                 err = get_codec_name(codec);
1498                 if (err < 0)
1499                         return err;
1500         }
1501
1502         if (is_generic_config(codec)) {
1503                 err = snd_hda_parse_generic_codec(codec);
1504                 goto patched;
1505         }
1506         if (codec->preset && codec->preset->patch) {
1507                 err = codec->preset->patch(codec);
1508                 goto patched;
1509         }
1510
1511         /* call the default parser */
1512         err = snd_hda_parse_generic_codec(codec);
1513         if (err < 0)
1514                 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1515
1516  patched:
1517         if (!err && codec->patch_ops.unsol_event)
1518                 err = init_unsol_queue(codec->bus);
1519         /* audio codec should override the mixer name */
1520         if (!err && (codec->afg || !*codec->bus->card->mixername))
1521                 snprintf(codec->bus->card->mixername,
1522                          sizeof(codec->bus->card->mixername),
1523                          "%s %s", codec->vendor_name, codec->chip_name);
1524         return err;
1525 }
1526 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1527
1528 /* update the stream-id if changed */
1529 static void update_pcm_stream_id(struct hda_codec *codec,
1530                                  struct hda_cvt_setup *p, hda_nid_t nid,
1531                                  u32 stream_tag, int channel_id)
1532 {
1533         unsigned int oldval, newval;
1534
1535         if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1536                 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1537                 newval = (stream_tag << 4) | channel_id;
1538                 if (oldval != newval)
1539                         snd_hda_codec_write(codec, nid, 0,
1540                                             AC_VERB_SET_CHANNEL_STREAMID,
1541                                             newval);
1542                 p->stream_tag = stream_tag;
1543                 p->channel_id = channel_id;
1544         }
1545 }
1546
1547 /* update the format-id if changed */
1548 static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1549                               hda_nid_t nid, int format)
1550 {
1551         unsigned int oldval;
1552
1553         if (p->format_id != format) {
1554                 oldval = snd_hda_codec_read(codec, nid, 0,
1555                                             AC_VERB_GET_STREAM_FORMAT, 0);
1556                 if (oldval != format) {
1557                         msleep(1);
1558                         snd_hda_codec_write(codec, nid, 0,
1559                                             AC_VERB_SET_STREAM_FORMAT,
1560                                             format);
1561                 }
1562                 p->format_id = format;
1563         }
1564 }
1565
1566 /**
1567  * snd_hda_codec_setup_stream - set up the codec for streaming
1568  * @codec: the CODEC to set up
1569  * @nid: the NID to set up
1570  * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1571  * @channel_id: channel id to pass, zero based.
1572  * @format: stream format.
1573  */
1574 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1575                                 u32 stream_tag,
1576                                 int channel_id, int format)
1577 {
1578         struct hda_codec *c;
1579         struct hda_cvt_setup *p;
1580         int type;
1581         int i;
1582
1583         if (!nid)
1584                 return;
1585
1586         snd_printdd("hda_codec_setup_stream: "
1587                     "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1588                     nid, stream_tag, channel_id, format);
1589         p = get_hda_cvt_setup(codec, nid);
1590         if (!p)
1591                 return;
1592
1593         if (codec->pcm_format_first)
1594                 update_pcm_format(codec, p, nid, format);
1595         update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1596         if (!codec->pcm_format_first)
1597                 update_pcm_format(codec, p, nid, format);
1598
1599         p->active = 1;
1600         p->dirty = 0;
1601
1602         /* make other inactive cvts with the same stream-tag dirty */
1603         type = get_wcaps_type(get_wcaps(codec, nid));
1604         list_for_each_entry(c, &codec->bus->codec_list, list) {
1605                 for (i = 0; i < c->cvt_setups.used; i++) {
1606                         p = snd_array_elem(&c->cvt_setups, i);
1607                         if (!p->active && p->stream_tag == stream_tag &&
1608                             get_wcaps_type(get_wcaps(c, p->nid)) == type)
1609                                 p->dirty = 1;
1610                 }
1611         }
1612 }
1613 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1614
1615 static void really_cleanup_stream(struct hda_codec *codec,
1616                                   struct hda_cvt_setup *q);
1617
1618 /**
1619  * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1620  * @codec: the CODEC to clean up
1621  * @nid: the NID to clean up
1622  * @do_now: really clean up the stream instead of clearing the active flag
1623  */
1624 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1625                                     int do_now)
1626 {
1627         struct hda_cvt_setup *p;
1628
1629         if (!nid)
1630                 return;
1631
1632         if (codec->no_sticky_stream)
1633                 do_now = 1;
1634
1635         snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1636         p = get_hda_cvt_setup(codec, nid);
1637         if (p) {
1638                 /* here we just clear the active flag when do_now isn't set;
1639                  * actual clean-ups will be done later in
1640                  * purify_inactive_streams() called from snd_hda_codec_prpapre()
1641                  */
1642                 if (do_now)
1643                         really_cleanup_stream(codec, p);
1644                 else
1645                         p->active = 0;
1646         }
1647 }
1648 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1649
1650 static void really_cleanup_stream(struct hda_codec *codec,
1651                                   struct hda_cvt_setup *q)
1652 {
1653         hda_nid_t nid = q->nid;
1654         if (q->stream_tag || q->channel_id)
1655                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1656         if (q->format_id)
1657                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1658 );
1659         memset(q, 0, sizeof(*q));
1660         q->nid = nid;
1661 }
1662
1663 /* clean up the all conflicting obsolete streams */
1664 static void purify_inactive_streams(struct hda_codec *codec)
1665 {
1666         struct hda_codec *c;
1667         int i;
1668
1669         list_for_each_entry(c, &codec->bus->codec_list, list) {
1670                 for (i = 0; i < c->cvt_setups.used; i++) {
1671                         struct hda_cvt_setup *p;
1672                         p = snd_array_elem(&c->cvt_setups, i);
1673                         if (p->dirty)
1674                                 really_cleanup_stream(c, p);
1675                 }
1676         }
1677 }
1678
1679 #ifdef CONFIG_PM
1680 /* clean up all streams; called from suspend */
1681 static void hda_cleanup_all_streams(struct hda_codec *codec)
1682 {
1683         int i;
1684
1685         for (i = 0; i < codec->cvt_setups.used; i++) {
1686                 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1687                 if (p->stream_tag)
1688                         really_cleanup_stream(codec, p);
1689         }
1690 }
1691 #endif
1692
1693 /*
1694  * amp access functions
1695  */
1696
1697 /* FIXME: more better hash key? */
1698 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1699 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1700 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1701 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1702 #define INFO_AMP_CAPS   (1<<0)
1703 #define INFO_AMP_VOL(ch)        (1 << (1 + (ch)))
1704
1705 /* initialize the hash table */
1706 static void init_hda_cache(struct hda_cache_rec *cache,
1707                                      unsigned int record_size)
1708 {
1709         memset(cache, 0, sizeof(*cache));
1710         memset(cache->hash, 0xff, sizeof(cache->hash));
1711         snd_array_init(&cache->buf, record_size, 64);
1712 }
1713
1714 static void free_hda_cache(struct hda_cache_rec *cache)
1715 {
1716         snd_array_free(&cache->buf);
1717 }
1718
1719 /* query the hash.  allocate an entry if not found. */
1720 static struct hda_cache_head  *get_hash(struct hda_cache_rec *cache, u32 key)
1721 {
1722         u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1723         u16 cur = cache->hash[idx];
1724         struct hda_cache_head *info;
1725
1726         while (cur != 0xffff) {
1727                 info = snd_array_elem(&cache->buf, cur);
1728                 if (info->key == key)
1729                         return info;
1730                 cur = info->next;
1731         }
1732         return NULL;
1733 }
1734
1735 /* query the hash.  allocate an entry if not found. */
1736 static struct hda_cache_head  *get_alloc_hash(struct hda_cache_rec *cache,
1737                                               u32 key)
1738 {
1739         struct hda_cache_head *info = get_hash(cache, key);
1740         if (!info) {
1741                 u16 idx, cur;
1742                 /* add a new hash entry */
1743                 info = snd_array_new(&cache->buf);
1744                 if (!info)
1745                         return NULL;
1746                 cur = snd_array_index(&cache->buf, info);
1747                 info->key = key;
1748                 info->val = 0;
1749                 info->dirty = 0;
1750                 idx = key % (u16)ARRAY_SIZE(cache->hash);
1751                 info->next = cache->hash[idx];
1752                 cache->hash[idx] = cur;
1753         }
1754         return info;
1755 }
1756
1757 /* query and allocate an amp hash entry */
1758 static inline struct hda_amp_info *
1759 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1760 {
1761         return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1762 }
1763
1764 /* overwrite the value with the key in the caps hash */
1765 static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1766 {
1767         struct hda_amp_info *info;
1768
1769         mutex_lock(&codec->hash_mutex);
1770         info = get_alloc_amp_hash(codec, key);
1771         if (!info) {
1772                 mutex_unlock(&codec->hash_mutex);
1773                 return -EINVAL;
1774         }
1775         info->amp_caps = val;
1776         info->head.val |= INFO_AMP_CAPS;
1777         mutex_unlock(&codec->hash_mutex);
1778         return 0;
1779 }
1780
1781 /* query the value from the caps hash; if not found, fetch the current
1782  * value from the given function and store in the hash
1783  */
1784 static unsigned int
1785 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1786                 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1787 {
1788         struct hda_amp_info *info;
1789         unsigned int val;
1790
1791         mutex_lock(&codec->hash_mutex);
1792         info = get_alloc_amp_hash(codec, key);
1793         if (!info) {
1794                 mutex_unlock(&codec->hash_mutex);
1795                 return 0;
1796         }
1797         if (!(info->head.val & INFO_AMP_CAPS)) {
1798                 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1799                 val = func(codec, nid, dir);
1800                 write_caps_hash(codec, key, val);
1801         } else {
1802                 val = info->amp_caps;
1803                 mutex_unlock(&codec->hash_mutex);
1804         }
1805         return val;
1806 }
1807
1808 static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1809                                  int direction)
1810 {
1811         if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1812                 nid = codec->afg;
1813         return snd_hda_param_read(codec, nid,
1814                                   direction == HDA_OUTPUT ?
1815                                   AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1816 }
1817
1818 /**
1819  * query_amp_caps - query AMP capabilities
1820  * @codec: the HD-auio codec
1821  * @nid: the NID to query
1822  * @direction: either #HDA_INPUT or #HDA_OUTPUT
1823  *
1824  * Query AMP capabilities for the given widget and direction.
1825  * Returns the obtained capability bits.
1826  *
1827  * When cap bits have been already read, this doesn't read again but
1828  * returns the cached value.
1829  */
1830 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1831 {
1832         return query_caps_hash(codec, nid, direction,
1833                                HDA_HASH_KEY(nid, direction, 0),
1834                                read_amp_cap);
1835 }
1836 EXPORT_SYMBOL_HDA(query_amp_caps);
1837
1838 /**
1839  * snd_hda_override_amp_caps - Override the AMP capabilities
1840  * @codec: the CODEC to clean up
1841  * @nid: the NID to clean up
1842  * @direction: either #HDA_INPUT or #HDA_OUTPUT
1843  * @caps: the capability bits to set
1844  *
1845  * Override the cached AMP caps bits value by the given one.
1846  * This function is useful if the driver needs to adjust the AMP ranges,
1847  * e.g. limit to 0dB, etc.
1848  *
1849  * Returns zero if successful or a negative error code.
1850  */
1851 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1852                               unsigned int caps)
1853 {
1854         return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
1855 }
1856 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1857
1858 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1859                                  int dir)
1860 {
1861         return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1862 }
1863
1864 /**
1865  * snd_hda_query_pin_caps - Query PIN capabilities
1866  * @codec: the HD-auio codec
1867  * @nid: the NID to query
1868  *
1869  * Query PIN capabilities for the given widget.
1870  * Returns the obtained capability bits.
1871  *
1872  * When cap bits have been already read, this doesn't read again but
1873  * returns the cached value.
1874  */
1875 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1876 {
1877         return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
1878                                read_pin_cap);
1879 }
1880 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1881
1882 /**
1883  * snd_hda_override_pin_caps - Override the pin capabilities
1884  * @codec: the CODEC
1885  * @nid: the NID to override
1886  * @caps: the capability bits to set
1887  *
1888  * Override the cached PIN capabilitiy bits value by the given one.
1889  *
1890  * Returns zero if successful or a negative error code.
1891  */
1892 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1893                               unsigned int caps)
1894 {
1895         return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
1896 }
1897 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1898
1899 /* read or sync the hash value with the current value;
1900  * call within hash_mutex
1901  */
1902 static struct hda_amp_info *
1903 update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
1904                 int direction, int index, bool init_only)
1905 {
1906         struct hda_amp_info *info;
1907         unsigned int parm, val = 0;
1908         bool val_read = false;
1909
1910  retry:
1911         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1912         if (!info)
1913                 return NULL;
1914         if (!(info->head.val & INFO_AMP_VOL(ch))) {
1915                 if (!val_read) {
1916                         mutex_unlock(&codec->hash_mutex);
1917                         parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1918                         parm |= direction == HDA_OUTPUT ?
1919                                 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1920                         parm |= index;
1921                         val = snd_hda_codec_read(codec, nid, 0,
1922                                  AC_VERB_GET_AMP_GAIN_MUTE, parm);
1923                         val &= 0xff;
1924                         val_read = true;
1925                         mutex_lock(&codec->hash_mutex);
1926                         goto retry;
1927                 }
1928                 info->vol[ch] = val;
1929                 info->head.val |= INFO_AMP_VOL(ch);
1930         } else if (init_only)
1931                 return NULL;
1932         return info;
1933 }
1934
1935 /*
1936  * write the current volume in info to the h/w
1937  */
1938 static void put_vol_mute(struct hda_codec *codec, unsigned int amp_caps,
1939                          hda_nid_t nid, int ch, int direction, int index,
1940                          int val)
1941 {
1942         u32 parm;
1943
1944         parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1945         parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1946         parm |= index << AC_AMP_SET_INDEX_SHIFT;
1947         if ((val & HDA_AMP_MUTE) && !(amp_caps & AC_AMPCAP_MUTE) &&
1948             (amp_caps & AC_AMPCAP_MIN_MUTE))
1949                 ; /* set the zero value as a fake mute */
1950         else
1951                 parm |= val;
1952         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1953 }
1954
1955 /**
1956  * snd_hda_codec_amp_read - Read AMP value
1957  * @codec: HD-audio codec
1958  * @nid: NID to read the AMP value
1959  * @ch: channel (left=0 or right=1)
1960  * @direction: #HDA_INPUT or #HDA_OUTPUT
1961  * @index: the index value (only for input direction)
1962  *
1963  * Read AMP value.  The volume is between 0 to 0x7f, 0x80 = mute bit.
1964  */
1965 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1966                            int direction, int index)
1967 {
1968         struct hda_amp_info *info;
1969         unsigned int val = 0;
1970
1971         mutex_lock(&codec->hash_mutex);
1972         info = update_amp_hash(codec, nid, ch, direction, index, false);
1973         if (info)
1974                 val = info->vol[ch];
1975         mutex_unlock(&codec->hash_mutex);
1976         return val;
1977 }
1978 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1979
1980 static int codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1981                             int direction, int idx, int mask, int val,
1982                             bool init_only)
1983 {
1984         struct hda_amp_info *info;
1985         unsigned int caps;
1986         unsigned int cache_only;
1987
1988         if (snd_BUG_ON(mask & ~0xff))
1989                 mask &= 0xff;
1990         val &= mask;
1991
1992         mutex_lock(&codec->hash_mutex);
1993         info = update_amp_hash(codec, nid, ch, direction, idx, init_only);
1994         if (!info) {
1995                 mutex_unlock(&codec->hash_mutex);
1996                 return 0;
1997         }
1998         val |= info->vol[ch] & ~mask;
1999         if (info->vol[ch] == val) {
2000                 mutex_unlock(&codec->hash_mutex);
2001                 return 0;
2002         }
2003         info->vol[ch] = val;
2004         cache_only = info->head.dirty = codec->cached_write;
2005         caps = info->amp_caps;
2006         mutex_unlock(&codec->hash_mutex);
2007         if (!cache_only)
2008                 put_vol_mute(codec, caps, nid, ch, direction, idx, val);
2009         return 1;
2010 }
2011
2012 /**
2013  * snd_hda_codec_amp_update - update the AMP value
2014  * @codec: HD-audio codec
2015  * @nid: NID to read the AMP value
2016  * @ch: channel (left=0 or right=1)
2017  * @direction: #HDA_INPUT or #HDA_OUTPUT
2018  * @idx: the index value (only for input direction)
2019  * @mask: bit mask to set
2020  * @val: the bits value to set
2021  *
2022  * Update the AMP value with a bit mask.
2023  * Returns 0 if the value is unchanged, 1 if changed.
2024  */
2025 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
2026                              int direction, int idx, int mask, int val)
2027 {
2028         return codec_amp_update(codec, nid, ch, direction, idx, mask, val, false);
2029 }
2030 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
2031
2032 /**
2033  * snd_hda_codec_amp_stereo - update the AMP stereo values
2034  * @codec: HD-audio codec
2035  * @nid: NID to read the AMP value
2036  * @direction: #HDA_INPUT or #HDA_OUTPUT
2037  * @idx: the index value (only for input direction)
2038  * @mask: bit mask to set
2039  * @val: the bits value to set
2040  *
2041  * Update the AMP values like snd_hda_codec_amp_update(), but for a
2042  * stereo widget with the same mask and value.
2043  */
2044 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
2045                              int direction, int idx, int mask, int val)
2046 {
2047         int ch, ret = 0;
2048
2049         if (snd_BUG_ON(mask & ~0xff))
2050                 mask &= 0xff;
2051         for (ch = 0; ch < 2; ch++)
2052                 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
2053                                                 idx, mask, val);
2054         return ret;
2055 }
2056 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
2057
2058 /* Works like snd_hda_codec_amp_update() but it writes the value only at
2059  * the first access.  If the amp was already initialized / updated beforehand,
2060  * this does nothing.
2061  */
2062 int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
2063                            int dir, int idx, int mask, int val)
2064 {
2065         return codec_amp_update(codec, nid, ch, dir, idx, mask, val, true);
2066 }
2067 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init);
2068
2069 int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
2070                                   int dir, int idx, int mask, int val)
2071 {
2072         int ch, ret = 0;
2073
2074         if (snd_BUG_ON(mask & ~0xff))
2075                 mask &= 0xff;
2076         for (ch = 0; ch < 2; ch++)
2077                 ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
2078                                               idx, mask, val);
2079         return ret;
2080 }
2081 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init_stereo);
2082
2083 /**
2084  * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
2085  * @codec: HD-audio codec
2086  *
2087  * Resume the all amp commands from the cache.
2088  */
2089 void snd_hda_codec_resume_amp(struct hda_codec *codec)
2090 {
2091         int i;
2092
2093         mutex_lock(&codec->hash_mutex);
2094         codec->cached_write = 0;
2095         for (i = 0; i < codec->amp_cache.buf.used; i++) {
2096                 struct hda_amp_info *buffer;
2097                 u32 key;
2098                 hda_nid_t nid;
2099                 unsigned int idx, dir, ch;
2100                 struct hda_amp_info info;
2101
2102                 buffer = snd_array_elem(&codec->amp_cache.buf, i);
2103                 if (!buffer->head.dirty)
2104                         continue;
2105                 buffer->head.dirty = 0;
2106                 info = *buffer;
2107                 key = info.head.key;
2108                 if (!key)
2109                         continue;
2110                 nid = key & 0xff;
2111                 idx = (key >> 16) & 0xff;
2112                 dir = (key >> 24) & 0xff;
2113                 for (ch = 0; ch < 2; ch++) {
2114                         if (!(info.head.val & INFO_AMP_VOL(ch)))
2115                                 continue;
2116                         mutex_unlock(&codec->hash_mutex);
2117                         put_vol_mute(codec, info.amp_caps, nid, ch, dir, idx,
2118                                      info.vol[ch]);
2119                         mutex_lock(&codec->hash_mutex);
2120                 }
2121         }
2122         mutex_unlock(&codec->hash_mutex);
2123 }
2124 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
2125
2126 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
2127                              unsigned int ofs)
2128 {
2129         u32 caps = query_amp_caps(codec, nid, dir);
2130         /* get num steps */
2131         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2132         if (ofs < caps)
2133                 caps -= ofs;
2134         return caps;
2135 }
2136
2137 /**
2138  * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
2139  *
2140  * The control element is supposed to have the private_value field
2141  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2142  */
2143 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
2144                                   struct snd_ctl_elem_info *uinfo)
2145 {
2146         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2147         u16 nid = get_amp_nid(kcontrol);
2148         u8 chs = get_amp_channels(kcontrol);
2149         int dir = get_amp_direction(kcontrol);
2150         unsigned int ofs = get_amp_offset(kcontrol);
2151
2152         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2153         uinfo->count = chs == 3 ? 2 : 1;
2154         uinfo->value.integer.min = 0;
2155         uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
2156         if (!uinfo->value.integer.max) {
2157                 printk(KERN_WARNING "hda_codec: "
2158                        "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
2159                        kcontrol->id.name);
2160                 return -EINVAL;
2161         }
2162         return 0;
2163 }
2164 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
2165
2166
2167 static inline unsigned int
2168 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
2169                int ch, int dir, int idx, unsigned int ofs)
2170 {
2171         unsigned int val;
2172         val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
2173         val &= HDA_AMP_VOLMASK;
2174         if (val >= ofs)
2175                 val -= ofs;
2176         else
2177                 val = 0;
2178         return val;
2179 }
2180
2181 static inline int
2182 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
2183                  int ch, int dir, int idx, unsigned int ofs,
2184                  unsigned int val)
2185 {
2186         unsigned int maxval;
2187
2188         if (val > 0)
2189                 val += ofs;
2190         /* ofs = 0: raw max value */
2191         maxval = get_amp_max_value(codec, nid, dir, 0);
2192         if (val > maxval)
2193                 val = maxval;
2194         return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
2195                                         HDA_AMP_VOLMASK, val);
2196 }
2197
2198 /**
2199  * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
2200  *
2201  * The control element is supposed to have the private_value field
2202  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2203  */
2204 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
2205                                  struct snd_ctl_elem_value *ucontrol)
2206 {
2207         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2208         hda_nid_t nid = get_amp_nid(kcontrol);
2209         int chs = get_amp_channels(kcontrol);
2210         int dir = get_amp_direction(kcontrol);
2211         int idx = get_amp_index(kcontrol);
2212         unsigned int ofs = get_amp_offset(kcontrol);
2213         long *valp = ucontrol->value.integer.value;
2214
2215         if (chs & 1)
2216                 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
2217         if (chs & 2)
2218                 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
2219         return 0;
2220 }
2221 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
2222
2223 /**
2224  * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2225  *
2226  * The control element is supposed to have the private_value field
2227  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2228  */
2229 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2230                                  struct snd_ctl_elem_value *ucontrol)
2231 {
2232         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2233         hda_nid_t nid = get_amp_nid(kcontrol);
2234         int chs = get_amp_channels(kcontrol);
2235         int dir = get_amp_direction(kcontrol);
2236         int idx = get_amp_index(kcontrol);
2237         unsigned int ofs = get_amp_offset(kcontrol);
2238         long *valp = ucontrol->value.integer.value;
2239         int change = 0;
2240
2241         snd_hda_power_up(codec);
2242         if (chs & 1) {
2243                 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2244                 valp++;
2245         }
2246         if (chs & 2)
2247                 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2248         snd_hda_power_down(codec);
2249         return change;
2250 }
2251 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
2252
2253 /**
2254  * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2255  *
2256  * The control element is supposed to have the private_value field
2257  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2258  */
2259 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2260                           unsigned int size, unsigned int __user *_tlv)
2261 {
2262         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2263         hda_nid_t nid = get_amp_nid(kcontrol);
2264         int dir = get_amp_direction(kcontrol);
2265         unsigned int ofs = get_amp_offset(kcontrol);
2266         bool min_mute = get_amp_min_mute(kcontrol);
2267         u32 caps, val1, val2;
2268
2269         if (size < 4 * sizeof(unsigned int))
2270                 return -ENOMEM;
2271         caps = query_amp_caps(codec, nid, dir);
2272         val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2273         val2 = (val2 + 1) * 25;
2274         val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2275         val1 += ofs;
2276         val1 = ((int)val1) * ((int)val2);
2277         if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
2278                 val2 |= TLV_DB_SCALE_MUTE;
2279         if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2280                 return -EFAULT;
2281         if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2282                 return -EFAULT;
2283         if (put_user(val1, _tlv + 2))
2284                 return -EFAULT;
2285         if (put_user(val2, _tlv + 3))
2286                 return -EFAULT;
2287         return 0;
2288 }
2289 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
2290
2291 /**
2292  * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2293  * @codec: HD-audio codec
2294  * @nid: NID of a reference widget
2295  * @dir: #HDA_INPUT or #HDA_OUTPUT
2296  * @tlv: TLV data to be stored, at least 4 elements
2297  *
2298  * Set (static) TLV data for a virtual master volume using the AMP caps
2299  * obtained from the reference NID.
2300  * The volume range is recalculated as if the max volume is 0dB.
2301  */
2302 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2303                              unsigned int *tlv)
2304 {
2305         u32 caps;
2306         int nums, step;
2307
2308         caps = query_amp_caps(codec, nid, dir);
2309         nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2310         step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2311         step = (step + 1) * 25;
2312         tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2313         tlv[1] = 2 * sizeof(unsigned int);
2314         tlv[2] = -nums * step;
2315         tlv[3] = step;
2316 }
2317 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2318
2319 /* find a mixer control element with the given name */
2320 static struct snd_kcontrol *
2321 find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
2322 {
2323         struct snd_ctl_elem_id id;
2324         memset(&id, 0, sizeof(id));
2325         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2326         id.device = dev;
2327         id.index = idx;
2328         if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2329                 return NULL;
2330         strcpy(id.name, name);
2331         return snd_ctl_find_id(codec->bus->card, &id);
2332 }
2333
2334 /**
2335  * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2336  * @codec: HD-audio codec
2337  * @name: ctl id name string
2338  *
2339  * Get the control element with the given id string and IFACE_MIXER.
2340  */
2341 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2342                                             const char *name)
2343 {
2344         return find_mixer_ctl(codec, name, 0, 0);
2345 }
2346 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
2347
2348 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
2349                                     int start_idx)
2350 {
2351         int i, idx;
2352         /* 16 ctlrs should be large enough */
2353         for (i = 0, idx = start_idx; i < 16; i++, idx++) {
2354                 if (!find_mixer_ctl(codec, name, 0, idx))
2355                         return idx;
2356         }
2357         return -EBUSY;
2358 }
2359
2360 /**
2361  * snd_hda_ctl_add - Add a control element and assign to the codec
2362  * @codec: HD-audio codec
2363  * @nid: corresponding NID (optional)
2364  * @kctl: the control element to assign
2365  *
2366  * Add the given control element to an array inside the codec instance.
2367  * All control elements belonging to a codec are supposed to be added
2368  * by this function so that a proper clean-up works at the free or
2369  * reconfiguration time.
2370  *
2371  * If non-zero @nid is passed, the NID is assigned to the control element.
2372  * The assignment is shown in the codec proc file.
2373  *
2374  * snd_hda_ctl_add() checks the control subdev id field whether
2375  * #HDA_SUBDEV_NID_FLAG bit is set.  If set (and @nid is zero), the lower
2376  * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2377  * specifies if kctl->private_value is a HDA amplifier value.
2378  */
2379 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2380                     struct snd_kcontrol *kctl)
2381 {
2382         int err;
2383         unsigned short flags = 0;
2384         struct hda_nid_item *item;
2385
2386         if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2387                 flags |= HDA_NID_ITEM_AMP;
2388                 if (nid == 0)
2389                         nid = get_amp_nid_(kctl->private_value);
2390         }
2391         if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2392                 nid = kctl->id.subdevice & 0xffff;
2393         if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2394                 kctl->id.subdevice = 0;
2395         err = snd_ctl_add(codec->bus->card, kctl);
2396         if (err < 0)
2397                 return err;
2398         item = snd_array_new(&codec->mixers);
2399         if (!item)
2400                 return -ENOMEM;
2401         item->kctl = kctl;
2402         item->nid = nid;
2403         item->flags = flags;
2404         return 0;
2405 }
2406 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
2407
2408 /**
2409  * snd_hda_add_nid - Assign a NID to a control element
2410  * @codec: HD-audio codec
2411  * @nid: corresponding NID (optional)
2412  * @kctl: the control element to assign
2413  * @index: index to kctl
2414  *
2415  * Add the given control element to an array inside the codec instance.
2416  * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2417  * NID:KCTL mapping - for example "Capture Source" selector.
2418  */
2419 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2420                     unsigned int index, hda_nid_t nid)
2421 {
2422         struct hda_nid_item *item;
2423
2424         if (nid > 0) {
2425                 item = snd_array_new(&codec->nids);
2426                 if (!item)
2427                         return -ENOMEM;
2428                 item->kctl = kctl;
2429                 item->index = index;
2430                 item->nid = nid;
2431                 return 0;
2432         }
2433         printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2434                kctl->id.name, kctl->id.index, index);
2435         return -EINVAL;
2436 }
2437 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2438
2439 /**
2440  * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2441  * @codec: HD-audio codec
2442  */
2443 void snd_hda_ctls_clear(struct hda_codec *codec)
2444 {
2445         int i;
2446         struct hda_nid_item *items = codec->mixers.list;
2447         for (i = 0; i < codec->mixers.used; i++)
2448                 snd_ctl_remove(codec->bus->card, items[i].kctl);
2449         snd_array_free(&codec->mixers);
2450         snd_array_free(&codec->nids);
2451 }
2452
2453 /* pseudo device locking
2454  * toggle card->shutdown to allow/disallow the device access (as a hack)
2455  */
2456 int snd_hda_lock_devices(struct hda_bus *bus)
2457 {
2458         struct snd_card *card = bus->card;
2459         struct hda_codec *codec;
2460
2461         spin_lock(&card->files_lock);
2462         if (card->shutdown)
2463                 goto err_unlock;
2464         card->shutdown = 1;
2465         if (!list_empty(&card->ctl_files))
2466                 goto err_clear;
2467
2468         list_for_each_entry(codec, &bus->codec_list, list) {
2469                 int pcm;
2470                 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2471                         struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2472                         if (!cpcm->pcm)
2473                                 continue;
2474                         if (cpcm->pcm->streams[0].substream_opened ||
2475                             cpcm->pcm->streams[1].substream_opened)
2476                                 goto err_clear;
2477                 }
2478         }
2479         spin_unlock(&card->files_lock);
2480         return 0;
2481
2482  err_clear:
2483         card->shutdown = 0;
2484  err_unlock:
2485         spin_unlock(&card->files_lock);
2486         return -EINVAL;
2487 }
2488 EXPORT_SYMBOL_HDA(snd_hda_lock_devices);
2489
2490 void snd_hda_unlock_devices(struct hda_bus *bus)
2491 {
2492         struct snd_card *card = bus->card;
2493
2494         card = bus->card;
2495         spin_lock(&card->files_lock);
2496         card->shutdown = 0;
2497         spin_unlock(&card->files_lock);
2498 }
2499 EXPORT_SYMBOL_HDA(snd_hda_unlock_devices);
2500
2501 /**
2502  * snd_hda_codec_reset - Clear all objects assigned to the codec
2503  * @codec: HD-audio codec
2504  *
2505  * This frees the all PCM and control elements assigned to the codec, and
2506  * clears the caches and restores the pin default configurations.
2507  *
2508  * When a device is being used, it returns -EBSY.  If successfully freed,
2509  * returns zero.
2510  */
2511 int snd_hda_codec_reset(struct hda_codec *codec)
2512 {
2513         struct hda_bus *bus = codec->bus;
2514         struct snd_card *card = bus->card;
2515         int i;
2516
2517         if (snd_hda_lock_devices(bus) < 0)
2518                 return -EBUSY;
2519
2520         /* OK, let it free */
2521         cancel_delayed_work_sync(&codec->jackpoll_work);
2522 #ifdef CONFIG_PM
2523         cancel_delayed_work_sync(&codec->power_work);
2524         flush_workqueue(bus->workq);
2525 #endif
2526         snd_hda_ctls_clear(codec);
2527         /* relase PCMs */
2528         for (i = 0; i < codec->num_pcms; i++) {
2529                 if (codec->pcm_info[i].pcm) {
2530                         snd_device_free(card, codec->pcm_info[i].pcm);
2531                         clear_bit(codec->pcm_info[i].device,
2532                                   bus->pcm_dev_bits);
2533                 }
2534         }
2535         if (codec->patch_ops.free)
2536                 codec->patch_ops.free(codec);
2537         memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2538         snd_hda_jack_tbl_clear(codec);
2539         codec->proc_widget_hook = NULL;
2540         codec->spec = NULL;
2541         free_hda_cache(&codec->amp_cache);
2542         free_hda_cache(&codec->cmd_cache);
2543         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2544         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2545         /* free only driver_pins so that init_pins + user_pins are restored */
2546         snd_array_free(&codec->driver_pins);
2547         snd_array_free(&codec->cvt_setups);
2548         snd_array_free(&codec->spdif_out);
2549         snd_array_free(&codec->verbs);
2550         codec->num_pcms = 0;
2551         codec->pcm_info = NULL;
2552         codec->preset = NULL;
2553         codec->slave_dig_outs = NULL;
2554         codec->spdif_status_reset = 0;
2555         module_put(codec->owner);
2556         codec->owner = NULL;
2557
2558         /* allow device access again */
2559         snd_hda_unlock_devices(bus);
2560         return 0;
2561 }
2562
2563 typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2564
2565 /* apply the function to all matching slave ctls in the mixer list */
2566 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2567                       const char *suffix, map_slave_func_t func, void *data) 
2568 {
2569         struct hda_nid_item *items;
2570         const char * const *s;
2571         int i, err;
2572
2573         items = codec->mixers.list;
2574         for (i = 0; i < codec->mixers.used; i++) {
2575                 struct snd_kcontrol *sctl = items[i].kctl;
2576                 if (!sctl || !sctl->id.name ||
2577                     sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2578                         continue;
2579                 for (s = slaves; *s; s++) {
2580                         char tmpname[sizeof(sctl->id.name)];
2581                         const char *name = *s;
2582                         if (suffix) {
2583                                 snprintf(tmpname, sizeof(tmpname), "%s %s",
2584                                          name, suffix);
2585                                 name = tmpname;
2586                         }
2587                         if (!strcmp(sctl->id.name, name)) {
2588                                 err = func(data, sctl);
2589                                 if (err)
2590                                         return err;
2591                                 break;
2592                         }
2593                 }
2594         }
2595         return 0;
2596 }
2597
2598 static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2599 {
2600         return 1;
2601 }
2602
2603 /* guess the value corresponding to 0dB */
2604 static int get_kctl_0dB_offset(struct snd_kcontrol *kctl)
2605 {
2606         int _tlv[4];
2607         const int *tlv = NULL;
2608         int val = -1;
2609
2610         if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2611                 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2612                 mm_segment_t fs = get_fs();
2613                 set_fs(get_ds());
2614                 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2615                         tlv = _tlv;
2616                 set_fs(fs);
2617         } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2618                 tlv = kctl->tlv.p;
2619         if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE)
2620                 val = -tlv[2] / tlv[3];
2621         return val;
2622 }
2623
2624 /* call kctl->put with the given value(s) */
2625 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2626 {
2627         struct snd_ctl_elem_value *ucontrol;
2628         ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2629         if (!ucontrol)
2630                 return -ENOMEM;
2631         ucontrol->value.integer.value[0] = val;
2632         ucontrol->value.integer.value[1] = val;
2633         kctl->put(kctl, ucontrol);
2634         kfree(ucontrol);
2635         return 0;
2636 }
2637
2638 /* initialize the slave volume with 0dB */
2639 static int init_slave_0dB(void *data, struct snd_kcontrol *slave)
2640 {
2641         int offset = get_kctl_0dB_offset(slave);
2642         if (offset > 0)
2643                 put_kctl_with_value(slave, offset);
2644         return 0;
2645 }
2646
2647 /* unmute the slave */
2648 static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2649 {
2650         return put_kctl_with_value(slave, 1);
2651 }
2652
2653 /**
2654  * snd_hda_add_vmaster - create a virtual master control and add slaves
2655  * @codec: HD-audio codec
2656  * @name: vmaster control name
2657  * @tlv: TLV data (optional)
2658  * @slaves: slave control names (optional)
2659  * @suffix: suffix string to each slave name (optional)
2660  * @init_slave_vol: initialize slaves to unmute/0dB
2661  * @ctl_ret: store the vmaster kcontrol in return
2662  *
2663  * Create a virtual master control with the given name.  The TLV data
2664  * must be either NULL or a valid data.
2665  *
2666  * @slaves is a NULL-terminated array of strings, each of which is a
2667  * slave control name.  All controls with these names are assigned to
2668  * the new virtual master control.
2669  *
2670  * This function returns zero if successful or a negative error code.
2671  */
2672 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2673                         unsigned int *tlv, const char * const *slaves,
2674                           const char *suffix, bool init_slave_vol,
2675                           struct snd_kcontrol **ctl_ret)
2676 {
2677         struct snd_kcontrol *kctl;
2678         int err;
2679
2680         if (ctl_ret)
2681                 *ctl_ret = NULL;
2682
2683         err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2684         if (err != 1) {
2685                 snd_printdd("No slave found for %s\n", name);
2686                 return 0;
2687         }
2688         kctl = snd_ctl_make_virtual_master(name, tlv);
2689         if (!kctl)
2690                 return -ENOMEM;
2691         err = snd_hda_ctl_add(codec, 0, kctl);
2692         if (err < 0)
2693                 return err;
2694
2695         err = map_slaves(codec, slaves, suffix,
2696                          (map_slave_func_t)snd_ctl_add_slave, kctl);
2697         if (err < 0)
2698                 return err;
2699
2700         /* init with master mute & zero volume */
2701         put_kctl_with_value(kctl, 0);
2702         if (init_slave_vol)
2703                 map_slaves(codec, slaves, suffix,
2704                            tlv ? init_slave_0dB : init_slave_unmute, kctl);
2705
2706         if (ctl_ret)
2707                 *ctl_ret = kctl;
2708         return 0;
2709 }
2710 EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
2711
2712 /*
2713  * mute-LED control using vmaster
2714  */
2715 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2716                                   struct snd_ctl_elem_info *uinfo)
2717 {
2718         static const char * const texts[] = {
2719                 "On", "Off", "Follow Master"
2720         };
2721         unsigned int index;
2722
2723         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2724         uinfo->count = 1;
2725         uinfo->value.enumerated.items = 3;
2726         index = uinfo->value.enumerated.item;
2727         if (index >= 3)
2728                 index = 2;
2729         strcpy(uinfo->value.enumerated.name, texts[index]);
2730         return 0;
2731 }
2732
2733 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2734                                  struct snd_ctl_elem_value *ucontrol)
2735 {
2736         struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2737         ucontrol->value.enumerated.item[0] = hook->mute_mode;
2738         return 0;
2739 }
2740
2741 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2742                                  struct snd_ctl_elem_value *ucontrol)
2743 {
2744         struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2745         unsigned int old_mode = hook->mute_mode;
2746
2747         hook->mute_mode = ucontrol->value.enumerated.item[0];
2748         if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2749                 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2750         if (old_mode == hook->mute_mode)
2751                 return 0;
2752         snd_hda_sync_vmaster_hook(hook);
2753         return 1;
2754 }
2755
2756 static struct snd_kcontrol_new vmaster_mute_mode = {
2757         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2758         .name = "Mute-LED Mode",
2759         .info = vmaster_mute_mode_info,
2760         .get = vmaster_mute_mode_get,
2761         .put = vmaster_mute_mode_put,
2762 };
2763
2764 /*
2765  * Add a mute-LED hook with the given vmaster switch kctl
2766  * "Mute-LED Mode" control is automatically created and associated with
2767  * the given hook.
2768  */
2769 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2770                              struct hda_vmaster_mute_hook *hook,
2771                              bool expose_enum_ctl)
2772 {
2773         struct snd_kcontrol *kctl;
2774
2775         if (!hook->hook || !hook->sw_kctl)
2776                 return 0;
2777         snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2778         hook->codec = codec;
2779         hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2780         if (!expose_enum_ctl)
2781                 return 0;
2782         kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2783         if (!kctl)
2784                 return -ENOMEM;
2785         return snd_hda_ctl_add(codec, 0, kctl);
2786 }
2787 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
2788
2789 /*
2790  * Call the hook with the current value for synchronization
2791  * Should be called in init callback
2792  */
2793 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2794 {
2795         if (!hook->hook || !hook->codec)
2796                 return;
2797         /* don't call vmaster hook in the destructor since it might have
2798          * been already destroyed
2799          */
2800         if (hook->codec->bus->shutdown)
2801                 return;
2802         switch (hook->mute_mode) {
2803         case HDA_VMUTE_FOLLOW_MASTER:
2804                 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2805                 break;
2806         default:
2807                 hook->hook(hook->codec, hook->mute_mode);
2808                 break;
2809         }
2810 }
2811 EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
2812
2813
2814 /**
2815  * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2816  *
2817  * The control element is supposed to have the private_value field
2818  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2819  */
2820 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2821                                   struct snd_ctl_elem_info *uinfo)
2822 {
2823         int chs = get_amp_channels(kcontrol);
2824
2825         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2826         uinfo->count = chs == 3 ? 2 : 1;
2827         uinfo->value.integer.min = 0;
2828         uinfo->value.integer.max = 1;
2829         return 0;
2830 }
2831 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2832
2833 /**
2834  * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2835  *
2836  * The control element is supposed to have the private_value field
2837  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2838  */
2839 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2840                                  struct snd_ctl_elem_value *ucontrol)
2841 {
2842         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2843         hda_nid_t nid = get_amp_nid(kcontrol);
2844         int chs = get_amp_channels(kcontrol);
2845         int dir = get_amp_direction(kcontrol);
2846         int idx = get_amp_index(kcontrol);
2847         long *valp = ucontrol->value.integer.value;
2848
2849         if (chs & 1)
2850                 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2851                            HDA_AMP_MUTE) ? 0 : 1;
2852         if (chs & 2)
2853                 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2854                          HDA_AMP_MUTE) ? 0 : 1;
2855         return 0;
2856 }
2857 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2858
2859 /**
2860  * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2861  *
2862  * The control element is supposed to have the private_value field
2863  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2864  */
2865 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2866                                  struct snd_ctl_elem_value *ucontrol)
2867 {
2868         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2869         hda_nid_t nid = get_amp_nid(kcontrol);
2870         int chs = get_amp_channels(kcontrol);
2871         int dir = get_amp_direction(kcontrol);
2872         int idx = get_amp_index(kcontrol);
2873         long *valp = ucontrol->value.integer.value;
2874         int change = 0;
2875
2876         snd_hda_power_up(codec);
2877         if (chs & 1) {
2878                 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2879                                                   HDA_AMP_MUTE,
2880                                                   *valp ? 0 : HDA_AMP_MUTE);
2881                 valp++;
2882         }
2883         if (chs & 2)
2884                 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2885                                                    HDA_AMP_MUTE,
2886                                                    *valp ? 0 : HDA_AMP_MUTE);
2887         hda_call_check_power_status(codec, nid);
2888         snd_hda_power_down(codec);
2889         return change;
2890 }
2891 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2892
2893 /*
2894  * bound volume controls
2895  *
2896  * bind multiple volumes (# indices, from 0)
2897  */
2898
2899 #define AMP_VAL_IDX_SHIFT       19
2900 #define AMP_VAL_IDX_MASK        (0x0f<<19)
2901
2902 /**
2903  * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2904  *
2905  * The control element is supposed to have the private_value field
2906  * set up via HDA_BIND_MUTE*() macros.
2907  */
2908 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2909                                   struct snd_ctl_elem_value *ucontrol)
2910 {
2911         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2912         unsigned long pval;
2913         int err;
2914
2915         mutex_lock(&codec->control_mutex);
2916         pval = kcontrol->private_value;
2917         kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2918         err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2919         kcontrol->private_value = pval;
2920         mutex_unlock(&codec->control_mutex);
2921         return err;
2922 }
2923 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2924
2925 /**
2926  * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2927  *
2928  * The control element is supposed to have the private_value field
2929  * set up via HDA_BIND_MUTE*() macros.
2930  */
2931 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2932                                   struct snd_ctl_elem_value *ucontrol)
2933 {
2934         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2935         unsigned long pval;
2936         int i, indices, err = 0, change = 0;
2937
2938         mutex_lock(&codec->control_mutex);
2939         pval = kcontrol->private_value;
2940         indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2941         for (i = 0; i < indices; i++) {
2942                 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2943                         (i << AMP_VAL_IDX_SHIFT);
2944                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2945                 if (err < 0)
2946                         break;
2947                 change |= err;
2948         }
2949         kcontrol->private_value = pval;
2950         mutex_unlock(&codec->control_mutex);
2951         return err < 0 ? err : change;
2952 }
2953 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2954
2955 /**
2956  * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2957  *
2958  * The control element is supposed to have the private_value field
2959  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2960  */
2961 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2962                                  struct snd_ctl_elem_info *uinfo)
2963 {
2964         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2965         struct hda_bind_ctls *c;
2966         int err;
2967
2968         mutex_lock(&codec->control_mutex);
2969         c = (struct hda_bind_ctls *)kcontrol->private_value;
2970         kcontrol->private_value = *c->values;
2971         err = c->ops->info(kcontrol, uinfo);
2972         kcontrol->private_value = (long)c;
2973         mutex_unlock(&codec->control_mutex);
2974         return err;
2975 }
2976 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2977
2978 /**
2979  * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2980  *
2981  * The control element is supposed to have the private_value field
2982  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2983  */
2984 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2985                                 struct snd_ctl_elem_value *ucontrol)
2986 {
2987         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2988         struct hda_bind_ctls *c;
2989         int err;
2990
2991         mutex_lock(&codec->control_mutex);
2992         c = (struct hda_bind_ctls *)kcontrol->private_value;
2993         kcontrol->private_value = *c->values;
2994         err = c->ops->get(kcontrol, ucontrol);
2995         kcontrol->private_value = (long)c;
2996         mutex_unlock(&codec->control_mutex);
2997         return err;
2998 }
2999 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
3000
3001 /**
3002  * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
3003  *
3004  * The control element is supposed to have the private_value field
3005  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
3006  */
3007 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
3008                                 struct snd_ctl_elem_value *ucontrol)
3009 {
3010         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3011         struct hda_bind_ctls *c;
3012         unsigned long *vals;
3013         int err = 0, change = 0;
3014
3015         mutex_lock(&codec->control_mutex);
3016         c = (struct hda_bind_ctls *)kcontrol->private_value;
3017         for (vals = c->values; *vals; vals++) {
3018                 kcontrol->private_value = *vals;
3019                 err = c->ops->put(kcontrol, ucontrol);
3020                 if (err < 0)
3021                         break;
3022                 change |= err;
3023         }
3024         kcontrol->private_value = (long)c;
3025         mutex_unlock(&codec->control_mutex);
3026         return err < 0 ? err : change;
3027 }
3028 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
3029
3030 /**
3031  * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
3032  *
3033  * The control element is supposed to have the private_value field
3034  * set up via HDA_BIND_VOL() macro.
3035  */
3036 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
3037                            unsigned int size, unsigned int __user *tlv)
3038 {
3039         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3040         struct hda_bind_ctls *c;
3041         int err;
3042
3043         mutex_lock(&codec->control_mutex);
3044         c = (struct hda_bind_ctls *)kcontrol->private_value;
3045         kcontrol->private_value = *c->values;
3046         err = c->ops->tlv(kcontrol, op_flag, size, tlv);
3047         kcontrol->private_value = (long)c;
3048         mutex_unlock(&codec->control_mutex);
3049         return err;
3050 }
3051 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
3052
3053 struct hda_ctl_ops snd_hda_bind_vol = {
3054         .info = snd_hda_mixer_amp_volume_info,
3055         .get = snd_hda_mixer_amp_volume_get,
3056         .put = snd_hda_mixer_amp_volume_put,
3057         .tlv = snd_hda_mixer_amp_tlv
3058 };
3059 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
3060
3061 struct hda_ctl_ops snd_hda_bind_sw = {
3062         .info = snd_hda_mixer_amp_switch_info,
3063         .get = snd_hda_mixer_amp_switch_get,
3064         .put = snd_hda_mixer_amp_switch_put,
3065         .tlv = snd_hda_mixer_amp_tlv
3066 };
3067 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
3068
3069 /*
3070  * SPDIF out controls
3071  */
3072
3073 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
3074                                    struct snd_ctl_elem_info *uinfo)
3075 {
3076         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
3077         uinfo->count = 1;
3078         return 0;
3079 }
3080
3081 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
3082                                    struct snd_ctl_elem_value *ucontrol)
3083 {
3084         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3085                                            IEC958_AES0_NONAUDIO |
3086                                            IEC958_AES0_CON_EMPHASIS_5015 |
3087                                            IEC958_AES0_CON_NOT_COPYRIGHT;
3088         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
3089                                            IEC958_AES1_CON_ORIGINAL;
3090         return 0;
3091 }
3092
3093 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
3094                                    struct snd_ctl_elem_value *ucontrol)
3095 {
3096         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3097                                            IEC958_AES0_NONAUDIO |
3098                                            IEC958_AES0_PRO_EMPHASIS_5015;
3099         return 0;
3100 }
3101
3102 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
3103                                      struct snd_ctl_elem_value *ucontrol)
3104 {
3105         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3106         int idx = kcontrol->private_value;
3107         struct hda_spdif_out *spdif;
3108
3109         mutex_lock(&codec->spdif_mutex);
3110         spdif = snd_array_elem(&codec->spdif_out, idx);
3111         ucontrol->value.iec958.status[0] = spdif->status & 0xff;
3112         ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
3113         ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
3114         ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
3115         mutex_unlock(&codec->spdif_mutex);
3116
3117         return 0;
3118 }
3119
3120 /* convert from SPDIF status bits to HDA SPDIF bits
3121  * bit 0 (DigEn) is always set zero (to be filled later)
3122  */
3123 static unsigned short convert_from_spdif_status(unsigned int sbits)
3124 {
3125         unsigned short val = 0;
3126
3127         if (sbits & IEC958_AES0_PROFESSIONAL)
3128                 val |= AC_DIG1_PROFESSIONAL;
3129         if (sbits & IEC958_AES0_NONAUDIO)
3130                 val |= AC_DIG1_NONAUDIO;
3131         if (sbits & IEC958_AES0_PROFESSIONAL) {
3132                 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
3133                     IEC958_AES0_PRO_EMPHASIS_5015)
3134                         val |= AC_DIG1_EMPHASIS;
3135         } else {
3136                 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
3137                     IEC958_AES0_CON_EMPHASIS_5015)
3138                         val |= AC_DIG1_EMPHASIS;
3139                 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
3140                         val |= AC_DIG1_COPYRIGHT;
3141                 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
3142                         val |= AC_DIG1_LEVEL;
3143                 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
3144         }
3145         return val;
3146 }
3147
3148 /* convert to SPDIF status bits from HDA SPDIF bits
3149  */
3150 static unsigned int convert_to_spdif_status(unsigned short val)
3151 {
3152         unsigned int sbits = 0;
3153
3154         if (val & AC_DIG1_NONAUDIO)
3155                 sbits |= IEC958_AES0_NONAUDIO;
3156         if (val & AC_DIG1_PROFESSIONAL)
3157                 sbits |= IEC958_AES0_PROFESSIONAL;
3158         if (sbits & IEC958_AES0_PROFESSIONAL) {
3159                 if (val & AC_DIG1_EMPHASIS)
3160                         sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
3161         } else {
3162                 if (val & AC_DIG1_EMPHASIS)
3163                         sbits |= IEC958_AES0_CON_EMPHASIS_5015;
3164                 if (!(val & AC_DIG1_COPYRIGHT))
3165                         sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
3166                 if (val & AC_DIG1_LEVEL)
3167                         sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
3168                 sbits |= val & (0x7f << 8);
3169         }
3170         return sbits;
3171 }
3172
3173 /* set digital convert verbs both for the given NID and its slaves */
3174 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
3175                         int verb, int val)
3176 {
3177         const hda_nid_t *d;
3178
3179         snd_hda_codec_write_cache(codec, nid, 0, verb, val);
3180         d = codec->slave_dig_outs;
3181         if (!d)
3182                 return;
3183         for (; *d; d++)
3184                 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
3185 }
3186
3187 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
3188                                        int dig1, int dig2)
3189 {
3190         if (dig1 != -1)
3191                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
3192         if (dig2 != -1)
3193                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
3194 }
3195
3196 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
3197                                      struct snd_ctl_elem_value *ucontrol)
3198 {
3199         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3200         int idx = kcontrol->private_value;
3201         struct hda_spdif_out *spdif;
3202         hda_nid_t nid;
3203         unsigned short val;
3204         int change;
3205
3206         mutex_lock(&codec->spdif_mutex);
3207         spdif = snd_array_elem(&codec->spdif_out, idx);
3208         nid = spdif->nid;
3209         spdif->status = ucontrol->value.iec958.status[0] |
3210                 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
3211                 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
3212                 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
3213         val = convert_from_spdif_status(spdif->status);
3214         val |= spdif->ctls & 1;
3215         change = spdif->ctls != val;
3216         spdif->ctls = val;
3217         if (change && nid != (u16)-1)
3218                 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
3219         mutex_unlock(&codec->spdif_mutex);
3220         return change;
3221 }
3222
3223 #define snd_hda_spdif_out_switch_info   snd_ctl_boolean_mono_info
3224
3225 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3226                                         struct snd_ctl_elem_value *ucontrol)
3227 {
3228         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3229         int idx = kcontrol->private_value;
3230         struct hda_spdif_out *spdif;
3231
3232         mutex_lock(&codec->spdif_mutex);
3233         spdif = snd_array_elem(&codec->spdif_out, idx);
3234         ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
3235         mutex_unlock(&codec->spdif_mutex);
3236         return 0;
3237 }
3238
3239 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3240                                   int dig1, int dig2)
3241 {
3242         set_dig_out_convert(codec, nid, dig1, dig2);
3243         /* unmute amp switch (if any) */
3244         if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3245             (dig1 & AC_DIG1_ENABLE))
3246                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3247                                             HDA_AMP_MUTE, 0);
3248 }
3249
3250 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3251                                         struct snd_ctl_elem_value *ucontrol)
3252 {
3253         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3254         int idx = kcontrol->private_value;
3255         struct hda_spdif_out *spdif;
3256         hda_nid_t nid;
3257         unsigned short val;
3258         int change;
3259
3260         mutex_lock(&codec->spdif_mutex);
3261         spdif = snd_array_elem(&codec->spdif_out, idx);
3262         nid = spdif->nid;
3263         val = spdif->ctls & ~AC_DIG1_ENABLE;
3264         if (ucontrol->value.integer.value[0])
3265                 val |= AC_DIG1_ENABLE;
3266         change = spdif->ctls != val;
3267         spdif->ctls = val;
3268         if (change && nid != (u16)-1)
3269                 set_spdif_ctls(codec, nid, val & 0xff, -1);
3270         mutex_unlock(&codec->spdif_mutex);
3271         return change;
3272 }
3273
3274 int snd_hda_max_pcm_ch_info(struct snd_kcontrol *kcontrol,
3275                 struct snd_ctl_elem_info *uinfo)
3276 {
3277         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3278         uinfo->count = 1;
3279         uinfo->value.integer.min = 0;
3280         uinfo->value.integer.max = 0xFFFFFFFF;
3281         return 0;
3282 }
3283
3284 int snd_hda_hdmi_decode_info(struct snd_kcontrol *kcontrol,
3285                                 struct snd_ctl_elem_info *uinfo)
3286 {
3287         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3288         uinfo->count = 1;
3289         uinfo->value.integer.min = 0;
3290         uinfo->value.integer.max = 0xFFFFFFFF;
3291         return 0;
3292 }
3293
3294 static int snd_hda_max_pcm_ch_get(struct snd_kcontrol *kcontrol,
3295                 struct snd_ctl_elem_value *ucontrol)
3296 {
3297         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3298
3299         ucontrol->value.integer.value[0] = codec->max_pcm_channels;
3300         return 0;
3301 }
3302
3303 static int snd_hda_hdmi_decode_get(struct snd_kcontrol *kcontrol,
3304                                         struct snd_ctl_elem_value *ucontrol)
3305 {
3306         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3307
3308         ucontrol->value.integer.value[0] = codec->recv_dec_cap;
3309         return 0;
3310 }
3311
3312 static struct snd_kcontrol_new dig_mixes[] = {
3313         {
3314                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3315                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3316                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3317                 .info = snd_hda_spdif_mask_info,
3318                 .get = snd_hda_spdif_cmask_get,
3319         },
3320         {
3321                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3322                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3323                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3324                 .info = snd_hda_spdif_mask_info,
3325                 .get = snd_hda_spdif_pmask_get,
3326         },
3327         {
3328                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3329                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3330                 .info = snd_hda_spdif_mask_info,
3331                 .get = snd_hda_spdif_default_get,
3332                 .put = snd_hda_spdif_default_put,
3333         },
3334         {
3335                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3336                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3337                 .info = snd_hda_spdif_out_switch_info,
3338                 .get = snd_hda_spdif_out_switch_get,
3339                 .put = snd_hda_spdif_out_switch_put,
3340         },
3341         {
3342                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3343                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3344                 .name = "HDA Decode Capability",
3345                 .info = snd_hda_hdmi_decode_info,
3346                 .get = snd_hda_hdmi_decode_get,
3347         },
3348         {
3349                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3350                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3351                 .name = "HDA Maximum PCM Channels",
3352                 .info = snd_hda_max_pcm_ch_info,
3353                 .get = snd_hda_max_pcm_ch_get,
3354         },
3355         { } /* end */
3356 };
3357
3358 /**
3359  * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
3360  * @codec: the HDA codec
3361  * @associated_nid: NID that new ctls associated with
3362  * @cvt_nid: converter NID
3363  * @type: HDA_PCM_TYPE_*
3364  * Creates controls related with the digital output.
3365  * Called from each patch supporting the digital out.
3366  *
3367  * Returns 0 if successful, or a negative error code.
3368  */
3369 int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
3370                                 hda_nid_t associated_nid,
3371                                 hda_nid_t cvt_nid,
3372                                 int type)
3373 {
3374         int err;
3375         struct snd_kcontrol *kctl;
3376         struct snd_kcontrol_new *dig_mix;
3377         int idx = 0;
3378         const int spdif_index = 16;
3379         struct hda_spdif_out *spdif;
3380         struct hda_bus *bus = codec->bus;
3381
3382         if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
3383             type == HDA_PCM_TYPE_SPDIF) {
3384                 idx = spdif_index;
3385         } else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
3386                    type == HDA_PCM_TYPE_HDMI) {
3387                 /* suppose a single SPDIF device */
3388                 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3389                         kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
3390                         if (!kctl)
3391                                 break;
3392                         kctl->id.index = spdif_index;
3393                 }
3394                 bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
3395         }
3396         if (!bus->primary_dig_out_type)
3397                 bus->primary_dig_out_type = type;
3398
3399         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
3400         if (idx < 0) {
3401                 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3402                 return -EBUSY;
3403         }
3404         spdif = snd_array_new(&codec->spdif_out);
3405         if (!spdif)
3406                 return -ENOMEM;
3407         for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3408                 kctl = snd_ctl_new1(dig_mix, codec);
3409                 if (!kctl)
3410                         return -ENOMEM;
3411                 kctl->id.index = idx;
3412                 kctl->private_value = codec->spdif_out.used - 1;
3413                 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3414                 if (err < 0)
3415                         return err;
3416         }
3417         spdif->nid = cvt_nid;
3418         spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3419                                          AC_VERB_GET_DIGI_CONVERT_1, 0);
3420         spdif->status = convert_to_spdif_status(spdif->ctls);
3421         return 0;
3422 }
3423 EXPORT_SYMBOL_HDA(snd_hda_create_dig_out_ctls);
3424
3425 /* get the hda_spdif_out entry from the given NID
3426  * call within spdif_mutex lock
3427  */
3428 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3429                                                hda_nid_t nid)
3430 {
3431         int i;
3432         for (i = 0; i < codec->spdif_out.used; i++) {
3433                 struct hda_spdif_out *spdif =
3434                                 snd_array_elem(&codec->spdif_out, i);
3435                 if (spdif->nid == nid)
3436                         return spdif;
3437         }
3438         return NULL;
3439 }
3440 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3441
3442 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3443 {
3444         struct hda_spdif_out *spdif;
3445
3446         mutex_lock(&codec->spdif_mutex);
3447         spdif = snd_array_elem(&codec->spdif_out, idx);
3448         spdif->nid = (u16)-1;
3449         mutex_unlock(&codec->spdif_mutex);
3450 }
3451 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3452
3453 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3454 {
3455         struct hda_spdif_out *spdif;
3456         unsigned short val;
3457
3458         mutex_lock(&codec->spdif_mutex);
3459         spdif = snd_array_elem(&codec->spdif_out, idx);
3460         if (spdif->nid != nid) {
3461                 spdif->nid = nid;
3462                 val = spdif->ctls;
3463                 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3464         }
3465         mutex_unlock(&codec->spdif_mutex);
3466 }
3467 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3468
3469 /*
3470  * SPDIF sharing with analog output
3471  */
3472 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3473                               struct snd_ctl_elem_value *ucontrol)
3474 {
3475         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3476         ucontrol->value.integer.value[0] = mout->share_spdif;
3477         return 0;
3478 }
3479
3480 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3481                               struct snd_ctl_elem_value *ucontrol)
3482 {
3483         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3484         mout->share_spdif = !!ucontrol->value.integer.value[0];
3485         return 0;
3486 }
3487
3488 static struct snd_kcontrol_new spdif_share_sw = {
3489         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3490         .name = "IEC958 Default PCM Playback Switch",
3491         .info = snd_ctl_boolean_mono_info,
3492         .get = spdif_share_sw_get,
3493         .put = spdif_share_sw_put,
3494 };
3495
3496 /**
3497  * snd_hda_create_spdif_share_sw - create Default PCM switch
3498  * @codec: the HDA codec
3499  * @mout: multi-out instance
3500  */
3501 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3502                                   struct hda_multi_out *mout)
3503 {
3504         struct snd_kcontrol *kctl;
3505
3506         if (!mout->dig_out_nid)
3507                 return 0;
3508
3509         kctl = snd_ctl_new1(&spdif_share_sw, mout);
3510         if (!kctl)
3511                 return -ENOMEM;
3512         /* ATTENTION: here mout is passed as private_data, instead of codec */
3513         return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
3514 }
3515 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3516
3517 /*
3518  * SPDIF input
3519  */
3520
3521 #define snd_hda_spdif_in_switch_info    snd_hda_spdif_out_switch_info
3522
3523 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3524                                        struct snd_ctl_elem_value *ucontrol)
3525 {
3526         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3527
3528         ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3529         return 0;
3530 }
3531
3532 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3533                                        struct snd_ctl_elem_value *ucontrol)
3534 {
3535         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3536         hda_nid_t nid = kcontrol->private_value;
3537         unsigned int val = !!ucontrol->value.integer.value[0];
3538         int change;
3539
3540         mutex_lock(&codec->spdif_mutex);
3541         change = codec->spdif_in_enable != val;
3542         if (change) {
3543                 codec->spdif_in_enable = val;
3544                 snd_hda_codec_write_cache(codec, nid, 0,
3545                                           AC_VERB_SET_DIGI_CONVERT_1, val);
3546         }
3547         mutex_unlock(&codec->spdif_mutex);
3548         return change;
3549 }
3550
3551 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3552                                        struct snd_ctl_elem_value *ucontrol)
3553 {
3554         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3555         hda_nid_t nid = kcontrol->private_value;
3556         unsigned short val;
3557         unsigned int sbits;
3558
3559         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3560         sbits = convert_to_spdif_status(val);
3561         ucontrol->value.iec958.status[0] = sbits;
3562         ucontrol->value.iec958.status[1] = sbits >> 8;
3563         ucontrol->value.iec958.status[2] = sbits >> 16;
3564         ucontrol->value.iec958.status[3] = sbits >> 24;
3565         return 0;
3566 }
3567
3568 static struct snd_kcontrol_new dig_in_ctls[] = {
3569         {
3570                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3571                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3572                 .info = snd_hda_spdif_in_switch_info,
3573                 .get = snd_hda_spdif_in_switch_get,
3574                 .put = snd_hda_spdif_in_switch_put,
3575         },
3576         {
3577                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3578                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3579                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3580                 .info = snd_hda_spdif_mask_info,
3581                 .get = snd_hda_spdif_in_status_get,
3582         },
3583         { } /* end */
3584 };
3585
3586 /**
3587  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3588  * @codec: the HDA codec
3589  * @nid: audio in widget NID
3590  *
3591  * Creates controls related with the SPDIF input.
3592  * Called from each patch supporting the SPDIF in.
3593  *
3594  * Returns 0 if successful, or a negative error code.
3595  */
3596 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3597 {
3598         int err;
3599         struct snd_kcontrol *kctl;
3600         struct snd_kcontrol_new *dig_mix;
3601         int idx;
3602
3603         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
3604         if (idx < 0) {
3605                 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3606                 return -EBUSY;
3607         }
3608         for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3609                 kctl = snd_ctl_new1(dig_mix, codec);
3610                 if (!kctl)
3611                         return -ENOMEM;
3612                 kctl->private_value = nid;
3613                 err = snd_hda_ctl_add(codec, nid, kctl);
3614                 if (err < 0)
3615                         return err;
3616         }
3617         codec->spdif_in_enable =
3618                 snd_hda_codec_read(codec, nid, 0,
3619                                    AC_VERB_GET_DIGI_CONVERT_1, 0) &
3620                 AC_DIG1_ENABLE;
3621         return 0;
3622 }
3623 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3624
3625 /*
3626  * command cache
3627  */
3628
3629 /* build a 31bit cache key with the widget id and the command parameter */
3630 #define build_cmd_cache_key(nid, verb)  ((verb << 8) | nid)
3631 #define get_cmd_cache_nid(key)          ((key) & 0xff)
3632 #define get_cmd_cache_cmd(key)          (((key) >> 8) & 0xffff)
3633
3634 /**
3635  * snd_hda_codec_write_cache - send a single command with caching
3636  * @codec: the HDA codec
3637  * @nid: NID to send the command
3638  * @direct: direct flag
3639  * @verb: the verb to send
3640  * @parm: the parameter for the verb
3641  *
3642  * Send a single command without waiting for response.
3643  *
3644  * Returns 0 if successful, or a negative error code.
3645  */
3646 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3647                               int direct, unsigned int verb, unsigned int parm)
3648 {
3649         int err;
3650         struct hda_cache_head *c;
3651         u32 key;
3652         unsigned int cache_only;
3653
3654         cache_only = codec->cached_write;
3655         if (!cache_only) {
3656                 err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3657                 if (err < 0)
3658                         return err;
3659         }
3660
3661         /* parm may contain the verb stuff for get/set amp */
3662         verb = verb | (parm >> 8);
3663         parm &= 0xff;
3664         key = build_cmd_cache_key(nid, verb);
3665         mutex_lock(&codec->bus->cmd_mutex);
3666         c = get_alloc_hash(&codec->cmd_cache, key);
3667         if (c) {
3668                 c->val = parm;
3669                 c->dirty = cache_only;
3670         }
3671         mutex_unlock(&codec->bus->cmd_mutex);
3672         return 0;
3673 }
3674 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3675
3676 /**
3677  * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3678  * @codec: the HDA codec
3679  * @nid: NID to send the command
3680  * @direct: direct flag
3681  * @verb: the verb to send
3682  * @parm: the parameter for the verb
3683  *
3684  * This function works like snd_hda_codec_write_cache(), but it doesn't send
3685  * command if the parameter is already identical with the cached value.
3686  * If not, it sends the command and refreshes the cache.
3687  *
3688  * Returns 0 if successful, or a negative error code.
3689  */
3690 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3691                                int direct, unsigned int verb, unsigned int parm)
3692 {
3693         struct hda_cache_head *c;
3694         u32 key;
3695
3696         /* parm may contain the verb stuff for get/set amp */
3697         verb = verb | (parm >> 8);
3698         parm &= 0xff;
3699         key = build_cmd_cache_key(nid, verb);
3700         mutex_lock(&codec->bus->cmd_mutex);
3701         c = get_hash(&codec->cmd_cache, key);
3702         if (c && c->val == parm) {
3703                 mutex_unlock(&codec->bus->cmd_mutex);
3704                 return 0;
3705         }
3706         mutex_unlock(&codec->bus->cmd_mutex);
3707         return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3708 }
3709 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3710
3711 /**
3712  * snd_hda_codec_resume_cache - Resume the all commands from the cache
3713  * @codec: HD-audio codec
3714  *
3715  * Execute all verbs recorded in the command caches to resume.
3716  */
3717 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3718 {
3719         int i;
3720
3721         mutex_lock(&codec->hash_mutex);
3722         codec->cached_write = 0;
3723         for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3724                 struct hda_cache_head *buffer;
3725                 u32 key;
3726
3727                 buffer = snd_array_elem(&codec->cmd_cache.buf, i);
3728                 key = buffer->key;
3729                 if (!key)
3730                         continue;
3731                 if (!buffer->dirty)
3732                         continue;
3733                 buffer->dirty = 0;
3734                 mutex_unlock(&codec->hash_mutex);
3735                 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3736                                     get_cmd_cache_cmd(key), buffer->val);
3737                 mutex_lock(&codec->hash_mutex);
3738         }
3739         mutex_unlock(&codec->hash_mutex);
3740 }
3741 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3742
3743 /**
3744  * snd_hda_sequence_write_cache - sequence writes with caching
3745  * @codec: the HDA codec
3746  * @seq: VERB array to send
3747  *
3748  * Send the commands sequentially from the given array.
3749  * Thte commands are recorded on cache for power-save and resume.
3750  * The array must be terminated with NID=0.
3751  */
3752 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3753                                   const struct hda_verb *seq)
3754 {
3755         for (; seq->nid; seq++)
3756                 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3757                                           seq->param);
3758 }
3759 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3760
3761 /**
3762  * snd_hda_codec_flush_cache - Execute all pending (cached) amps / verbs
3763  * @codec: HD-audio codec
3764  */
3765 void snd_hda_codec_flush_cache(struct hda_codec *codec)
3766 {
3767         snd_hda_codec_resume_amp(codec);
3768         snd_hda_codec_resume_cache(codec);
3769 }
3770 EXPORT_SYMBOL_HDA(snd_hda_codec_flush_cache);
3771
3772 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3773                                     unsigned int power_state)
3774 {
3775         hda_nid_t nid = codec->start_nid;
3776         int i;
3777
3778         for (i = 0; i < codec->num_nodes; i++, nid++) {
3779                 unsigned int wcaps = get_wcaps(codec, nid);
3780                 unsigned int state = power_state;
3781                 if (!(wcaps & AC_WCAP_POWER))
3782                         continue;
3783                 if (codec->power_filter) {
3784                         state = codec->power_filter(codec, nid, power_state);
3785                         if (state != power_state && power_state == AC_PWRST_D3)
3786                                 continue;
3787                 }
3788                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3789                                     state);
3790         }
3791 }
3792 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3793
3794 /*
3795  *  supported power states check
3796  */
3797 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
3798                                 unsigned int power_state)
3799 {
3800         int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
3801
3802         if (sup == -1)
3803                 return false;
3804         if (sup & power_state)
3805                 return true;
3806         else
3807                 return false;
3808 }
3809
3810 /*
3811  * wait until the state is reached, returns the current state
3812  */
3813 static unsigned int hda_sync_power_state(struct hda_codec *codec,
3814                                          hda_nid_t fg,
3815                                          unsigned int power_state)
3816 {
3817         unsigned long end_time = jiffies + msecs_to_jiffies(500);
3818         unsigned int state, actual_state;
3819
3820         for (;;) {
3821                 state = snd_hda_codec_read(codec, fg, 0,
3822                                            AC_VERB_GET_POWER_STATE, 0);
3823                 if (state & AC_PWRST_ERROR)
3824                         break;
3825                 actual_state = (state >> 4) & 0x0f;
3826                 if (actual_state == power_state)
3827                         break;
3828                 if (time_after_eq(jiffies, end_time))
3829                         break;
3830                 /* wait until the codec reachs to the target state */
3831                 mdelay(1);
3832         }
3833         return state;
3834 }
3835
3836 /* don't power down the widget if it controls eapd and EAPD_BTLENABLE is set */
3837 unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
3838                                              hda_nid_t nid,
3839                                              unsigned int power_state)
3840 {
3841         if (power_state == AC_PWRST_D3 &&
3842             get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
3843             (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3844                 int eapd = snd_hda_codec_read(codec, nid, 0,
3845                                               AC_VERB_GET_EAPD_BTLENABLE, 0);
3846                 if (eapd & 0x02)
3847                         return AC_PWRST_D0;
3848         }
3849         return power_state;
3850 }
3851 EXPORT_SYMBOL_HDA(snd_hda_codec_eapd_power_filter);
3852
3853 /*
3854  * set power state of the codec, and return the power state
3855  */
3856 static unsigned int hda_set_power_state(struct hda_codec *codec,
3857                                         unsigned int power_state)
3858 {
3859         hda_nid_t fg = codec->afg ? codec->afg : codec->mfg;
3860         int count;
3861         unsigned int state;
3862
3863         /* this delay seems necessary to avoid click noise at power-down */
3864         if (power_state == AC_PWRST_D3) {
3865                 /* transition time less than 10ms for power down */
3866                 msleep(codec->epss ? 10 : 100);
3867         }
3868
3869         /* repeat power states setting at most 10 times*/
3870         for (count = 0; count < 10; count++) {
3871                 if (codec->patch_ops.set_power_state)
3872                         codec->patch_ops.set_power_state(codec, fg,
3873                                                          power_state);
3874                 else {
3875                         snd_hda_codec_read(codec, fg, 0,
3876                                            AC_VERB_SET_POWER_STATE,
3877                                            power_state);
3878                         snd_hda_codec_set_power_to_all(codec, fg, power_state);
3879                 }
3880                 state = hda_sync_power_state(codec, fg, power_state);
3881                 if (!(state & AC_PWRST_ERROR))
3882                         break;
3883         }
3884
3885         return state;
3886 }
3887
3888 /* sync power states of all widgets;
3889  * this is called at the end of codec parsing
3890  */
3891 static void sync_power_up_states(struct hda_codec *codec)
3892 {
3893         hda_nid_t nid = codec->start_nid;
3894         int i;
3895
3896         /* don't care if no filter is used */
3897         if (!codec->power_filter)
3898                 return;
3899
3900         for (i = 0; i < codec->num_nodes; i++, nid++) {
3901                 unsigned int wcaps = get_wcaps(codec, nid);
3902                 unsigned int target;
3903                 if (!(wcaps & AC_WCAP_POWER))
3904                         continue;
3905                 target = codec->power_filter(codec, nid, AC_PWRST_D0);
3906                 if (target == AC_PWRST_D0)
3907                         continue;
3908                 if (!snd_hda_check_power_state(codec, nid, target))
3909                         snd_hda_codec_write(codec, nid, 0,
3910                                             AC_VERB_SET_POWER_STATE, target);
3911         }
3912 }
3913
3914 #ifdef CONFIG_SND_HDA_HWDEP
3915 /* execute additional init verbs */
3916 static void hda_exec_init_verbs(struct hda_codec *codec)
3917 {
3918         if (codec->init_verbs.list)
3919                 snd_hda_sequence_write(codec, codec->init_verbs.list);
3920 }
3921 #else
3922 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3923 #endif
3924
3925 #ifdef CONFIG_PM
3926 /*
3927  * call suspend and power-down; used both from PM and power-save
3928  * this function returns the power state in the end
3929  */
3930 static unsigned int hda_call_codec_suspend(struct hda_codec *codec, bool in_wq)
3931 {
3932         unsigned int state;
3933
3934         codec->in_pm = 1;
3935
3936         if (codec->patch_ops.suspend)
3937                 codec->patch_ops.suspend(codec);
3938         hda_cleanup_all_streams(codec);
3939         state = hda_set_power_state(codec, AC_PWRST_D3);
3940         /* Cancel delayed work if we aren't currently running from it. */
3941         if (!in_wq)
3942                 cancel_delayed_work_sync(&codec->power_work);
3943         spin_lock(&codec->power_lock);
3944         snd_hda_update_power_acct(codec);
3945         trace_hda_power_down(codec);
3946         codec->power_on = 0;
3947         codec->power_transition = 0;
3948         codec->power_jiffies = jiffies;
3949         spin_unlock(&codec->power_lock);
3950         codec->in_pm = 0;
3951 #ifdef CONFIG_SND_HDA_PLATFORM_NVIDIA_TEGRA
3952         state |= AC_PWRST_CLK_STOP_OK;
3953 #endif
3954         return state;
3955 }
3956
3957 /* mark all entries of cmd and amp caches dirty */
3958 static void hda_mark_cmd_cache_dirty(struct hda_codec *codec)
3959 {
3960         int i;
3961         for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3962                 struct hda_cache_head *cmd;
3963                 cmd = snd_array_elem(&codec->cmd_cache.buf, i);
3964                 cmd->dirty = 1;
3965         }
3966         for (i = 0; i < codec->amp_cache.buf.used; i++) {
3967                 struct hda_amp_info *amp;
3968                 amp = snd_array_elem(&codec->amp_cache.buf, i);
3969                 amp->head.dirty = 1;
3970         }
3971 }
3972
3973 /*
3974  * kick up codec; used both from PM and power-save
3975  */
3976 static void hda_call_codec_resume(struct hda_codec *codec)
3977 {
3978         codec->in_pm = 1;
3979
3980         hda_mark_cmd_cache_dirty(codec);
3981
3982         /* set as if powered on for avoiding re-entering the resume
3983          * in the resume / power-save sequence
3984          */
3985         hda_keep_power_on(codec);
3986         if (codec->pm_down_notified) {
3987                 codec->pm_down_notified = 0;
3988                 hda_call_pm_notify(codec->bus, true);
3989         }
3990         hda_set_power_state(codec, AC_PWRST_D0);
3991         restore_shutup_pins(codec);
3992         hda_exec_init_verbs(codec);
3993         snd_hda_jack_set_dirty_all(codec);
3994         if (codec->patch_ops.resume)
3995                 codec->patch_ops.resume(codec);
3996         else {
3997                 if (codec->patch_ops.init)
3998                         codec->patch_ops.init(codec);
3999                 snd_hda_codec_resume_amp(codec);
4000                 snd_hda_codec_resume_cache(codec);
4001         }
4002
4003         if (codec->jackpoll_interval)
4004                 hda_jackpoll_work(&codec->jackpoll_work.work);
4005         else
4006                 snd_hda_jack_report_sync(codec);
4007
4008         codec->in_pm = 0;
4009         snd_hda_power_down(codec); /* flag down before returning */
4010 }
4011 #endif /* CONFIG_PM */
4012
4013
4014 /**
4015  * snd_hda_build_controls - build mixer controls
4016  * @bus: the BUS
4017  *
4018  * Creates mixer controls for each codec included in the bus.
4019  *
4020  * Returns 0 if successful, otherwise a negative error code.
4021  */
4022 int snd_hda_build_controls(struct hda_bus *bus)
4023 {
4024         struct hda_codec *codec;
4025
4026         list_for_each_entry(codec, &bus->codec_list, list) {
4027                 int err = snd_hda_codec_build_controls(codec);
4028                 if (err < 0) {
4029                         printk(KERN_ERR "hda_codec: cannot build controls "
4030                                "for #%d (error %d)\n", codec->addr, err);
4031                         err = snd_hda_codec_reset(codec);
4032                         if (err < 0) {
4033                                 printk(KERN_ERR
4034                                        "hda_codec: cannot revert codec\n");
4035                                 return err;
4036                         }
4037                 }
4038         }
4039         return 0;
4040 }
4041 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
4042
4043 /*
4044  * add standard channel maps if not specified
4045  */
4046 static int add_std_chmaps(struct hda_codec *codec)
4047 {
4048         int i, str, err;
4049
4050         for (i = 0; i < codec->num_pcms; i++) {
4051                 for (str = 0; str < 2; str++) {
4052                         struct snd_pcm *pcm = codec->pcm_info[i].pcm;
4053                         struct hda_pcm_stream *hinfo =
4054                                 &codec->pcm_info[i].stream[str];
4055                         struct snd_pcm_chmap *chmap;
4056                         const struct snd_pcm_chmap_elem *elem;
4057
4058                         if (codec->pcm_info[i].own_chmap)
4059                                 continue;
4060                         if (!pcm || !hinfo->substreams)
4061                                 continue;
4062                         elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
4063                         err = snd_pcm_add_chmap_ctls(pcm, str, elem,
4064                                                      hinfo->channels_max,
4065                                                      0, &chmap);
4066                         if (err < 0)
4067                                 return err;
4068                         chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
4069                 }
4070         }
4071         return 0;
4072 }
4073
4074 /* default channel maps for 2.1 speakers;
4075  * since HD-audio supports only stereo, odd number channels are omitted
4076  */
4077 const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
4078         { .channels = 2,
4079           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
4080         { .channels = 4,
4081           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
4082                    SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
4083         { }
4084 };
4085 EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
4086
4087 int snd_hda_codec_build_controls(struct hda_codec *codec)
4088 {
4089         int err = 0;
4090         hda_exec_init_verbs(codec);
4091         /* continue to initialize... */
4092         if (codec->patch_ops.init)
4093                 err = codec->patch_ops.init(codec);
4094         if (!err && codec->patch_ops.build_controls)
4095                 err = codec->patch_ops.build_controls(codec);
4096         if (err < 0)
4097                 return err;
4098
4099         /* we create chmaps here instead of build_pcms */
4100         err = add_std_chmaps(codec);
4101         if (err < 0)
4102                 return err;
4103
4104         if (codec->jackpoll_interval)
4105                 hda_jackpoll_work(&codec->jackpoll_work.work);
4106         else
4107                 snd_hda_jack_report_sync(codec); /* call at the last init point */
4108         sync_power_up_states(codec);
4109         return 0;
4110 }
4111
4112 /*
4113  * stream formats
4114  */
4115 struct hda_rate_tbl {
4116         unsigned int hz;
4117         unsigned int alsa_bits;
4118         unsigned int hda_fmt;
4119 };
4120
4121 /* rate = base * mult / div */
4122 #define HDA_RATE(base, mult, div) \
4123         (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
4124          (((div) - 1) << AC_FMT_DIV_SHIFT))
4125
4126 static struct hda_rate_tbl rate_bits[] = {
4127         /* rate in Hz, ALSA rate bitmask, HDA format value */
4128
4129         /* autodetected value used in snd_hda_query_supported_pcm */
4130         { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
4131         { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
4132         { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
4133         { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
4134         { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
4135         { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
4136         { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
4137         { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
4138         { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
4139         { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
4140         { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
4141 #define AC_PAR_PCM_RATE_BITS    11
4142         /* up to bits 10, 384kHZ isn't supported properly */
4143
4144         /* not autodetected value */
4145         { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
4146
4147         { 0 } /* terminator */
4148 };
4149
4150 /**
4151  * snd_hda_calc_stream_format - calculate format bitset
4152  * @rate: the sample rate
4153  * @channels: the number of channels
4154  * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
4155  * @maxbps: the max. bps
4156  *
4157  * Calculate the format bitset from the given rate, channels and th PCM format.
4158  *
4159  * Return zero if invalid.
4160  */
4161 unsigned int snd_hda_calc_stream_format(unsigned int rate,
4162                                         unsigned int channels,
4163                                         unsigned int format,
4164                                         unsigned int maxbps,
4165                                         unsigned short spdif_ctls)
4166 {
4167         int i;
4168         unsigned int val = 0;
4169
4170         for (i = 0; rate_bits[i].hz; i++)
4171                 if (rate_bits[i].hz == rate) {
4172                         val = rate_bits[i].hda_fmt;
4173                         break;
4174                 }
4175         if (!rate_bits[i].hz) {
4176                 snd_printdd("invalid rate %d\n", rate);
4177                 return 0;
4178         }
4179
4180         if (channels == 0 || channels > 8) {
4181                 snd_printdd("invalid channels %d\n", channels);
4182                 return 0;
4183         }
4184         val |= channels - 1;
4185
4186         switch (snd_pcm_format_width(format)) {
4187         case 8:
4188                 val |= AC_FMT_BITS_8;
4189                 break;
4190         case 16:
4191                 val |= AC_FMT_BITS_16;
4192                 break;
4193         case 20:
4194         case 24:
4195         case 32:
4196                 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
4197                         val |= AC_FMT_BITS_32;
4198                 else if (maxbps >= 24)
4199                         val |= AC_FMT_BITS_24;
4200                 else
4201                         val |= AC_FMT_BITS_20;
4202                 break;
4203         default:
4204                 snd_printdd("invalid format width %d\n",
4205                             snd_pcm_format_width(format));
4206                 return 0;
4207         }
4208
4209         if (spdif_ctls & AC_DIG1_NONAUDIO)
4210                 val |= AC_FMT_TYPE_NON_PCM;
4211
4212         return val;
4213 }
4214 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
4215
4216 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
4217                                   int dir)
4218 {
4219         unsigned int val = 0;
4220         if (nid != codec->afg &&
4221             (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
4222                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
4223         if (!val || val == -1)
4224                 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
4225         if (!val || val == -1)
4226                 return 0;
4227         return val;
4228 }
4229
4230 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
4231 {
4232         return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
4233                                get_pcm_param);
4234 }
4235
4236 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
4237                                      int dir)
4238 {
4239         unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
4240         if (!streams || streams == -1)
4241                 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
4242         if (!streams || streams == -1)
4243                 return 0;
4244         return streams;
4245 }
4246
4247 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
4248 {
4249         return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
4250                                get_stream_param);
4251 }
4252
4253 /**
4254  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
4255  * @codec: the HDA codec
4256  * @nid: NID to query
4257  * @ratesp: the pointer to store the detected rate bitflags
4258  * @formatsp: the pointer to store the detected formats
4259  * @bpsp: the pointer to store the detected format widths
4260  *
4261  * Queries the supported PCM rates and formats.  The NULL @ratesp, @formatsp
4262  * or @bsps argument is ignored.
4263  *
4264  * Returns 0 if successful, otherwise a negative error code.
4265  */
4266 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
4267                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
4268 {
4269         unsigned int i, val, wcaps;
4270
4271         wcaps = get_wcaps(codec, nid);
4272         val = query_pcm_param(codec, nid);
4273
4274         if (ratesp) {
4275                 u32 rates = 0;
4276                 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
4277                         if (val & (1 << i))
4278                                 rates |= rate_bits[i].alsa_bits;
4279                 }
4280                 if (rates == 0) {
4281                         snd_printk(KERN_ERR "hda_codec: rates == 0 "
4282                                    "(nid=0x%x, val=0x%x, ovrd=%i)\n",
4283                                         nid, val,
4284                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
4285                         return -EIO;
4286                 }
4287                 *ratesp = rates;
4288         }
4289
4290         if (formatsp || bpsp) {
4291                 u64 formats = 0;
4292                 unsigned int streams, bps;
4293
4294                 streams = query_stream_param(codec, nid);
4295                 if (!streams)
4296                         return -EIO;
4297
4298                 bps = 0;
4299                 if (streams & AC_SUPFMT_PCM) {
4300                         if (val & AC_SUPPCM_BITS_8) {
4301                                 formats |= SNDRV_PCM_FMTBIT_U8;
4302                                 bps = 8;
4303                         }
4304                         if (val & AC_SUPPCM_BITS_16) {
4305                                 formats |= SNDRV_PCM_FMTBIT_S16_LE;
4306                                 bps = 16;
4307                         }
4308                         if (wcaps & AC_WCAP_DIGITAL) {
4309                                 if (val & AC_SUPPCM_BITS_32)
4310                                         formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
4311                                 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
4312                                         formats |= SNDRV_PCM_FMTBIT_S32_LE;
4313                                 if (val & AC_SUPPCM_BITS_24)
4314                                         bps = 24;
4315                                 else if (val & AC_SUPPCM_BITS_20)
4316                                         bps = 20;
4317                         } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
4318                                           AC_SUPPCM_BITS_32)) {
4319                                 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4320                                 if (val & AC_SUPPCM_BITS_32)
4321                                         bps = 32;
4322                                 else if (val & AC_SUPPCM_BITS_24)
4323                                         bps = 24;
4324                                 else if (val & AC_SUPPCM_BITS_20)
4325                                         bps = 20;
4326                         }
4327                 }
4328 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
4329                 if (streams & AC_SUPFMT_FLOAT32) {
4330                         formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
4331                         if (!bps)
4332                                 bps = 32;
4333                 }
4334 #endif
4335                 if (streams == AC_SUPFMT_AC3) {
4336                         /* should be exclusive */
4337                         /* temporary hack: we have still no proper support
4338                          * for the direct AC3 stream...
4339                          */
4340                         formats |= SNDRV_PCM_FMTBIT_U8;
4341                         bps = 8;
4342                 }
4343                 if (formats == 0) {
4344                         snd_printk(KERN_ERR "hda_codec: formats == 0 "
4345                                    "(nid=0x%x, val=0x%x, ovrd=%i, "
4346                                    "streams=0x%x)\n",
4347                                         nid, val,
4348                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
4349                                         streams);
4350                         return -EIO;
4351                 }
4352                 if (formatsp)
4353                         *formatsp = formats;
4354                 if (bpsp)
4355                         *bpsp = bps;
4356         }
4357
4358         return 0;
4359 }
4360 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
4361
4362 /**
4363  * snd_hda_is_supported_format - Check the validity of the format
4364  * @codec: HD-audio codec
4365  * @nid: NID to check
4366  * @format: the HD-audio format value to check
4367  *
4368  * Check whether the given node supports the format value.
4369  *
4370  * Returns 1 if supported, 0 if not.
4371  */
4372 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
4373                                 unsigned int format)
4374 {
4375         int i;
4376         unsigned int val = 0, rate, stream;
4377
4378         val = query_pcm_param(codec, nid);
4379         if (!val)
4380                 return 0;
4381
4382         rate = format & 0xff00;
4383         for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
4384                 if (rate_bits[i].hda_fmt == rate) {
4385                         if (val & (1 << i))
4386                                 break;
4387                         return 0;
4388                 }
4389         if (i >= AC_PAR_PCM_RATE_BITS)
4390                 return 0;
4391
4392         stream = query_stream_param(codec, nid);
4393         if (!stream)
4394                 return 0;
4395
4396         if (stream & AC_SUPFMT_PCM) {
4397                 switch (format & 0xf0) {
4398                 case 0x00:
4399                         if (!(val & AC_SUPPCM_BITS_8))
4400                                 return 0;
4401                         break;
4402                 case 0x10:
4403                         if (!(val & AC_SUPPCM_BITS_16))
4404                                 return 0;
4405                         break;
4406                 case 0x20:
4407                         if (!(val & AC_SUPPCM_BITS_20))
4408                                 return 0;
4409                         break;
4410                 case 0x30:
4411                         if (!(val & AC_SUPPCM_BITS_24))
4412                                 return 0;
4413                         break;
4414                 case 0x40:
4415                         if (!(val & AC_SUPPCM_BITS_32))
4416                                 return 0;
4417                         break;
4418                 default:
4419                         return 0;
4420                 }
4421         } else {
4422                 /* FIXME: check for float32 and AC3? */
4423         }
4424
4425         return 1;
4426 }
4427 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
4428
4429 /*
4430  * PCM stuff
4431  */
4432 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
4433                                       struct hda_codec *codec,
4434                                       struct snd_pcm_substream *substream)
4435 {
4436         return 0;
4437 }
4438
4439 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
4440                                    struct hda_codec *codec,
4441                                    unsigned int stream_tag,
4442                                    unsigned int format,
4443                                    struct snd_pcm_substream *substream)
4444 {
4445         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4446         return 0;
4447 }
4448
4449 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
4450                                    struct hda_codec *codec,
4451                                    struct snd_pcm_substream *substream)
4452 {
4453         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4454         return 0;
4455 }
4456
4457 static int set_pcm_default_values(struct hda_codec *codec,
4458                                   struct hda_pcm_stream *info)
4459 {
4460         int err;
4461
4462         /* query support PCM information from the given NID */
4463         if (info->nid && (!info->rates || !info->formats)) {
4464                 err = snd_hda_query_supported_pcm(codec, info->nid,
4465                                 info->rates ? NULL : &info->rates,
4466                                 info->formats ? NULL : &info->formats,
4467                                 info->maxbps ? NULL : &info->maxbps);
4468                 if (err < 0)
4469                         return err;
4470         }
4471         if (info->ops.open == NULL)
4472                 info->ops.open = hda_pcm_default_open_close;
4473         if (info->ops.close == NULL)
4474                 info->ops.close = hda_pcm_default_open_close;
4475         if (info->ops.prepare == NULL) {
4476                 if (snd_BUG_ON(!info->nid))
4477                         return -EINVAL;
4478                 info->ops.prepare = hda_pcm_default_prepare;
4479         }
4480         if (info->ops.cleanup == NULL) {
4481                 if (snd_BUG_ON(!info->nid))
4482                         return -EINVAL;
4483                 info->ops.cleanup = hda_pcm_default_cleanup;
4484         }
4485         return 0;
4486 }
4487
4488 /*
4489  * codec prepare/cleanup entries
4490  */
4491 int snd_hda_codec_prepare(struct hda_codec *codec,
4492                           struct hda_pcm_stream *hinfo,
4493                           unsigned int stream,
4494                           unsigned int format,
4495                           struct snd_pcm_substream *substream)
4496 {
4497         int ret;
4498         mutex_lock(&codec->bus->prepare_mutex);
4499         ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4500         if (ret >= 0)
4501                 purify_inactive_streams(codec);
4502         mutex_unlock(&codec->bus->prepare_mutex);
4503         return ret;
4504 }
4505 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
4506
4507 void snd_hda_codec_cleanup(struct hda_codec *codec,
4508                            struct hda_pcm_stream *hinfo,
4509                            struct snd_pcm_substream *substream)
4510 {
4511         mutex_lock(&codec->bus->prepare_mutex);
4512         hinfo->ops.cleanup(hinfo, codec, substream);
4513         mutex_unlock(&codec->bus->prepare_mutex);
4514 }
4515 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
4516
4517 /* global */
4518 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4519         "Audio", "SPDIF", "HDMI", "Modem"
4520 };
4521
4522 /*
4523  * get the empty PCM device number to assign
4524  *
4525  * note the max device number is limited by HDA_MAX_PCMS, currently 10
4526  */
4527 static int get_empty_pcm_device(struct hda_bus *bus, int type)
4528 {
4529         /* audio device indices; not linear to keep compatibility */
4530         static int audio_idx[HDA_PCM_NTYPES][5] = {
4531                 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4532                 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
4533                 [HDA_PCM_TYPE_HDMI]  = { 3, 7, 8, 9, -1 },
4534                 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
4535         };
4536         int i;
4537
4538         if (type >= HDA_PCM_NTYPES) {
4539                 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4540                 return -EINVAL;
4541         }
4542
4543         for (i = 0; audio_idx[type][i] >= 0 ; i++)
4544                 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4545                         return audio_idx[type][i];
4546
4547         /* non-fixed slots starting from 10 */
4548         for (i = 10; i < 32; i++) {
4549                 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4550                         return i;
4551         }
4552
4553         snd_printk(KERN_WARNING "Too many %s devices\n",
4554                 snd_hda_pcm_type_name[type]);
4555         return -EAGAIN;
4556 }
4557
4558 /*
4559  * attach a new PCM stream
4560  */
4561 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4562 {
4563         struct hda_bus *bus = codec->bus;
4564         struct hda_pcm_stream *info;
4565         int stream, err;
4566
4567         if (snd_BUG_ON(!pcm->name))
4568                 return -EINVAL;
4569         for (stream = 0; stream < 2; stream++) {
4570                 info = &pcm->stream[stream];
4571                 if (info->substreams) {
4572                         err = set_pcm_default_values(codec, info);
4573                         if (err < 0)
4574                                 return err;
4575                 }
4576         }
4577         return bus->ops.attach_pcm(bus, codec, pcm);
4578 }
4579
4580 /* assign all PCMs of the given codec */
4581 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4582 {
4583         unsigned int pcm;
4584         int err;
4585
4586         if (!codec->num_pcms) {
4587                 if (!codec->patch_ops.build_pcms)
4588                         return 0;
4589                 err = codec->patch_ops.build_pcms(codec);
4590                 if (err < 0) {
4591                         printk(KERN_ERR "hda_codec: cannot build PCMs"
4592                                "for #%d (error %d)\n", codec->addr, err);
4593                         err = snd_hda_codec_reset(codec);
4594                         if (err < 0) {
4595                                 printk(KERN_ERR
4596                                        "hda_codec: cannot revert codec\n");
4597                                 return err;
4598                         }
4599                 }
4600         }
4601         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4602                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4603                 int dev;
4604
4605                 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4606                         continue; /* no substreams assigned */
4607
4608                 if (!cpcm->pcm) {
4609                         dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4610                         if (dev < 0)
4611                                 continue; /* no fatal error */
4612                         cpcm->device = dev;
4613                         err = snd_hda_attach_pcm(codec, cpcm);
4614                         if (err < 0) {
4615                                 printk(KERN_ERR "hda_codec: cannot attach "
4616                                        "PCM stream %d for codec #%d\n",
4617                                        dev, codec->addr);
4618                                 continue; /* no fatal error */
4619                         }
4620                 }
4621         }
4622         return 0;
4623 }
4624
4625 /**
4626  * snd_hda_build_pcms - build PCM information
4627  * @bus: the BUS
4628  *
4629  * Create PCM information for each codec included in the bus.
4630  *
4631  * The build_pcms codec patch is requested to set up codec->num_pcms and
4632  * codec->pcm_info properly.  The array is referred by the top-level driver
4633  * to create its PCM instances.
4634  * The allocated codec->pcm_info should be released in codec->patch_ops.free
4635  * callback.
4636  *
4637  * At least, substreams, channels_min and channels_max must be filled for
4638  * each stream.  substreams = 0 indicates that the stream doesn't exist.
4639  * When rates and/or formats are zero, the supported values are queried
4640  * from the given nid.  The nid is used also by the default ops.prepare
4641  * and ops.cleanup callbacks.
4642  *
4643  * The driver needs to call ops.open in its open callback.  Similarly,
4644  * ops.close is supposed to be called in the close callback.
4645  * ops.prepare should be called in the prepare or hw_params callback
4646  * with the proper parameters for set up.
4647  * ops.cleanup should be called in hw_free for clean up of streams.
4648  *
4649  * This function returns 0 if successful, or a negative error code.
4650  */
4651 int snd_hda_build_pcms(struct hda_bus *bus)
4652 {
4653         struct hda_codec *codec;
4654
4655         list_for_each_entry(codec, &bus->codec_list, list) {
4656                 int err = snd_hda_codec_build_pcms(codec);
4657                 if (err < 0)
4658                         return err;
4659         }
4660         return 0;
4661 }
4662 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
4663
4664 /**
4665  * snd_hda_check_board_config - compare the current codec with the config table
4666  * @codec: the HDA codec
4667  * @num_configs: number of config enums
4668  * @models: array of model name strings
4669  * @tbl: configuration table, terminated by null entries
4670  *
4671  * Compares the modelname or PCI subsystem id of the current codec with the
4672  * given configuration table.  If a matching entry is found, returns its
4673  * config value (supposed to be 0 or positive).
4674  *
4675  * If no entries are matching, the function returns a negative value.
4676  */
4677 int snd_hda_check_board_config(struct hda_codec *codec,
4678                                int num_configs, const char * const *models,
4679                                const struct snd_pci_quirk *tbl)
4680 {
4681         if (codec->modelname && models) {
4682                 int i;
4683                 for (i = 0; i < num_configs; i++) {
4684                         if (models[i] &&
4685                             !strcmp(codec->modelname, models[i])) {
4686                                 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4687                                            "selected\n", models[i]);
4688                                 return i;
4689                         }
4690                 }
4691         }
4692
4693         if (!codec->bus->pci || !tbl)
4694                 return -1;
4695
4696         tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4697         if (!tbl)
4698                 return -1;
4699         if (tbl->value >= 0 && tbl->value < num_configs) {
4700 #ifdef CONFIG_SND_DEBUG_VERBOSE
4701                 char tmp[10];
4702                 const char *model = NULL;
4703                 if (models)
4704                         model = models[tbl->value];
4705                 if (!model) {
4706                         sprintf(tmp, "#%d", tbl->value);
4707                         model = tmp;
4708                 }
4709                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4710                             "for config %x:%x (%s)\n",
4711                             model, tbl->subvendor, tbl->subdevice,
4712                             (tbl->name ? tbl->name : "Unknown device"));
4713 #endif
4714                 return tbl->value;
4715         }
4716         return -1;
4717 }
4718 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
4719
4720 /**
4721  * snd_hda_check_board_codec_sid_config - compare the current codec
4722                                         subsystem ID with the
4723                                         config table
4724
4725            This is important for Gateway notebooks with SB450 HDA Audio
4726            where the vendor ID of the PCI device is:
4727                 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4728            and the vendor/subvendor are found only at the codec.
4729
4730  * @codec: the HDA codec
4731  * @num_configs: number of config enums
4732  * @models: array of model name strings
4733  * @tbl: configuration table, terminated by null entries
4734  *
4735  * Compares the modelname or PCI subsystem id of the current codec with the
4736  * given configuration table.  If a matching entry is found, returns its
4737  * config value (supposed to be 0 or positive).
4738  *
4739  * If no entries are matching, the function returns a negative value.
4740  */
4741 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4742                                int num_configs, const char * const *models,
4743                                const struct snd_pci_quirk *tbl)
4744 {
4745         const struct snd_pci_quirk *q;
4746
4747         /* Search for codec ID */
4748         for (q = tbl; q->subvendor; q++) {
4749                 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4750                 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4751                 if ((codec->subsystem_id & mask) == id)
4752                         break;
4753         }
4754
4755         if (!q->subvendor)
4756                 return -1;
4757
4758         tbl = q;
4759
4760         if (tbl->value >= 0 && tbl->value < num_configs) {
4761 #ifdef CONFIG_SND_DEBUG_VERBOSE
4762                 char tmp[10];
4763                 const char *model = NULL;
4764                 if (models)
4765                         model = models[tbl->value];
4766                 if (!model) {
4767                         sprintf(tmp, "#%d", tbl->value);
4768                         model = tmp;
4769                 }
4770                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4771                             "for config %x:%x (%s)\n",
4772                             model, tbl->subvendor, tbl->subdevice,
4773                             (tbl->name ? tbl->name : "Unknown device"));
4774 #endif
4775                 return tbl->value;
4776         }
4777         return -1;
4778 }
4779 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4780
4781 /**
4782  * snd_hda_add_new_ctls - create controls from the array
4783  * @codec: the HDA codec
4784  * @knew: the array of struct snd_kcontrol_new
4785  *
4786  * This helper function creates and add new controls in the given array.
4787  * The array must be terminated with an empty entry as terminator.
4788  *
4789  * Returns 0 if successful, or a negative error code.
4790  */
4791 int snd_hda_add_new_ctls(struct hda_codec *codec,
4792                          const struct snd_kcontrol_new *knew)
4793 {
4794         int err;
4795
4796         for (; knew->name; knew++) {
4797                 struct snd_kcontrol *kctl;
4798                 int addr = 0, idx = 0;
4799                 if (knew->iface == -1)  /* skip this codec private value */
4800                         continue;
4801                 for (;;) {
4802                         kctl = snd_ctl_new1(knew, codec);
4803                         if (!kctl)
4804                                 return -ENOMEM;
4805                         if (addr > 0)
4806                                 kctl->id.device = addr;
4807                         if (idx > 0)
4808                                 kctl->id.index = idx;
4809                         err = snd_hda_ctl_add(codec, 0, kctl);
4810                         if (!err)
4811                                 break;
4812                         /* try first with another device index corresponding to
4813                          * the codec addr; if it still fails (or it's the
4814                          * primary codec), then try another control index
4815                          */
4816                         if (!addr && codec->addr)
4817                                 addr = codec->addr;
4818                         else if (!idx && !knew->index) {
4819                                 idx = find_empty_mixer_ctl_idx(codec,
4820                                                                knew->name, 0);
4821                                 if (idx <= 0)
4822                                         return err;
4823                         } else
4824                                 return err;
4825                 }
4826         }
4827         return 0;
4828 }
4829 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4830
4831 #ifdef CONFIG_PM
4832 static void hda_power_work(struct work_struct *work)
4833 {
4834         struct hda_codec *codec =
4835                 container_of(work, struct hda_codec, power_work.work);
4836         struct hda_bus *bus = codec->bus;
4837         unsigned int state;
4838
4839         spin_lock(&codec->power_lock);
4840         if (codec->power_transition > 0) { /* during power-up sequence? */
4841                 spin_unlock(&codec->power_lock);
4842                 return;
4843         }
4844         if (!codec->power_on || codec->power_count) {
4845                 codec->power_transition = 0;
4846                 spin_unlock(&codec->power_lock);
4847                 return;
4848         }
4849         spin_unlock(&codec->power_lock);
4850
4851         state = hda_call_codec_suspend(codec, true);
4852         if (!codec->pm_down_notified &&
4853             !bus->power_keep_link_on && (state & AC_PWRST_CLK_STOP_OK)) {
4854                 codec->pm_down_notified = 1;
4855                 hda_call_pm_notify(bus, false);
4856         }
4857 }
4858
4859 static void hda_keep_power_on(struct hda_codec *codec)
4860 {
4861         spin_lock(&codec->power_lock);
4862         codec->power_count++;
4863         codec->power_on = 1;
4864         codec->power_jiffies = jiffies;
4865         spin_unlock(&codec->power_lock);
4866 }
4867
4868 /* update the power on/off account with the current jiffies */
4869 void snd_hda_update_power_acct(struct hda_codec *codec)
4870 {
4871         unsigned long delta = jiffies - codec->power_jiffies;
4872         if (codec->power_on)
4873                 codec->power_on_acct += delta;
4874         else
4875                 codec->power_off_acct += delta;
4876         codec->power_jiffies += delta;
4877 }
4878
4879 /* Transition to powered up, if wait_power_down then wait for a pending
4880  * transition to D3 to complete. A pending D3 transition is indicated
4881  * with power_transition == -1. */
4882 /* call this with codec->power_lock held! */
4883 static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
4884 {
4885         struct hda_bus *bus = codec->bus;
4886
4887         /* Return if power_on or transitioning to power_on, unless currently
4888          * powering down. */
4889         if ((codec->power_on || codec->power_transition > 0) &&
4890             !(wait_power_down && codec->power_transition < 0))
4891                 return;
4892         spin_unlock(&codec->power_lock);
4893
4894         cancel_delayed_work_sync(&codec->power_work);
4895
4896         spin_lock(&codec->power_lock);
4897         /* If the power down delayed work was cancelled above before starting,
4898          * then there is no need to go through power up here.
4899          */
4900         if (codec->power_on) {
4901                 if (codec->power_transition < 0)
4902                         codec->power_transition = 0;
4903                 return;
4904         }
4905
4906         trace_hda_power_up(codec);
4907         snd_hda_update_power_acct(codec);
4908         codec->power_on = 1;
4909         codec->power_jiffies = jiffies;
4910         codec->power_transition = 1; /* avoid reentrance */
4911         spin_unlock(&codec->power_lock);
4912
4913         if (codec->pm_down_notified) {
4914                 codec->pm_down_notified = 0;
4915                 hda_call_pm_notify(bus, true);
4916         }
4917
4918         hda_call_codec_resume(codec);
4919
4920         spin_lock(&codec->power_lock);
4921         codec->power_transition = 0;
4922 }
4923
4924 #define power_save(codec)       \
4925         ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4926
4927 /* Transition to powered down */
4928 static void __snd_hda_power_down(struct hda_codec *codec)
4929 {
4930         if (!codec->power_on || codec->power_count || codec->power_transition)
4931                 return;
4932
4933         if (power_save(codec)) {
4934                 codec->power_transition = -1; /* avoid reentrance */
4935                 queue_delayed_work(codec->bus->workq, &codec->power_work,
4936                                 msecs_to_jiffies(power_save(codec) * 1000));
4937         }
4938 }
4939
4940 /**
4941  * snd_hda_power_save - Power-up/down/sync the codec
4942  * @codec: HD-audio codec
4943  * @delta: the counter delta to change
4944  *
4945  * Change the power-up counter via @delta, and power up or down the hardware
4946  * appropriately.  For the power-down, queue to the delayed action.
4947  * Passing zero to @delta means to synchronize the power state.
4948  */
4949 void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait)
4950 {
4951         spin_lock(&codec->power_lock);
4952         codec->power_count += delta;
4953         trace_hda_power_count(codec);
4954         if (delta > 0)
4955                 __snd_hda_power_up(codec, d3wait);
4956         else
4957                 __snd_hda_power_down(codec);
4958         spin_unlock(&codec->power_lock);
4959 }
4960 EXPORT_SYMBOL_HDA(snd_hda_power_save);
4961
4962 /**
4963  * snd_hda_check_amp_list_power - Check the amp list and update the power
4964  * @codec: HD-audio codec
4965  * @check: the object containing an AMP list and the status
4966  * @nid: NID to check / update
4967  *
4968  * Check whether the given NID is in the amp list.  If it's in the list,
4969  * check the current AMP status, and update the the power-status according
4970  * to the mute status.
4971  *
4972  * This function is supposed to be set or called from the check_power_status
4973  * patch ops.
4974  */
4975 int snd_hda_check_amp_list_power(struct hda_codec *codec,
4976                                  struct hda_loopback_check *check,
4977                                  hda_nid_t nid)
4978 {
4979         const struct hda_amp_list *p;
4980         int ch, v;
4981
4982         if (!check->amplist)
4983                 return 0;
4984         for (p = check->amplist; p->nid; p++) {
4985                 if (p->nid == nid)
4986                         break;
4987         }
4988         if (!p->nid)
4989                 return 0; /* nothing changed */
4990
4991         for (p = check->amplist; p->nid; p++) {
4992                 for (ch = 0; ch < 2; ch++) {
4993                         v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4994                                                    p->idx);
4995                         if (!(v & HDA_AMP_MUTE) && v > 0) {
4996                                 if (!check->power_on) {
4997                                         check->power_on = 1;
4998                                         snd_hda_power_up(codec);
4999                                 }
5000                                 return 1;
5001                         }
5002                 }
5003         }
5004         if (check->power_on) {
5005                 check->power_on = 0;
5006                 snd_hda_power_down(codec);
5007         }
5008         return 0;
5009 }
5010 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
5011 #endif
5012
5013 /*
5014  * Channel mode helper
5015  */
5016
5017 /**
5018  * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
5019  */
5020 int snd_hda_ch_mode_info(struct hda_codec *codec,
5021                          struct snd_ctl_elem_info *uinfo,
5022                          const struct hda_channel_mode *chmode,
5023                          int num_chmodes)
5024 {
5025         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5026         uinfo->count = 1;
5027         uinfo->value.enumerated.items = num_chmodes;
5028         if (uinfo->value.enumerated.item >= num_chmodes)
5029                 uinfo->value.enumerated.item = num_chmodes - 1;
5030         sprintf(uinfo->value.enumerated.name, "%dch",
5031                 chmode[uinfo->value.enumerated.item].channels);
5032         return 0;
5033 }
5034 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
5035
5036 /**
5037  * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
5038  */
5039 int snd_hda_ch_mode_get(struct hda_codec *codec,
5040                         struct snd_ctl_elem_value *ucontrol,
5041                         const struct hda_channel_mode *chmode,
5042                         int num_chmodes,
5043                         int max_channels)
5044 {
5045         int i;
5046
5047         for (i = 0; i < num_chmodes; i++) {
5048                 if (max_channels == chmode[i].channels) {
5049                         ucontrol->value.enumerated.item[0] = i;
5050                         break;
5051                 }
5052         }
5053         return 0;
5054 }
5055 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
5056
5057 /**
5058  * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
5059  */
5060 int snd_hda_ch_mode_put(struct hda_codec *codec,
5061                         struct snd_ctl_elem_value *ucontrol,
5062                         const struct hda_channel_mode *chmode,
5063                         int num_chmodes,
5064                         int *max_channelsp)
5065 {
5066         unsigned int mode;
5067
5068         mode = ucontrol->value.enumerated.item[0];
5069         if (mode >= num_chmodes)
5070                 return -EINVAL;
5071         if (*max_channelsp == chmode[mode].channels)
5072                 return 0;
5073         /* change the current channel setting */
5074         *max_channelsp = chmode[mode].channels;
5075         if (chmode[mode].sequence)
5076                 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
5077         return 1;
5078 }
5079 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
5080
5081 /*
5082  * input MUX helper
5083  */
5084
5085 /**
5086  * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
5087  */
5088 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
5089                            struct snd_ctl_elem_info *uinfo)
5090 {
5091         unsigned int index;
5092
5093         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5094         uinfo->count = 1;
5095         uinfo->value.enumerated.items = imux->num_items;
5096         if (!imux->num_items)
5097                 return 0;
5098         index = uinfo->value.enumerated.item;
5099         if (index >= imux->num_items)
5100                 index = imux->num_items - 1;
5101         strcpy(uinfo->value.enumerated.name, imux->items[index].label);
5102         return 0;
5103 }
5104 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
5105
5106 /**
5107  * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
5108  */
5109 int snd_hda_input_mux_put(struct hda_codec *codec,
5110                           const struct hda_input_mux *imux,
5111                           struct snd_ctl_elem_value *ucontrol,
5112                           hda_nid_t nid,
5113                           unsigned int *cur_val)
5114 {
5115         unsigned int idx;
5116
5117         if (!imux->num_items)
5118                 return 0;
5119         idx = ucontrol->value.enumerated.item[0];
5120         if (idx >= imux->num_items)
5121                 idx = imux->num_items - 1;
5122         if (*cur_val == idx)
5123                 return 0;
5124         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
5125                                   imux->items[idx].index);
5126         *cur_val = idx;
5127         return 1;
5128 }
5129 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
5130
5131
5132 /*
5133  * process kcontrol info callback of a simple string enum array
5134  * when @num_items is 0 or @texts is NULL, assume a boolean enum array
5135  */
5136 int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
5137                              struct snd_ctl_elem_info *uinfo,
5138                              int num_items, const char * const *texts)
5139 {
5140         static const char * const texts_default[] = {
5141                 "Disabled", "Enabled"
5142         };
5143
5144         if (!texts || !num_items) {
5145                 num_items = 2;
5146                 texts = texts_default;
5147         }
5148
5149         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5150         uinfo->count = 1;
5151         uinfo->value.enumerated.items = num_items;
5152         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
5153                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
5154         strcpy(uinfo->value.enumerated.name,
5155                texts[uinfo->value.enumerated.item]);
5156         return 0;
5157 }
5158 EXPORT_SYMBOL_HDA(snd_hda_enum_helper_info);
5159
5160 /*
5161  * Multi-channel / digital-out PCM helper functions
5162  */
5163
5164 /* setup SPDIF output stream */
5165 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
5166                                  unsigned int stream_tag, unsigned int format)
5167 {
5168         struct hda_spdif_out *spdif;
5169         unsigned int curr_fmt;
5170         bool reset;
5171
5172         spdif = snd_hda_spdif_out_of_nid(codec, nid);
5173         curr_fmt = snd_hda_codec_read(codec, nid, 0,
5174                                       AC_VERB_GET_STREAM_FORMAT, 0);
5175         reset = codec->spdif_status_reset &&
5176                 (spdif->ctls & AC_DIG1_ENABLE) &&
5177                 curr_fmt != format;
5178
5179         /* turn off SPDIF if needed; otherwise the IEC958 bits won't be
5180            updated */
5181         if (reset)
5182                 set_dig_out_convert(codec, nid,
5183                                     spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
5184                                     -1);
5185         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
5186         if (codec->slave_dig_outs) {
5187                 const hda_nid_t *d;
5188                 for (d = codec->slave_dig_outs; *d; d++)
5189                         snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
5190                                                    format);
5191         }
5192         /* turn on again (if needed) */
5193         if (reset)
5194                 set_dig_out_convert(codec, nid,
5195                                     spdif->ctls & 0xff, -1);
5196 }
5197
5198 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
5199 {
5200         snd_hda_codec_cleanup_stream(codec, nid);
5201         if (codec->slave_dig_outs) {
5202                 const hda_nid_t *d;
5203                 for (d = codec->slave_dig_outs; *d; d++)
5204                         snd_hda_codec_cleanup_stream(codec, *d);
5205         }
5206 }
5207
5208 /**
5209  * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
5210  * @bus: HD-audio bus
5211  */
5212 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
5213 {
5214         struct hda_codec *codec;
5215
5216         if (!bus)
5217                 return;
5218         list_for_each_entry(codec, &bus->codec_list, list) {
5219                 if (hda_codec_is_power_on(codec) &&
5220                     codec->patch_ops.reboot_notify)
5221                         codec->patch_ops.reboot_notify(codec);
5222         }
5223 }
5224 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
5225
5226 /**
5227  * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
5228  */
5229 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
5230                                struct hda_multi_out *mout)
5231 {
5232         mutex_lock(&codec->spdif_mutex);
5233         if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
5234                 /* already opened as analog dup; reset it once */
5235                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5236         mout->dig_out_used = HDA_DIG_EXCLUSIVE;
5237         mutex_unlock(&codec->spdif_mutex);
5238         return 0;
5239 }
5240 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
5241
5242 /**
5243  * snd_hda_multi_out_dig_prepare - prepare the digital out stream
5244  */
5245 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
5246                                   struct hda_multi_out *mout,
5247                                   unsigned int stream_tag,
5248                                   unsigned int format,
5249                                   struct snd_pcm_substream *substream)
5250 {
5251         mutex_lock(&codec->spdif_mutex);
5252         setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
5253         mutex_unlock(&codec->spdif_mutex);
5254         return 0;
5255 }
5256 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
5257
5258 /**
5259  * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
5260  */
5261 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
5262                                   struct hda_multi_out *mout)
5263 {
5264         mutex_lock(&codec->spdif_mutex);
5265         cleanup_dig_out_stream(codec, mout->dig_out_nid);
5266         mutex_unlock(&codec->spdif_mutex);
5267         return 0;
5268 }
5269 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
5270
5271 /**
5272  * snd_hda_multi_out_dig_close - release the digital out stream
5273  */
5274 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
5275                                 struct hda_multi_out *mout)
5276 {
5277         mutex_lock(&codec->spdif_mutex);
5278         mout->dig_out_used = 0;
5279         mutex_unlock(&codec->spdif_mutex);
5280         return 0;
5281 }
5282 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
5283
5284 /**
5285  * snd_hda_multi_out_analog_open - open analog outputs
5286  *
5287  * Open analog outputs and set up the hw-constraints.
5288  * If the digital outputs can be opened as slave, open the digital
5289  * outputs, too.
5290  */
5291 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
5292                                   struct hda_multi_out *mout,
5293                                   struct snd_pcm_substream *substream,
5294                                   struct hda_pcm_stream *hinfo)
5295 {
5296         struct snd_pcm_runtime *runtime = substream->runtime;
5297         runtime->hw.channels_max = mout->max_channels;
5298         if (mout->dig_out_nid) {
5299                 if (!mout->analog_rates) {
5300                         mout->analog_rates = hinfo->rates;
5301                         mout->analog_formats = hinfo->formats;
5302                         mout->analog_maxbps = hinfo->maxbps;
5303                 } else {
5304                         runtime->hw.rates = mout->analog_rates;
5305                         runtime->hw.formats = mout->analog_formats;
5306                         hinfo->maxbps = mout->analog_maxbps;
5307                 }
5308                 if (!mout->spdif_rates) {
5309                         snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
5310                                                     &mout->spdif_rates,
5311                                                     &mout->spdif_formats,
5312                                                     &mout->spdif_maxbps);
5313                 }
5314                 mutex_lock(&codec->spdif_mutex);
5315                 if (mout->share_spdif) {
5316                         if ((runtime->hw.rates & mout->spdif_rates) &&
5317                             (runtime->hw.formats & mout->spdif_formats)) {
5318                                 runtime->hw.rates &= mout->spdif_rates;
5319                                 runtime->hw.formats &= mout->spdif_formats;
5320                                 if (mout->spdif_maxbps < hinfo->maxbps)
5321                                         hinfo->maxbps = mout->spdif_maxbps;
5322                         } else {
5323                                 mout->share_spdif = 0;
5324                                 /* FIXME: need notify? */
5325                         }
5326                 }
5327                 mutex_unlock(&codec->spdif_mutex);
5328         }
5329         return snd_pcm_hw_constraint_step(substream->runtime, 0,
5330                                           SNDRV_PCM_HW_PARAM_CHANNELS, 2);
5331 }
5332 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
5333
5334 /**
5335  * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
5336  *
5337  * Set up the i/o for analog out.
5338  * When the digital out is available, copy the front out to digital out, too.
5339  */
5340 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
5341                                      struct hda_multi_out *mout,
5342                                      unsigned int stream_tag,
5343                                      unsigned int format,
5344                                      struct snd_pcm_substream *substream)
5345 {
5346         const hda_nid_t *nids = mout->dac_nids;
5347         int chs = substream->runtime->channels;
5348         struct hda_spdif_out *spdif;
5349         int i;
5350
5351         mutex_lock(&codec->spdif_mutex);
5352         spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
5353         if (mout->dig_out_nid && mout->share_spdif &&
5354             mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
5355                 if (chs == 2 &&
5356                     snd_hda_is_supported_format(codec, mout->dig_out_nid,
5357                                                 format) &&
5358                     !(spdif->status & IEC958_AES0_NONAUDIO)) {
5359                         mout->dig_out_used = HDA_DIG_ANALOG_DUP;
5360                         setup_dig_out_stream(codec, mout->dig_out_nid,
5361                                              stream_tag, format);
5362                 } else {
5363                         mout->dig_out_used = 0;
5364                         cleanup_dig_out_stream(codec, mout->dig_out_nid);
5365                 }
5366         }
5367         mutex_unlock(&codec->spdif_mutex);
5368
5369         /* front */
5370         snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
5371                                    0, format);
5372         if (!mout->no_share_stream &&
5373             mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
5374                 /* headphone out will just decode front left/right (stereo) */
5375                 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
5376                                            0, format);
5377         /* extra outputs copied from front */
5378         for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5379                 if (!mout->no_share_stream && mout->hp_out_nid[i])
5380                         snd_hda_codec_setup_stream(codec,
5381                                                    mout->hp_out_nid[i],
5382                                                    stream_tag, 0, format);
5383         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
5384                 if (!mout->no_share_stream && mout->extra_out_nid[i])
5385                         snd_hda_codec_setup_stream(codec,
5386                                                    mout->extra_out_nid[i],
5387                                                    stream_tag, 0, format);
5388
5389         /* surrounds */
5390         for (i = 1; i < mout->num_dacs; i++) {
5391                 if (chs >= (i + 1) * 2) /* independent out */
5392                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5393                                                    i * 2, format);
5394                 else if (!mout->no_share_stream) /* copy front */
5395                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5396                                                    0, format);
5397         }
5398         return 0;
5399 }
5400 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
5401
5402 /**
5403  * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
5404  */
5405 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
5406                                      struct hda_multi_out *mout)
5407 {
5408         const hda_nid_t *nids = mout->dac_nids;
5409         int i;
5410
5411         for (i = 0; i < mout->num_dacs; i++)
5412                 snd_hda_codec_cleanup_stream(codec, nids[i]);
5413         if (mout->hp_nid)
5414                 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
5415         for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5416                 if (mout->hp_out_nid[i])
5417                         snd_hda_codec_cleanup_stream(codec,
5418                                                      mout->hp_out_nid[i]);
5419         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
5420                 if (mout->extra_out_nid[i])
5421                         snd_hda_codec_cleanup_stream(codec,
5422                                                      mout->extra_out_nid[i]);
5423         mutex_lock(&codec->spdif_mutex);
5424         if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
5425                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5426                 mout->dig_out_used = 0;
5427         }
5428         mutex_unlock(&codec->spdif_mutex);
5429         return 0;
5430 }
5431 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
5432
5433 /**
5434  * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
5435  *
5436  * Guess the suitable VREF pin bits to be set as the pin-control value.
5437  * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
5438  */
5439 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
5440 {
5441         unsigned int pincap;
5442         unsigned int oldval;
5443         oldval = snd_hda_codec_read(codec, pin, 0,
5444                                     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5445         pincap = snd_hda_query_pin_caps(codec, pin);
5446         pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5447         /* Exception: if the default pin setup is vref50, we give it priority */
5448         if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
5449                 return AC_PINCTL_VREF_80;
5450         else if (pincap & AC_PINCAP_VREF_50)
5451                 return AC_PINCTL_VREF_50;
5452         else if (pincap & AC_PINCAP_VREF_100)
5453                 return AC_PINCTL_VREF_100;
5454         else if (pincap & AC_PINCAP_VREF_GRD)
5455                 return AC_PINCTL_VREF_GRD;
5456         return AC_PINCTL_VREF_HIZ;
5457 }
5458 EXPORT_SYMBOL_HDA(snd_hda_get_default_vref);
5459
5460 /* correct the pin ctl value for matching with the pin cap */
5461 unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
5462                                      hda_nid_t pin, unsigned int val)
5463 {
5464         static unsigned int cap_lists[][2] = {
5465                 { AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
5466                 { AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
5467                 { AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
5468                 { AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
5469         };
5470         unsigned int cap;
5471
5472         if (!val)
5473                 return 0;
5474         cap = snd_hda_query_pin_caps(codec, pin);
5475         if (!cap)
5476                 return val; /* don't know what to do... */
5477
5478         if (val & AC_PINCTL_OUT_EN) {
5479                 if (!(cap & AC_PINCAP_OUT))
5480                         val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5481                 else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
5482                         val &= ~AC_PINCTL_HP_EN;
5483         }
5484
5485         if (val & AC_PINCTL_IN_EN) {
5486                 if (!(cap & AC_PINCAP_IN))
5487                         val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
5488                 else {
5489                         unsigned int vcap, vref;
5490                         int i;
5491                         vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5492                         vref = val & AC_PINCTL_VREFEN;
5493                         for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
5494                                 if (vref == cap_lists[i][0] &&
5495                                     !(vcap & cap_lists[i][1])) {
5496                                         if (i == ARRAY_SIZE(cap_lists) - 1)
5497                                                 vref = AC_PINCTL_VREF_HIZ;
5498                                         else
5499                                                 vref = cap_lists[i + 1][0];
5500                                 }
5501                         }
5502                         val &= ~AC_PINCTL_VREFEN;
5503                         val |= vref;
5504                 }
5505         }
5506
5507         return val;
5508 }
5509 EXPORT_SYMBOL_HDA(snd_hda_correct_pin_ctl);
5510
5511 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
5512                          unsigned int val, bool cached)
5513 {
5514         val = snd_hda_correct_pin_ctl(codec, pin, val);
5515         snd_hda_codec_set_pin_target(codec, pin, val);
5516         if (cached)
5517                 return snd_hda_codec_update_cache(codec, pin, 0,
5518                                 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5519         else
5520                 return snd_hda_codec_write(codec, pin, 0,
5521                                            AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5522 }
5523 EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl);
5524
5525 /**
5526  * snd_hda_add_imux_item - Add an item to input_mux
5527  *
5528  * When the same label is used already in the existing items, the number
5529  * suffix is appended to the label.  This label index number is stored
5530  * to type_idx when non-NULL pointer is given.
5531  */
5532 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5533                           int index, int *type_idx)
5534 {
5535         int i, label_idx = 0;
5536         if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5537                 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5538                 return -EINVAL;
5539         }
5540         for (i = 0; i < imux->num_items; i++) {
5541                 if (!strncmp(label, imux->items[i].label, strlen(label)))
5542                         label_idx++;
5543         }
5544         if (type_idx)
5545                 *type_idx = label_idx;
5546         if (label_idx > 0)
5547                 snprintf(imux->items[imux->num_items].label,
5548                          sizeof(imux->items[imux->num_items].label),
5549                          "%s %d", label, label_idx);
5550         else
5551                 strlcpy(imux->items[imux->num_items].label, label,
5552                         sizeof(imux->items[imux->num_items].label));
5553         imux->items[imux->num_items].index = index;
5554         imux->num_items++;
5555         return 0;
5556 }
5557 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5558
5559
5560 #ifdef CONFIG_PM
5561 /*
5562  * power management
5563  */
5564
5565 /**
5566  * snd_hda_suspend - suspend the codecs
5567  * @bus: the HDA bus
5568  *
5569  * Returns 0 if successful.
5570  */
5571 int snd_hda_suspend(struct hda_bus *bus)
5572 {
5573         struct hda_codec *codec;
5574         unsigned int state;
5575
5576         list_for_each_entry(codec, &bus->codec_list, list) {
5577                 cancel_delayed_work_sync(&codec->jackpoll_work);
5578                 if (hda_codec_is_power_on(codec)) {
5579                         state = hda_call_codec_suspend(codec, false);
5580                         codec->pm_down_notified = 0;
5581                         if (!bus->power_keep_link_on && (state & AC_PWRST_CLK_STOP_OK)) {
5582                                 codec->pm_down_notified = 1;
5583                                 hda_call_pm_notify(bus, false);
5584                         }
5585                 }
5586         }
5587         return 0;
5588 }
5589 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5590
5591 /**
5592  * snd_hda_resume - resume the codecs
5593  * @bus: the HDA bus
5594  *
5595  * Returns 0 if successful.
5596  */
5597 int snd_hda_resume(struct hda_bus *bus)
5598 {
5599         struct hda_codec *codec;
5600
5601         list_for_each_entry(codec, &bus->codec_list, list) {
5602                 hda_call_codec_resume(codec);
5603         }
5604         return 0;
5605 }
5606 EXPORT_SYMBOL_HDA(snd_hda_resume);
5607 #endif /* CONFIG_PM */
5608
5609 /*
5610  * generic arrays
5611  */
5612
5613 /**
5614  * snd_array_new - get a new element from the given array
5615  * @array: the array object
5616  *
5617  * Get a new element from the given array.  If it exceeds the
5618  * pre-allocated array size, re-allocate the array.
5619  *
5620  * Returns NULL if allocation failed.
5621  */
5622 void *snd_array_new(struct snd_array *array)
5623 {
5624         if (snd_BUG_ON(!array->elem_size))
5625                 return NULL;
5626         if (array->used >= array->alloced) {
5627                 int num = array->alloced + array->alloc_align;
5628                 int size = (num + 1) * array->elem_size;
5629                 void *nlist;
5630                 if (snd_BUG_ON(num >= 4096))
5631                         return NULL;
5632                 nlist = krealloc(array->list, size, GFP_KERNEL | __GFP_ZERO);
5633                 if (!nlist)
5634                         return NULL;
5635                 array->list = nlist;
5636                 array->alloced = num;
5637         }
5638         return snd_array_elem(array, array->used++);
5639 }
5640 EXPORT_SYMBOL_HDA(snd_array_new);
5641
5642 /**
5643  * snd_array_free - free the given array elements
5644  * @array: the array object
5645  */
5646 void snd_array_free(struct snd_array *array)
5647 {
5648         kfree(array->list);
5649         array->used = 0;
5650         array->alloced = 0;
5651         array->list = NULL;
5652 }
5653 EXPORT_SYMBOL_HDA(snd_array_free);
5654
5655 /**
5656  * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5657  * @pcm: PCM caps bits
5658  * @buf: the string buffer to write
5659  * @buflen: the max buffer length
5660  *
5661  * used by hda_proc.c and hda_eld.c
5662  */
5663 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5664 {
5665         static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5666         int i, j;
5667
5668         for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5669                 if (pcm & (AC_SUPPCM_BITS_8 << i))
5670                         j += snprintf(buf + j, buflen - j,  " %d", bits[i]);
5671
5672         buf[j] = '\0'; /* necessary when j == 0 */
5673 }
5674 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5675
5676 MODULE_DESCRIPTION("HDA codec core");
5677 MODULE_LICENSE("GPL");