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