~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/hda/hda_codec.c

Version: ~ [ linux-5.5-rc7 ] ~ [ linux-5.4.13 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.97 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.166 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.210 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.210 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp