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