sound/pci/hda/hda_codec.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
   5  *
   6  *
   7  *  This driver is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This driver is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20  */
  21
  22 #include <linux/mm.h>
  23 #include <linux/init.h>
  24 #include <linux/delay.h>
  25 #include <linux/slab.h>
  26 #include <linux/pci.h>
  27 #include <linux/mutex.h>
  28 #include <linux/module.h>
  29 #include <sound/core.h>
  30 #include "hda_codec.h"
  31 #include <sound/asoundef.h>
  32 #include <sound/tlv.h>
  33 #include <sound/initval.h>
  34 #include <sound/jack.h>
  35 #include "hda_local.h"
  36 #include "hda_beep.h"
  37 #include "hda_jack.h"
  38 #include <sound/hda_hwdep.h>
  39
  40 #define CREATE_TRACE_POINTS
  41 #include "hda_trace.h"
  42
  43 /*
  44  * vendor / preset table
  45  */
  46
  47 struct hda_vendor_id {
  48         unsigned int id;
  49         const char *name;
  50 };
  51
  52 /* codec vendor labels */
  53 static struct hda_vendor_id hda_vendor_ids[] = {
  54         { 0x1002, "ATI" },
  55         { 0x1013, "Cirrus Logic" },
  56         { 0x1057, "Motorola" },
  57         { 0x1095, "Silicon Image" },
  58         { 0x10de, "Nvidia" },
  59         { 0x10ec, "Realtek" },
  60         { 0x1102, "Creative" },
  61         { 0x1106, "VIA" },
  62         { 0x111d, "IDT" },
  63         { 0x11c1, "LSI" },
  64         { 0x11d4, "Analog Devices" },
  65         { 0x13f6, "C-Media" },
  66         { 0x14f1, "Conexant" },
  67         { 0x17e8, "Chrontel" },
  68         { 0x1854, "LG" },
  69         { 0x1aec, "Wolfson Microelectronics" },
  70         { 0x434d, "C-Media" },
  71         { 0x8086, "Intel" },
  72         { 0x8384, "SigmaTel" },
  73         {} /* terminator */
  74 };
  75
  76 static DEFINE_MUTEX(preset_mutex);
  77 static LIST_HEAD(hda_preset_tables);
  78
  79 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
  80 {
  81         mutex_lock(&preset_mutex);
  82         list_add_tail(&preset->list, &hda_preset_tables);
  83         mutex_unlock(&preset_mutex);
  84         return 0;
  85 }
  86 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
  87
  88 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
  89 {
  90         mutex_lock(&preset_mutex);
  91         list_del(&preset->list);
  92         mutex_unlock(&preset_mutex);
  93         return 0;
  94 }
  95 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
  96
  97 #ifdef CONFIG_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         snd_hda_jack_tbl_clear(codec);
2329         codec->proc_widget_hook = NULL;
2330         codec->spec = NULL;
2331         free_hda_cache(&codec->amp_cache);
2332         free_hda_cache(&codec->cmd_cache);
2333         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2334         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2335         /* free only driver_pins so that init_pins + user_pins are restored */
2336         snd_array_free(&codec->driver_pins);
2337         restore_pincfgs(codec);
2338         snd_array_free(&codec->cvt_setups);
2339         snd_array_free(&codec->spdif_out);
2340         codec->num_pcms = 0;
2341         codec->pcm_info = NULL;
2342         codec->preset = NULL;
2343         memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
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 /*
2680  * bound volume controls
2681  *
2682  * bind multiple volumes (# indices, from 0)
2683  */
2684
2685 #define AMP_VAL_IDX_SHIFT       19
2686 #define AMP_VAL_IDX_MASK        (0x0f<<19)
2687
2688 /**
2689  * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2690  *
2691  * The control element is supposed to have the private_value field
2692  * set up via HDA_BIND_MUTE*() macros.
2693  */
2694 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2695                                   struct snd_ctl_elem_value *ucontrol)
2696 {
2697         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2698         unsigned long pval;
2699         int err;
2700
2701         mutex_lock(&codec->control_mutex);
2702         pval = kcontrol->private_value;
2703         kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2704         err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2705         kcontrol->private_value = pval;
2706         mutex_unlock(&codec->control_mutex);
2707         return err;
2708 }
2709 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2710
2711 /**
2712  * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2713  *
2714  * The control element is supposed to have the private_value field
2715  * set up via HDA_BIND_MUTE*() macros.
2716  */
2717 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2718                                   struct snd_ctl_elem_value *ucontrol)
2719 {
2720         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2721         unsigned long pval;
2722         int i, indices, err = 0, change = 0;
2723
2724         mutex_lock(&codec->control_mutex);
2725         pval = kcontrol->private_value;
2726         indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2727         for (i = 0; i < indices; i++) {
2728                 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2729                         (i << AMP_VAL_IDX_SHIFT);
2730                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2731                 if (err < 0)
2732                         break;
2733                 change |= err;
2734         }
2735         kcontrol->private_value = pval;
2736         mutex_unlock(&codec->control_mutex);
2737         return err < 0 ? err : change;
2738 }
2739 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2740
2741 /**
2742  * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2743  *
2744  * The control element is supposed to have the private_value field
2745  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2746  */
2747 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2748                                  struct snd_ctl_elem_info *uinfo)
2749 {
2750         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2751         struct hda_bind_ctls *c;
2752         int err;
2753
2754         mutex_lock(&codec->control_mutex);
2755         c = (struct hda_bind_ctls *)kcontrol->private_value;
2756         kcontrol->private_value = *c->values;
2757         err = c->ops->info(kcontrol, uinfo);
2758         kcontrol->private_value = (long)c;
2759         mutex_unlock(&codec->control_mutex);
2760         return err;
2761 }
2762 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2763
2764 /**
2765  * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2766  *
2767  * The control element is supposed to have the private_value field
2768  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2769  */
2770 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2771                                 struct snd_ctl_elem_value *ucontrol)
2772 {
2773         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2774         struct hda_bind_ctls *c;
2775         int err;
2776
2777         mutex_lock(&codec->control_mutex);
2778         c = (struct hda_bind_ctls *)kcontrol->private_value;
2779         kcontrol->private_value = *c->values;
2780         err = c->ops->get(kcontrol, ucontrol);
2781         kcontrol->private_value = (long)c;
2782         mutex_unlock(&codec->control_mutex);
2783         return err;
2784 }
2785 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2786
2787 /**
2788  * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2789  *
2790  * The control element is supposed to have the private_value field
2791  * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2792  */
2793 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2794                                 struct snd_ctl_elem_value *ucontrol)
2795 {
2796         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2797         struct hda_bind_ctls *c;
2798         unsigned long *vals;
2799         int err = 0, change = 0;
2800
2801         mutex_lock(&codec->control_mutex);
2802         c = (struct hda_bind_ctls *)kcontrol->private_value;
2803         for (vals = c->values; *vals; vals++) {
2804                 kcontrol->private_value = *vals;
2805                 err = c->ops->put(kcontrol, ucontrol);
2806                 if (err < 0)
2807                         break;
2808                 change |= err;
2809         }
2810         kcontrol->private_value = (long)c;
2811         mutex_unlock(&codec->control_mutex);
2812         return err < 0 ? err : change;
2813 }
2814 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2815
2816 /**
2817  * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2818  *
2819  * The control element is supposed to have the private_value field
2820  * set up via HDA_BIND_VOL() macro.
2821  */
2822 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2823                            unsigned int size, unsigned int __user *tlv)
2824 {
2825         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2826         struct hda_bind_ctls *c;
2827         int err;
2828
2829         mutex_lock(&codec->control_mutex);
2830         c = (struct hda_bind_ctls *)kcontrol->private_value;
2831         kcontrol->private_value = *c->values;
2832         err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2833         kcontrol->private_value = (long)c;
2834         mutex_unlock(&codec->control_mutex);
2835         return err;
2836 }
2837 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2838
2839 struct hda_ctl_ops snd_hda_bind_vol = {
2840         .info = snd_hda_mixer_amp_volume_info,
2841         .get = snd_hda_mixer_amp_volume_get,
2842         .put = snd_hda_mixer_amp_volume_put,
2843         .tlv = snd_hda_mixer_amp_tlv
2844 };
2845 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2846
2847 struct hda_ctl_ops snd_hda_bind_sw = {
2848         .info = snd_hda_mixer_amp_switch_info,
2849         .get = snd_hda_mixer_amp_switch_get,
2850         .put = snd_hda_mixer_amp_switch_put,
2851         .tlv = snd_hda_mixer_amp_tlv
2852 };
2853 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2854
2855 /*
2856  * SPDIF out controls
2857  */
2858
2859 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2860                                    struct snd_ctl_elem_info *uinfo)
2861 {
2862         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2863         uinfo->count = 1;
2864         return 0;
2865 }
2866
2867 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2868                                    struct snd_ctl_elem_value *ucontrol)
2869 {
2870         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2871                                            IEC958_AES0_NONAUDIO |
2872                                            IEC958_AES0_CON_EMPHASIS_5015 |
2873                                            IEC958_AES0_CON_NOT_COPYRIGHT;
2874         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2875                                            IEC958_AES1_CON_ORIGINAL;
2876         return 0;
2877 }
2878
2879 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2880                                    struct snd_ctl_elem_value *ucontrol)
2881 {
2882         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2883                                            IEC958_AES0_NONAUDIO |
2884                                            IEC958_AES0_PRO_EMPHASIS_5015;
2885         return 0;
2886 }
2887
2888 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2889                                      struct snd_ctl_elem_value *ucontrol)
2890 {
2891         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2892         int idx = kcontrol->private_value;
2893         struct hda_spdif_out *spdif;
2894
2895         mutex_lock(&codec->spdif_mutex);
2896         spdif = snd_array_elem(&codec->spdif_out, idx);
2897         ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2898         ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2899         ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2900         ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2901         mutex_unlock(&codec->spdif_mutex);
2902
2903         return 0;
2904 }
2905
2906 /* convert from SPDIF status bits to HDA SPDIF bits
2907  * bit 0 (DigEn) is always set zero (to be filled later)
2908  */
2909 static unsigned short convert_from_spdif_status(unsigned int sbits)
2910 {
2911         unsigned short val = 0;
2912
2913         if (sbits & IEC958_AES0_PROFESSIONAL)
2914                 val |= AC_DIG1_PROFESSIONAL;
2915         if (sbits & IEC958_AES0_NONAUDIO)
2916                 val |= AC_DIG1_NONAUDIO;
2917         if (sbits & IEC958_AES0_PROFESSIONAL) {
2918                 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2919                     IEC958_AES0_PRO_EMPHASIS_5015)
2920                         val |= AC_DIG1_EMPHASIS;
2921         } else {
2922                 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2923                     IEC958_AES0_CON_EMPHASIS_5015)
2924                         val |= AC_DIG1_EMPHASIS;
2925                 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2926                         val |= AC_DIG1_COPYRIGHT;
2927                 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2928                         val |= AC_DIG1_LEVEL;
2929                 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2930         }
2931         return val;
2932 }
2933
2934 /* convert to SPDIF status bits from HDA SPDIF bits
2935  */
2936 static unsigned int convert_to_spdif_status(unsigned short val)
2937 {
2938         unsigned int sbits = 0;
2939
2940         if (val & AC_DIG1_NONAUDIO)
2941                 sbits |= IEC958_AES0_NONAUDIO;
2942         if (val & AC_DIG1_PROFESSIONAL)
2943                 sbits |= IEC958_AES0_PROFESSIONAL;
2944         if (sbits & IEC958_AES0_PROFESSIONAL) {
2945                 if (sbits & AC_DIG1_EMPHASIS)
2946                         sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2947         } else {
2948                 if (val & AC_DIG1_EMPHASIS)
2949                         sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2950                 if (!(val & AC_DIG1_COPYRIGHT))
2951                         sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2952                 if (val & AC_DIG1_LEVEL)
2953                         sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2954                 sbits |= val & (0x7f << 8);
2955         }
2956         return sbits;
2957 }
2958
2959 /* set digital convert verbs both for the given NID and its slaves */
2960 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2961                         int verb, int val)
2962 {
2963         const hda_nid_t *d;
2964
2965         snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2966         d = codec->slave_dig_outs;
2967         if (!d)
2968                 return;
2969         for (; *d; d++)
2970                 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2971 }
2972
2973 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2974                                        int dig1, int dig2)
2975 {
2976         if (dig1 != -1)
2977                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2978         if (dig2 != -1)
2979                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2980 }
2981
2982 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2983                                      struct snd_ctl_elem_value *ucontrol)
2984 {
2985         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2986         int idx = kcontrol->private_value;
2987         struct hda_spdif_out *spdif;
2988         hda_nid_t nid;
2989         unsigned short val;
2990         int change;
2991
2992         mutex_lock(&codec->spdif_mutex);
2993         spdif = snd_array_elem(&codec->spdif_out, idx);
2994         nid = spdif->nid;
2995         spdif->status = ucontrol->value.iec958.status[0] |
2996                 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2997                 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2998                 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2999         val = convert_from_spdif_status(spdif->status);
3000         val |= spdif->ctls & 1;
3001         change = spdif->ctls != val;
3002         spdif->ctls = val;
3003         if (change && nid != (u16)-1)
3004                 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
3005         mutex_unlock(&codec->spdif_mutex);
3006         return change;
3007 }
3008
3009 #define snd_hda_spdif_out_switch_info   snd_ctl_boolean_mono_info
3010
3011 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3012                                         struct snd_ctl_elem_value *ucontrol)
3013 {
3014         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3015         int idx = kcontrol->private_value;
3016         struct hda_spdif_out *spdif;
3017
3018         mutex_lock(&codec->spdif_mutex);
3019         spdif = snd_array_elem(&codec->spdif_out, idx);
3020         ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
3021         mutex_unlock(&codec->spdif_mutex);
3022         return 0;
3023 }
3024
3025 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3026                                   int dig1, int dig2)
3027 {
3028         set_dig_out_convert(codec, nid, dig1, dig2);
3029         /* unmute amp switch (if any) */
3030         if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3031             (dig1 & AC_DIG1_ENABLE))
3032                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3033                                             HDA_AMP_MUTE, 0);
3034 }
3035
3036 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3037                                         struct snd_ctl_elem_value *ucontrol)
3038 {
3039         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3040         int idx = kcontrol->private_value;
3041         struct hda_spdif_out *spdif;
3042         hda_nid_t nid;
3043         unsigned short val;
3044         int change;
3045
3046         mutex_lock(&codec->spdif_mutex);
3047         spdif = snd_array_elem(&codec->spdif_out, idx);
3048         nid = spdif->nid;
3049         val = spdif->ctls & ~AC_DIG1_ENABLE;
3050         if (ucontrol->value.integer.value[0])
3051                 val |= AC_DIG1_ENABLE;
3052         change = spdif->ctls != val;
3053         spdif->ctls = val;
3054         if (change && nid != (u16)-1)
3055                 set_spdif_ctls(codec, nid, val & 0xff, -1);
3056         mutex_unlock(&codec->spdif_mutex);
3057         return change;
3058 }
3059
3060 static struct snd_kcontrol_new dig_mixes[] = {
3061         {
3062                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3063                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3064                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3065                 .info = snd_hda_spdif_mask_info,
3066                 .get = snd_hda_spdif_cmask_get,
3067         },
3068         {
3069                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3070                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3071                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3072                 .info = snd_hda_spdif_mask_info,
3073                 .get = snd_hda_spdif_pmask_get,
3074         },
3075         {
3076                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3077                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3078                 .info = snd_hda_spdif_mask_info,
3079                 .get = snd_hda_spdif_default_get,
3080                 .put = snd_hda_spdif_default_put,
3081         },
3082         {
3083                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3084                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3085                 .info = snd_hda_spdif_out_switch_info,
3086                 .get = snd_hda_spdif_out_switch_get,
3087                 .put = snd_hda_spdif_out_switch_put,
3088         },
3089         { } /* end */
3090 };
3091
3092 /**
3093  * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
3094  * @codec: the HDA codec
3095  * @nid: audio out widget NID
3096  *
3097  * Creates controls related with the SPDIF output.
3098  * Called from each patch supporting the SPDIF out.
3099  *
3100  * Returns 0 if successful, or a negative error code.
3101  */
3102 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
3103                                   hda_nid_t associated_nid,
3104                                   hda_nid_t cvt_nid)
3105 {
3106         int err;
3107         struct snd_kcontrol *kctl;
3108         struct snd_kcontrol_new *dig_mix;
3109         int idx;
3110         struct hda_spdif_out *spdif;
3111
3112         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
3113         if (idx < 0) {
3114                 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3115                 return -EBUSY;
3116         }
3117         spdif = snd_array_new(&codec->spdif_out);
3118         for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3119                 kctl = snd_ctl_new1(dig_mix, codec);
3120                 if (!kctl)
3121                         return -ENOMEM;
3122                 kctl->id.index = idx;
3123                 kctl->private_value = codec->spdif_out.used - 1;
3124                 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3125                 if (err < 0)
3126                         return err;
3127         }
3128         spdif->nid = cvt_nid;
3129         spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3130                                          AC_VERB_GET_DIGI_CONVERT_1, 0);
3131         spdif->status = convert_to_spdif_status(spdif->ctls);
3132         return 0;
3133 }
3134 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
3135
3136 /* get the hda_spdif_out entry from the given NID
3137  * call within spdif_mutex lock
3138  */
3139 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3140                                                hda_nid_t nid)
3141 {
3142         int i;
3143         for (i = 0; i < codec->spdif_out.used; i++) {
3144                 struct hda_spdif_out *spdif =
3145                                 snd_array_elem(&codec->spdif_out, i);
3146                 if (spdif->nid == nid)
3147                         return spdif;
3148         }
3149         return NULL;
3150 }
3151 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3152
3153 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3154 {
3155         struct hda_spdif_out *spdif;
3156
3157         mutex_lock(&codec->spdif_mutex);
3158         spdif = snd_array_elem(&codec->spdif_out, idx);
3159         spdif->nid = (u16)-1;
3160         mutex_unlock(&codec->spdif_mutex);
3161 }
3162 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3163
3164 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3165 {
3166         struct hda_spdif_out *spdif;
3167         unsigned short val;
3168
3169         mutex_lock(&codec->spdif_mutex);
3170         spdif = snd_array_elem(&codec->spdif_out, idx);
3171         if (spdif->nid != nid) {
3172                 spdif->nid = nid;
3173                 val = spdif->ctls;
3174                 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3175         }
3176         mutex_unlock(&codec->spdif_mutex);
3177 }
3178 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3179
3180 /*
3181  * SPDIF sharing with analog output
3182  */
3183 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3184                               struct snd_ctl_elem_value *ucontrol)
3185 {
3186         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3187         ucontrol->value.integer.value[0] = mout->share_spdif;
3188         return 0;
3189 }
3190
3191 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3192                               struct snd_ctl_elem_value *ucontrol)
3193 {
3194         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3195         mout->share_spdif = !!ucontrol->value.integer.value[0];
3196         return 0;
3197 }
3198
3199 static struct snd_kcontrol_new spdif_share_sw = {
3200         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3201         .name = "IEC958 Default PCM Playback Switch",
3202         .info = snd_ctl_boolean_mono_info,
3203         .get = spdif_share_sw_get,
3204         .put = spdif_share_sw_put,
3205 };
3206
3207 /**
3208  * snd_hda_create_spdif_share_sw - create Default PCM switch
3209  * @codec: the HDA codec
3210  * @mout: multi-out instance
3211  */
3212 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3213                                   struct hda_multi_out *mout)
3214 {
3215         if (!mout->dig_out_nid)
3216                 return 0;
3217         /* ATTENTION: here mout is passed as private_data, instead of codec */
3218         return snd_hda_ctl_add(codec, mout->dig_out_nid,
3219                               snd_ctl_new1(&spdif_share_sw, mout));
3220 }
3221 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3222
3223 /*
3224  * SPDIF input
3225  */
3226
3227 #define snd_hda_spdif_in_switch_info    snd_hda_spdif_out_switch_info
3228
3229 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3230                                        struct snd_ctl_elem_value *ucontrol)
3231 {
3232         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3233
3234         ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3235         return 0;
3236 }
3237
3238 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3239                                        struct snd_ctl_elem_value *ucontrol)
3240 {
3241         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3242         hda_nid_t nid = kcontrol->private_value;
3243         unsigned int val = !!ucontrol->value.integer.value[0];
3244         int change;
3245
3246         mutex_lock(&codec->spdif_mutex);
3247         change = codec->spdif_in_enable != val;
3248         if (change) {
3249                 codec->spdif_in_enable = val;
3250                 snd_hda_codec_write_cache(codec, nid, 0,
3251                                           AC_VERB_SET_DIGI_CONVERT_1, val);
3252         }
3253         mutex_unlock(&codec->spdif_mutex);
3254         return change;
3255 }
3256
3257 static int snd_hda_spdif_in_status_get(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 short val;
3263         unsigned int sbits;
3264
3265         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3266         sbits = convert_to_spdif_status(val);
3267         ucontrol->value.iec958.status[0] = sbits;
3268         ucontrol->value.iec958.status[1] = sbits >> 8;
3269         ucontrol->value.iec958.status[2] = sbits >> 16;
3270         ucontrol->value.iec958.status[3] = sbits >> 24;
3271         return 0;
3272 }
3273
3274 static struct snd_kcontrol_new dig_in_ctls[] = {
3275         {
3276                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3277                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3278                 .info = snd_hda_spdif_in_switch_info,
3279                 .get = snd_hda_spdif_in_switch_get,
3280                 .put = snd_hda_spdif_in_switch_put,
3281         },
3282         {
3283                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3284                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3285                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3286                 .info = snd_hda_spdif_mask_info,
3287                 .get = snd_hda_spdif_in_status_get,
3288         },
3289         { } /* end */
3290 };
3291
3292 /**
3293  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3294  * @codec: the HDA codec
3295  * @nid: audio in widget NID
3296  *
3297  * Creates controls related with the SPDIF input.
3298  * Called from each patch supporting the SPDIF in.
3299  *
3300  * Returns 0 if successful, or a negative error code.
3301  */
3302 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3303 {
3304         int err;
3305         struct snd_kcontrol *kctl;
3306         struct snd_kcontrol_new *dig_mix;
3307         int idx;
3308
3309         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3310         if (idx < 0) {
3311                 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3312                 return -EBUSY;
3313         }
3314         for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3315                 kctl = snd_ctl_new1(dig_mix, codec);
3316                 if (!kctl)
3317                         return -ENOMEM;
3318                 kctl->private_value = nid;
3319                 err = snd_hda_ctl_add(codec, nid, kctl);
3320                 if (err < 0)
3321                         return err;
3322         }
3323         codec->spdif_in_enable =
3324                 snd_hda_codec_read(codec, nid, 0,
3325                                    AC_VERB_GET_DIGI_CONVERT_1, 0) &
3326                 AC_DIG1_ENABLE;
3327         return 0;
3328 }
3329 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3330
3331 #ifdef CONFIG_PM
3332 /*
3333  * command cache
3334  */
3335
3336 /* build a 32bit cache key with the widget id and the command parameter */
3337 #define build_cmd_cache_key(nid, verb)  ((verb << 8) | nid)
3338 #define get_cmd_cache_nid(key)          ((key) & 0xff)
3339 #define get_cmd_cache_cmd(key)          (((key) >> 8) & 0xffff)
3340
3341 /**
3342  * snd_hda_codec_write_cache - send a single command with caching
3343  * @codec: the HDA codec
3344  * @nid: NID to send the command
3345  * @direct: direct flag
3346  * @verb: the verb to send
3347  * @parm: the parameter for the verb
3348  *
3349  * Send a single command without waiting for response.
3350  *
3351  * Returns 0 if successful, or a negative error code.
3352  */
3353 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3354                               int direct, unsigned int verb, unsigned int parm)
3355 {
3356         int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3357         struct hda_cache_head *c;
3358         u32 key;
3359
3360         if (err < 0)
3361                 return err;
3362         /* parm may contain the verb stuff for get/set amp */
3363         verb = verb | (parm >> 8);
3364         parm &= 0xff;
3365         key = build_cmd_cache_key(nid, verb);
3366         mutex_lock(&codec->bus->cmd_mutex);
3367         c = get_alloc_hash(&codec->cmd_cache, key);
3368         if (c)
3369                 c->val = parm;
3370         mutex_unlock(&codec->bus->cmd_mutex);
3371         return 0;
3372 }
3373 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3374
3375 /**
3376  * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3377  * @codec: the HDA codec
3378  * @nid: NID to send the command
3379  * @direct: direct flag
3380  * @verb: the verb to send
3381  * @parm: the parameter for the verb
3382  *
3383  * This function works like snd_hda_codec_write_cache(), but it doesn't send
3384  * command if the parameter is already identical with the cached value.
3385  * If not, it sends the command and refreshes the cache.
3386  *
3387  * Returns 0 if successful, or a negative error code.
3388  */
3389 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3390                                int direct, unsigned int verb, unsigned int parm)
3391 {
3392         struct hda_cache_head *c;
3393         u32 key;
3394
3395         /* parm may contain the verb stuff for get/set amp */
3396         verb = verb | (parm >> 8);
3397         parm &= 0xff;
3398         key = build_cmd_cache_key(nid, verb);
3399         mutex_lock(&codec->bus->cmd_mutex);
3400         c = get_hash(&codec->cmd_cache, key);
3401         if (c && c->val == parm) {
3402                 mutex_unlock(&codec->bus->cmd_mutex);
3403                 return 0;
3404         }
3405         mutex_unlock(&codec->bus->cmd_mutex);
3406         return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3407 }
3408 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3409
3410 /**
3411  * snd_hda_codec_resume_cache - Resume the all commands from the cache
3412  * @codec: HD-audio codec
3413  *
3414  * Execute all verbs recorded in the command caches to resume.
3415  */
3416 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3417 {
3418         struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
3419         int i;
3420
3421         for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
3422                 u32 key = buffer->key;
3423                 if (!key)
3424                         continue;
3425                 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3426                                     get_cmd_cache_cmd(key), buffer->val);
3427         }
3428 }
3429 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3430
3431 /**
3432  * snd_hda_sequence_write_cache - sequence writes with caching
3433  * @codec: the HDA codec
3434  * @seq: VERB array to send
3435  *
3436  * Send the commands sequentially from the given array.
3437  * Thte commands are recorded on cache for power-save and resume.
3438  * The array must be terminated with NID=0.
3439  */
3440 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3441                                   const struct hda_verb *seq)
3442 {
3443         for (; seq->nid; seq++)
3444                 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3445                                           seq->param);
3446 }
3447 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3448 #endif /* CONFIG_PM */
3449
3450 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3451                                     unsigned int power_state,
3452                                     bool eapd_workaround)
3453 {
3454         hda_nid_t nid = codec->start_nid;
3455         int i;
3456
3457         for (i = 0; i < codec->num_nodes; i++, nid++) {
3458                 unsigned int wcaps = get_wcaps(codec, nid);
3459                 if (!(wcaps & AC_WCAP_POWER))
3460                         continue;
3461                 /* don't power down the widget if it controls eapd and
3462                  * EAPD_BTLENABLE is set.
3463                  */
3464                 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3465                     get_wcaps_type(wcaps) == AC_WID_PIN &&
3466                     (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3467                         int eapd = snd_hda_codec_read(codec, nid, 0,
3468                                                 AC_VERB_GET_EAPD_BTLENABLE, 0);
3469                         if (eapd & 0x02)
3470                                 continue;
3471                 }
3472                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3473                                     power_state);
3474         }
3475
3476         if (power_state == AC_PWRST_D0) {
3477                 unsigned long end_time;
3478                 int state;
3479                 /* wait until the codec reachs to D0 */
3480                 end_time = jiffies + msecs_to_jiffies(500);
3481                 do {
3482                         state = snd_hda_codec_read(codec, fg, 0,
3483                                                    AC_VERB_GET_POWER_STATE, 0);
3484                         if (state == power_state)
3485                                 break;
3486                         msleep(1);
3487                 } while (time_after_eq(end_time, jiffies));
3488         }
3489 }
3490 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3491
3492 /*
3493  *  supported power states check
3494  */
3495 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
3496                                 unsigned int power_state)
3497 {
3498         int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
3499
3500         if (sup == -1)
3501                 return false;
3502         if (sup & power_state)
3503                 return true;
3504         else
3505                 return false;
3506 }
3507
3508 /*
3509  * set power state of the codec
3510  */
3511 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3512                                 unsigned int power_state)
3513 {
3514         int count;
3515         unsigned int 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                 /* transition time less than 10ms for power down */
3525                 bool epss = snd_hda_codec_get_supported_ps(codec, fg, AC_PWRST_EPSS);
3526                 msleep(epss ? 10 : 100);
3527         }
3528
3529         /* repeat power states setting at most 10 times*/
3530         for (count = 0; count < 10; count++) {
3531                 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3532                                     power_state);
3533                 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3534                 state = snd_hda_codec_read(codec, fg, 0,
3535                                            AC_VERB_GET_POWER_STATE, 0);
3536                 if (!(state & AC_PWRST_ERROR))
3537                         break;
3538         }
3539 }
3540
3541 #ifdef CONFIG_SND_HDA_HWDEP
3542 /* execute additional init verbs */
3543 static void hda_exec_init_verbs(struct hda_codec *codec)
3544 {
3545         if (codec->init_verbs.list)
3546                 snd_hda_sequence_write(codec, codec->init_verbs.list);
3547 }
3548 #else
3549 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3550 #endif
3551
3552 #ifdef CONFIG_PM
3553 /*
3554  * call suspend and power-down; used both from PM and power-save
3555  */
3556 static void hda_call_codec_suspend(struct hda_codec *codec)
3557 {
3558         if (codec->patch_ops.suspend)
3559                 codec->patch_ops.suspend(codec);
3560         hda_cleanup_all_streams(codec);
3561         hda_set_power_state(codec,
3562                             codec->afg ? codec->afg : codec->mfg,
3563                             AC_PWRST_D3);
3564 #ifdef CONFIG_SND_HDA_POWER_SAVE
3565         cancel_delayed_work(&codec->power_work);
3566         spin_lock(&codec->power_lock);
3567         snd_hda_update_power_acct(codec);
3568         trace_hda_power_down(codec);
3569         codec->power_on = 0;
3570         codec->power_transition = 0;
3571         codec->power_jiffies = jiffies;
3572         spin_unlock(&codec->power_lock);
3573 #endif
3574 }
3575
3576 /*
3577  * kick up codec; used both from PM and power-save
3578  */
3579 static void hda_call_codec_resume(struct hda_codec *codec)
3580 {
3581         /* set as if powered on for avoiding re-entering the resume
3582          * in the resume / power-save sequence
3583          */
3584         hda_keep_power_on(codec);
3585         hda_set_power_state(codec,
3586                             codec->afg ? codec->afg : codec->mfg,
3587                             AC_PWRST_D0);
3588         restore_pincfgs(codec); /* restore all current pin configs */
3589         restore_shutup_pins(codec);
3590         hda_exec_init_verbs(codec);
3591         snd_hda_jack_set_dirty_all(codec);
3592         if (codec->patch_ops.resume)
3593                 codec->patch_ops.resume(codec);
3594         else {
3595                 if (codec->patch_ops.init)
3596                         codec->patch_ops.init(codec);
3597                 snd_hda_codec_resume_amp(codec);
3598                 snd_hda_codec_resume_cache(codec);
3599         }
3600         snd_hda_power_down(codec); /* flag down before returning */
3601 }
3602 #endif /* CONFIG_PM */
3603
3604
3605 /**
3606  * snd_hda_build_controls - build mixer controls
3607  * @bus: the BUS
3608  *
3609  * Creates mixer controls for each codec included in the bus.
3610  *
3611  * Returns 0 if successful, otherwise a negative error code.
3612  */
3613 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
3614 {
3615         struct hda_codec *codec;
3616
3617         list_for_each_entry(codec, &bus->codec_list, list) {
3618                 int err = snd_hda_codec_build_controls(codec);
3619                 if (err < 0) {
3620                         printk(KERN_ERR "hda_codec: cannot build controls "
3621                                "for #%d (error %d)\n", codec->addr, err);
3622                         err = snd_hda_codec_reset(codec);
3623                         if (err < 0) {
3624                                 printk(KERN_ERR
3625                                        "hda_codec: cannot revert codec\n");
3626                                 return err;
3627                         }
3628                 }
3629         }
3630         return 0;
3631 }
3632 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3633
3634 int snd_hda_codec_build_controls(struct hda_codec *codec)
3635 {
3636         int err = 0;
3637         hda_exec_init_verbs(codec);
3638         /* continue to initialize... */
3639         if (codec->patch_ops.init)
3640                 err = codec->patch_ops.init(codec);
3641         if (!err && codec->patch_ops.build_controls)
3642                 err = codec->patch_ops.build_controls(codec);
3643         if (err < 0)
3644                 return err;
3645         return 0;
3646 }
3647
3648 /*
3649  * stream formats
3650  */
3651 struct hda_rate_tbl {
3652         unsigned int hz;
3653         unsigned int alsa_bits;
3654         unsigned int hda_fmt;
3655 };
3656
3657 /* rate = base * mult / div */
3658 #define HDA_RATE(base, mult, div) \
3659         (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3660          (((div) - 1) << AC_FMT_DIV_SHIFT))
3661
3662 static struct hda_rate_tbl rate_bits[] = {
3663         /* rate in Hz, ALSA rate bitmask, HDA format value */
3664
3665         /* autodetected value used in snd_hda_query_supported_pcm */
3666         { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3667         { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3668         { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3669         { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3670         { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3671         { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3672         { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3673         { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3674         { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3675         { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3676         { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3677 #define AC_PAR_PCM_RATE_BITS    11
3678         /* up to bits 10, 384kHZ isn't supported properly */
3679
3680         /* not autodetected value */
3681         { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3682
3683         { 0 } /* terminator */
3684 };
3685
3686 /**
3687  * snd_hda_calc_stream_format - calculate format bitset
3688  * @rate: the sample rate
3689  * @channels: the number of channels
3690  * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3691  * @maxbps: the max. bps
3692  *
3693  * Calculate the format bitset from the given rate, channels and th PCM format.
3694  *
3695  * Return zero if invalid.
3696  */
3697 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3698                                         unsigned int channels,
3699                                         unsigned int format,
3700                                         unsigned int maxbps,
3701                                         unsigned short spdif_ctls)
3702 {
3703         int i;
3704         unsigned int val = 0;
3705
3706         for (i = 0; rate_bits[i].hz; i++)
3707                 if (rate_bits[i].hz == rate) {
3708                         val = rate_bits[i].hda_fmt;
3709                         break;
3710                 }
3711         if (!rate_bits[i].hz) {
3712                 snd_printdd("invalid rate %d\n", rate);
3713                 return 0;
3714         }
3715
3716         if (channels == 0 || channels > 8) {
3717                 snd_printdd("invalid channels %d\n", channels);
3718                 return 0;
3719         }
3720         val |= channels - 1;
3721
3722         switch (snd_pcm_format_width(format)) {
3723         case 8:
3724                 val |= AC_FMT_BITS_8;
3725                 break;
3726         case 16:
3727                 val |= AC_FMT_BITS_16;
3728                 break;
3729         case 20:
3730         case 24:
3731         case 32:
3732                 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3733                         val |= AC_FMT_BITS_32;
3734                 else if (maxbps >= 24)
3735                         val |= AC_FMT_BITS_24;
3736                 else
3737                         val |= AC_FMT_BITS_20;
3738                 break;
3739         default:
3740                 snd_printdd("invalid format width %d\n",
3741                             snd_pcm_format_width(format));
3742                 return 0;
3743         }
3744
3745         if (spdif_ctls & AC_DIG1_NONAUDIO)
3746                 val |= AC_FMT_TYPE_NON_PCM;
3747
3748         return val;
3749 }
3750 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3751
3752 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
3753                                   int dir)
3754 {
3755         unsigned int val = 0;
3756         if (nid != codec->afg &&
3757             (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3758                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3759         if (!val || val == -1)
3760                 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3761         if (!val || val == -1)
3762                 return 0;
3763         return val;
3764 }
3765
3766 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3767 {
3768         return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
3769                                get_pcm_param);
3770 }
3771
3772 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
3773                                      int dir)
3774 {
3775         unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3776         if (!streams || streams == -1)
3777                 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3778         if (!streams || streams == -1)
3779                 return 0;
3780         return streams;
3781 }
3782
3783 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3784 {
3785         return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
3786                                get_stream_param);
3787 }
3788
3789 /**
3790  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3791  * @codec: the HDA codec
3792  * @nid: NID to query
3793  * @ratesp: the pointer to store the detected rate bitflags
3794  * @formatsp: the pointer to store the detected formats
3795  * @bpsp: the pointer to store the detected format widths
3796  *
3797  * Queries the supported PCM rates and formats.  The NULL @ratesp, @formatsp
3798  * or @bsps argument is ignored.
3799  *
3800  * Returns 0 if successful, otherwise a negative error code.
3801  */
3802 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3803                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3804 {
3805         unsigned int i, val, wcaps;
3806
3807         wcaps = get_wcaps(codec, nid);
3808         val = query_pcm_param(codec, nid);
3809
3810         if (ratesp) {
3811                 u32 rates = 0;
3812                 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3813                         if (val & (1 << i))
3814                                 rates |= rate_bits[i].alsa_bits;
3815                 }
3816                 if (rates == 0) {
3817                         snd_printk(KERN_ERR "hda_codec: rates == 0 "
3818                                    "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3819                                         nid, val,
3820                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3821                         return -EIO;
3822                 }
3823                 *ratesp = rates;
3824         }
3825
3826         if (formatsp || bpsp) {
3827                 u64 formats = 0;
3828                 unsigned int streams, bps;
3829
3830                 streams = query_stream_param(codec, nid);
3831                 if (!streams)
3832                         return -EIO;
3833
3834                 bps = 0;
3835                 if (streams & AC_SUPFMT_PCM) {
3836                         if (val & AC_SUPPCM_BITS_8) {
3837                                 formats |= SNDRV_PCM_FMTBIT_U8;
3838                                 bps = 8;
3839                         }
3840                         if (val & AC_SUPPCM_BITS_16) {
3841                                 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3842                                 bps = 16;
3843                         }
3844                         if (wcaps & AC_WCAP_DIGITAL) {
3845                                 if (val & AC_SUPPCM_BITS_32)
3846                                         formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3847                                 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3848                                         formats |= SNDRV_PCM_FMTBIT_S32_LE;
3849                                 if (val & AC_SUPPCM_BITS_24)
3850                                         bps = 24;
3851                                 else if (val & AC_SUPPCM_BITS_20)
3852                                         bps = 20;
3853                         } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3854                                           AC_SUPPCM_BITS_32)) {
3855                                 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3856                                 if (val & AC_SUPPCM_BITS_32)
3857                                         bps = 32;
3858                                 else if (val & AC_SUPPCM_BITS_24)
3859                                         bps = 24;
3860                                 else if (val & AC_SUPPCM_BITS_20)
3861                                         bps = 20;
3862                         }
3863                 }
3864 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
3865                 if (streams & AC_SUPFMT_FLOAT32) {
3866                         formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3867                         if (!bps)
3868                                 bps = 32;
3869                 }
3870 #endif
3871                 if (streams == AC_SUPFMT_AC3) {
3872                         /* should be exclusive */
3873                         /* temporary hack: we have still no proper support
3874                          * for the direct AC3 stream...
3875                          */
3876                         formats |= SNDRV_PCM_FMTBIT_U8;
3877                         bps = 8;
3878                 }
3879                 if (formats == 0) {
3880                         snd_printk(KERN_ERR "hda_codec: formats == 0 "
3881                                    "(nid=0x%x, val=0x%x, ovrd=%i, "
3882                                    "streams=0x%x)\n",
3883                                         nid, val,
3884                                         (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3885                                         streams);
3886                         return -EIO;
3887                 }
3888                 if (formatsp)
3889                         *formatsp = formats;
3890                 if (bpsp)
3891                         *bpsp = bps;
3892         }
3893
3894         return 0;
3895 }
3896 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
3897
3898 /**
3899  * snd_hda_is_supported_format - Check the validity of the format
3900  * @codec: HD-audio codec
3901  * @nid: NID to check
3902  * @format: the HD-audio format value to check
3903  *
3904  * Check whether the given node supports the format value.
3905  *
3906  * Returns 1 if supported, 0 if not.
3907  */
3908 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3909                                 unsigned int format)
3910 {
3911         int i;
3912         unsigned int val = 0, rate, stream;
3913
3914         val = query_pcm_param(codec, nid);
3915         if (!val)
3916                 return 0;
3917
3918         rate = format & 0xff00;
3919         for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3920                 if (rate_bits[i].hda_fmt == rate) {
3921                         if (val & (1 << i))
3922                                 break;
3923                         return 0;
3924                 }
3925         if (i >= AC_PAR_PCM_RATE_BITS)
3926                 return 0;
3927
3928         stream = query_stream_param(codec, nid);
3929         if (!stream)
3930                 return 0;
3931
3932         if (stream & AC_SUPFMT_PCM) {
3933                 switch (format & 0xf0) {
3934                 case 0x00:
3935                         if (!(val & AC_SUPPCM_BITS_8))
3936                                 return 0;
3937                         break;
3938                 case 0x10:
3939                         if (!(val & AC_SUPPCM_BITS_16))
3940                                 return 0;
3941                         break;
3942                 case 0x20:
3943                         if (!(val & AC_SUPPCM_BITS_20))
3944                                 return 0;
3945                         break;
3946                 case 0x30:
3947                         if (!(val & AC_SUPPCM_BITS_24))
3948                                 return 0;
3949                         break;
3950                 case 0x40:
3951                         if (!(val & AC_SUPPCM_BITS_32))
3952                                 return 0;
3953                         break;
3954                 default:
3955                         return 0;
3956                 }
3957         } else {
3958                 /* FIXME: check for float32 and AC3? */
3959         }
3960
3961         return 1;
3962 }
3963 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3964
3965 /*
3966  * PCM stuff
3967  */
3968 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3969                                       struct hda_codec *codec,
3970                                       struct snd_pcm_substream *substream)
3971 {
3972         return 0;
3973 }
3974
3975 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3976                                    struct hda_codec *codec,
3977                                    unsigned int stream_tag,
3978                                    unsigned int format,
3979                                    struct snd_pcm_substream *substream)
3980 {
3981         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3982         return 0;
3983 }
3984
3985 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3986                                    struct hda_codec *codec,
3987                                    struct snd_pcm_substream *substream)
3988 {
3989         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3990         return 0;
3991 }
3992
3993 static int set_pcm_default_values(struct hda_codec *codec,
3994                                   struct hda_pcm_stream *info)
3995 {
3996         int err;
3997
3998         /* query support PCM information from the given NID */
3999         if (info->nid && (!info->rates || !info->formats)) {
4000                 err = snd_hda_query_supported_pcm(codec, info->nid,
4001                                 info->rates ? NULL : &info->rates,
4002                                 info->formats ? NULL : &info->formats,
4003                                 info->maxbps ? NULL : &info->maxbps);
4004                 if (err < 0)
4005                         return err;
4006         }
4007         if (info->ops.open == NULL)
4008                 info->ops.open = hda_pcm_default_open_close;
4009         if (info->ops.close == NULL)
4010                 info->ops.close = hda_pcm_default_open_close;
4011         if (info->ops.prepare == NULL) {
4012                 if (snd_BUG_ON(!info->nid))
4013                         return -EINVAL;
4014                 info->ops.prepare = hda_pcm_default_prepare;
4015         }
4016         if (info->ops.cleanup == NULL) {
4017                 if (snd_BUG_ON(!info->nid))
4018                         return -EINVAL;
4019                 info->ops.cleanup = hda_pcm_default_cleanup;
4020         }
4021         return 0;
4022 }
4023
4024 /*
4025  * codec prepare/cleanup entries
4026  */
4027 int snd_hda_codec_prepare(struct hda_codec *codec,
4028                           struct hda_pcm_stream *hinfo,
4029                           unsigned int stream,
4030                           unsigned int format,
4031                           struct snd_pcm_substream *substream)
4032 {
4033         int ret;
4034         mutex_lock(&codec->bus->prepare_mutex);
4035         ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4036         if (ret >= 0)
4037                 purify_inactive_streams(codec);
4038         mutex_unlock(&codec->bus->prepare_mutex);
4039         return ret;
4040 }
4041 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
4042
4043 void snd_hda_codec_cleanup(struct hda_codec *codec,
4044                            struct hda_pcm_stream *hinfo,
4045                            struct snd_pcm_substream *substream)
4046 {
4047         mutex_lock(&codec->bus->prepare_mutex);
4048         hinfo->ops.cleanup(hinfo, codec, substream);
4049         mutex_unlock(&codec->bus->prepare_mutex);
4050 }
4051 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
4052
4053 /* global */
4054 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4055         "Audio", "SPDIF", "HDMI", "Modem"
4056 };
4057
4058 /*
4059  * get the empty PCM device number to assign
4060  *
4061  * note the max device number is limited by HDA_MAX_PCMS, currently 10
4062  */
4063 static int get_empty_pcm_device(struct hda_bus *bus, int type)
4064 {
4065         /* audio device indices; not linear to keep compatibility */
4066         static int audio_idx[HDA_PCM_NTYPES][5] = {
4067                 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4068                 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
4069                 [HDA_PCM_TYPE_HDMI]  = { 3, 7, 8, 9, -1 },
4070                 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
4071         };
4072         int i;
4073
4074         if (type >= HDA_PCM_NTYPES) {
4075                 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4076                 return -EINVAL;
4077         }
4078
4079         for (i = 0; audio_idx[type][i] >= 0 ; i++)
4080                 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4081                         return audio_idx[type][i];
4082
4083         /* non-fixed slots starting from 10 */
4084         for (i = 10; i < 32; i++) {
4085                 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4086                         return i;
4087         }
4088
4089         snd_printk(KERN_WARNING "Too many %s devices\n",
4090                 snd_hda_pcm_type_name[type]);
4091         return -EAGAIN;
4092 }
4093
4094 /*
4095  * attach a new PCM stream
4096  */
4097 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4098 {
4099         struct hda_bus *bus = codec->bus;
4100         struct hda_pcm_stream *info;
4101         int stream, err;
4102
4103         if (snd_BUG_ON(!pcm->name))
4104                 return -EINVAL;
4105         for (stream = 0; stream < 2; stream++) {
4106                 info = &pcm->stream[stream];
4107                 if (info->substreams) {
4108                         err = set_pcm_default_values(codec, info);
4109                         if (err < 0)
4110                                 return err;
4111                 }
4112         }
4113         return bus->ops.attach_pcm(bus, codec, pcm);
4114 }
4115
4116 /* assign all PCMs of the given codec */
4117 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4118 {
4119         unsigned int pcm;
4120         int err;
4121
4122         if (!codec->num_pcms) {
4123                 if (!codec->patch_ops.build_pcms)
4124                         return 0;
4125                 err = codec->patch_ops.build_pcms(codec);
4126                 if (err < 0) {
4127                         printk(KERN_ERR "hda_codec: cannot build PCMs"
4128                                "for #%d (error %d)\n", codec->addr, err);
4129                         err = snd_hda_codec_reset(codec);
4130                         if (err < 0) {
4131                                 printk(KERN_ERR
4132                                        "hda_codec: cannot revert codec\n");
4133                                 return err;
4134                         }
4135                 }
4136         }
4137         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4138                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4139                 int dev;
4140
4141                 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4142                         continue; /* no substreams assigned */
4143
4144                 if (!cpcm->pcm) {
4145                         dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4146                         if (dev < 0)
4147                                 continue; /* no fatal error */
4148                         cpcm->device = dev;
4149                         err = snd_hda_attach_pcm(codec, cpcm);
4150                         if (err < 0) {
4151                                 printk(KERN_ERR "hda_codec: cannot attach "
4152                                        "PCM stream %d for codec #%d\n",
4153                                        dev, codec->addr);
4154                                 continue; /* no fatal error */
4155                         }
4156                 }
4157         }
4158         return 0;
4159 }
4160
4161 /**
4162  * snd_hda_build_pcms - build PCM information
4163  * @bus: the BUS
4164  *
4165  * Create PCM information for each codec included in the bus.
4166  *
4167  * The build_pcms codec patch is requested to set up codec->num_pcms and
4168  * codec->pcm_info properly.  The array is referred by the top-level driver
4169  * to create its PCM instances.
4170  * The allocated codec->pcm_info should be released in codec->patch_ops.free
4171  * callback.
4172  *
4173  * At least, substreams, channels_min and channels_max must be filled for
4174  * each stream.  substreams = 0 indicates that the stream doesn't exist.
4175  * When rates and/or formats are zero, the supported values are queried
4176  * from the given nid.  The nid is used also by the default ops.prepare
4177  * and ops.cleanup callbacks.
4178  *
4179  * The driver needs to call ops.open in its open callback.  Similarly,
4180  * ops.close is supposed to be called in the close callback.
4181  * ops.prepare should be called in the prepare or hw_params callback
4182  * with the proper parameters for set up.
4183  * ops.cleanup should be called in hw_free for clean up of streams.
4184  *
4185  * This function returns 0 if successful, or a negative error code.
4186  */
4187 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
4188 {
4189         struct hda_codec *codec;
4190
4191         list_for_each_entry(codec, &bus->codec_list, list) {
4192                 int err = snd_hda_codec_build_pcms(codec);
4193                 if (err < 0)
4194                         return err;
4195         }
4196         return 0;
4197 }
4198 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
4199
4200 /**
4201  * snd_hda_check_board_config - compare the current codec with the config table
4202  * @codec: the HDA codec
4203  * @num_configs: number of config enums
4204  * @models: array of model name strings
4205  * @tbl: configuration table, terminated by null entries
4206  *
4207  * Compares the modelname or PCI subsystem id of the current codec with the
4208  * given configuration table.  If a matching entry is found, returns its
4209  * config value (supposed to be 0 or positive).
4210  *
4211  * If no entries are matching, the function returns a negative value.
4212  */
4213 int snd_hda_check_board_config(struct hda_codec *codec,
4214                                int num_configs, const char * const *models,
4215                                const struct snd_pci_quirk *tbl)
4216 {
4217         if (codec->modelname && models) {
4218                 int i;
4219                 for (i = 0; i < num_configs; i++) {
4220                         if (models[i] &&
4221                             !strcmp(codec->modelname, models[i])) {
4222                                 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4223                                            "selected\n", models[i]);
4224                                 return i;
4225                         }
4226                 }
4227         }
4228
4229         if (!codec->bus->pci || !tbl)
4230                 return -1;
4231
4232         tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4233         if (!tbl)
4234                 return -1;
4235         if (tbl->value >= 0 && tbl->value < num_configs) {
4236 #ifdef CONFIG_SND_DEBUG_VERBOSE
4237                 char tmp[10];
4238                 const char *model = NULL;
4239                 if (models)
4240                         model = models[tbl->value];
4241                 if (!model) {
4242                         sprintf(tmp, "#%d", tbl->value);
4243                         model = tmp;
4244                 }
4245                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4246                             "for config %x:%x (%s)\n",
4247                             model, tbl->subvendor, tbl->subdevice,
4248                             (tbl->name ? tbl->name : "Unknown device"));
4249 #endif
4250                 return tbl->value;
4251         }
4252         return -1;
4253 }
4254 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
4255
4256 /**
4257  * snd_hda_check_board_codec_sid_config - compare the current codec
4258                                         subsystem ID with the
4259                                         config table
4260
4261            This is important for Gateway notebooks with SB450 HDA Audio
4262            where the vendor ID of the PCI device is:
4263                 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4264            and the vendor/subvendor are found only at the codec.
4265
4266  * @codec: the HDA codec
4267  * @num_configs: number of config enums
4268  * @models: array of model name strings
4269  * @tbl: configuration table, terminated by null entries
4270  *
4271  * Compares the modelname or PCI subsystem id of the current codec with the
4272  * given configuration table.  If a matching entry is found, returns its
4273  * config value (supposed to be 0 or positive).
4274  *
4275  * If no entries are matching, the function returns a negative value.
4276  */
4277 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4278                                int num_configs, const char * const *models,
4279                                const struct snd_pci_quirk *tbl)
4280 {
4281         const struct snd_pci_quirk *q;
4282
4283         /* Search for codec ID */
4284         for (q = tbl; q->subvendor; q++) {
4285                 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4286                 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4287                 if ((codec->subsystem_id & mask) == id)
4288                         break;
4289         }
4290
4291         if (!q->subvendor)
4292                 return -1;
4293
4294         tbl = q;
4295
4296         if (tbl->value >= 0 && tbl->value < num_configs) {
4297 #ifdef CONFIG_SND_DEBUG_VERBOSE
4298                 char tmp[10];
4299                 const char *model = NULL;
4300                 if (models)
4301                         model = models[tbl->value];
4302                 if (!model) {
4303                         sprintf(tmp, "#%d", tbl->value);
4304                         model = tmp;
4305                 }
4306                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4307                             "for config %x:%x (%s)\n",
4308                             model, tbl->subvendor, tbl->subdevice,
4309                             (tbl->name ? tbl->name : "Unknown device"));
4310 #endif
4311                 return tbl->value;
4312         }
4313         return -1;
4314 }
4315 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4316
4317 /**
4318  * snd_hda_add_new_ctls - create controls from the array
4319  * @codec: the HDA codec
4320  * @knew: the array of struct snd_kcontrol_new
4321  *
4322  * This helper function creates and add new controls in the given array.
4323  * The array must be terminated with an empty entry as terminator.
4324  *
4325  * Returns 0 if successful, or a negative error code.
4326  */
4327 int snd_hda_add_new_ctls(struct hda_codec *codec,
4328                          const struct snd_kcontrol_new *knew)
4329 {
4330         int err;
4331
4332         for (; knew->name; knew++) {
4333                 struct snd_kcontrol *kctl;
4334                 int addr = 0, idx = 0;
4335                 if (knew->iface == -1)  /* skip this codec private value */
4336                         continue;
4337                 for (;;) {
4338                         kctl = snd_ctl_new1(knew, codec);
4339                         if (!kctl)
4340                                 return -ENOMEM;
4341                         if (addr > 0)
4342                                 kctl->id.device = addr;
4343                         if (idx > 0)
4344                                 kctl->id.index = idx;
4345                         err = snd_hda_ctl_add(codec, 0, kctl);
4346                         if (!err)
4347                                 break;
4348                         /* try first with another device index corresponding to
4349                          * the codec addr; if it still fails (or it's the
4350                          * primary codec), then try another control index
4351                          */
4352                         if (!addr && codec->addr)
4353                                 addr = codec->addr;
4354                         else if (!idx && !knew->index) {
4355                                 idx = find_empty_mixer_ctl_idx(codec,
4356                                                                knew->name);
4357                                 if (idx <= 0)
4358                                         return err;
4359                         } else
4360                                 return err;
4361                 }
4362         }
4363         return 0;
4364 }
4365 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4366
4367 #ifdef CONFIG_SND_HDA_POWER_SAVE
4368 static void hda_power_work(struct work_struct *work)
4369 {
4370         struct hda_codec *codec =
4371                 container_of(work, struct hda_codec, power_work.work);
4372         struct hda_bus *bus = codec->bus;
4373
4374         spin_lock(&codec->power_lock);
4375         if (codec->power_transition > 0) { /* during power-up sequence? */
4376                 spin_unlock(&codec->power_lock);
4377                 return;
4378         }
4379         if (!codec->power_on || codec->power_count) {
4380                 codec->power_transition = 0;
4381                 spin_unlock(&codec->power_lock);
4382                 return;
4383         }
4384         spin_unlock(&codec->power_lock);
4385
4386         hda_call_codec_suspend(codec);
4387         if (bus->ops.pm_notify)
4388                 bus->ops.pm_notify(bus);
4389 }
4390
4391 static void hda_keep_power_on(struct hda_codec *codec)
4392 {
4393         spin_lock(&codec->power_lock);
4394         codec->power_count++;
4395         codec->power_on = 1;
4396         codec->power_jiffies = jiffies;
4397         spin_unlock(&codec->power_lock);
4398 }
4399
4400 /* update the power on/off account with the current jiffies */
4401 void snd_hda_update_power_acct(struct hda_codec *codec)
4402 {
4403         unsigned long delta = jiffies - codec->power_jiffies;
4404         if (codec->power_on)
4405                 codec->power_on_acct += delta;
4406         else
4407                 codec->power_off_acct += delta;
4408         codec->power_jiffies += delta;
4409 }
4410
4411 /* Transition to powered up, if wait_power_down then wait for a pending
4412  * transition to D3 to complete. A pending D3 transition is indicated
4413  * with power_transition == -1. */
4414 static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
4415 {
4416         struct hda_bus *bus = codec->bus;
4417
4418         spin_lock(&codec->power_lock);
4419         codec->power_count++;
4420         /* Return if power_on or transitioning to power_on, unless currently
4421          * powering down. */
4422         if ((codec->power_on || codec->power_transition > 0) &&
4423             !(wait_power_down && codec->power_transition < 0)) {
4424                 spin_unlock(&codec->power_lock);
4425                 return;
4426         }
4427         spin_unlock(&codec->power_lock);
4428
4429         cancel_delayed_work_sync(&codec->power_work);
4430
4431         spin_lock(&codec->power_lock);
4432         /* If the power down delayed work was cancelled above before starting,
4433          * then there is no need to go through power up here.
4434          */
4435         if (codec->power_on) {
4436                 spin_unlock(&codec->power_lock);
4437                 return;
4438         }
4439         trace_hda_power_up(codec);
4440         snd_hda_update_power_acct(codec);
4441         codec->power_on = 1;
4442         codec->power_jiffies = jiffies;
4443         codec->power_transition = 1; /* avoid reentrance */
4444         spin_unlock(&codec->power_lock);
4445
4446         if (bus->ops.pm_notify)
4447                 bus->ops.pm_notify(bus);
4448         hda_call_codec_resume(codec);
4449
4450         spin_lock(&codec->power_lock);
4451         codec->power_transition = 0;
4452         spin_unlock(&codec->power_lock);
4453 }
4454
4455 /**
4456  * snd_hda_power_up - Power-up the codec
4457  * @codec: HD-audio codec
4458  *
4459  * Increment the power-up counter and power up the hardware really when
4460  * not turned on yet.
4461  */
4462 void snd_hda_power_up(struct hda_codec *codec)
4463 {
4464         __snd_hda_power_up(codec, false);
4465 }
4466 EXPORT_SYMBOL_HDA(snd_hda_power_up);
4467
4468 /**
4469  * snd_hda_power_up_d3wait - Power-up the codec after waiting for any pending
4470  *   D3 transition to complete.  This differs from snd_hda_power_up() when
4471  *   power_transition == -1.  snd_hda_power_up sees this case as a nop,
4472  *   snd_hda_power_up_d3wait waits for the D3 transition to complete then powers
4473  *   back up.
4474  * @codec: HD-audio codec
4475  *
4476  * Cancel any power down operation hapenning on the work queue, then power up.
4477  */
4478 void snd_hda_power_up_d3wait(struct hda_codec *codec)
4479 {
4480         /* This will cancel and wait for pending power_work to complete. */
4481         __snd_hda_power_up(codec, true);
4482 }
4483 EXPORT_SYMBOL_HDA(snd_hda_power_up_d3wait);
4484
4485 #define power_save(codec)       \
4486         ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4487
4488 /**
4489  * snd_hda_power_down - Power-down the codec
4490  * @codec: HD-audio codec
4491  *
4492  * Decrement the power-up counter and schedules the power-off work if
4493  * the counter rearches to zero.
4494  */
4495 void snd_hda_power_down(struct hda_codec *codec)
4496 {
4497         spin_lock(&codec->power_lock);
4498         --codec->power_count;
4499         if (!codec->power_on || codec->power_count || codec->power_transition) {
4500                 spin_unlock(&codec->power_lock);
4501                 return;
4502         }
4503         if (power_save(codec)) {
4504                 codec->power_transition = -1; /* avoid reentrance */
4505                 queue_delayed_work(codec->bus->workq, &codec->power_work,
4506                                 msecs_to_jiffies(power_save(codec) * 1000));
4507         }
4508         spin_unlock(&codec->power_lock);
4509 }
4510 EXPORT_SYMBOL_HDA(snd_hda_power_down);
4511
4512 /**
4513  * snd_hda_check_amp_list_power - Check the amp list and update the power
4514  * @codec: HD-audio codec
4515  * @check: the object containing an AMP list and the status
4516  * @nid: NID to check / update
4517  *
4518  * Check whether the given NID is in the amp list.  If it's in the list,
4519  * check the current AMP status, and update the the power-status according
4520  * to the mute status.
4521  *
4522  * This function is supposed to be set or called from the check_power_status
4523  * patch ops.
4524  */
4525 int snd_hda_check_amp_list_power(struct hda_codec *codec,
4526                                  struct hda_loopback_check *check,
4527                                  hda_nid_t nid)
4528 {
4529         const struct hda_amp_list *p;
4530         int ch, v;
4531
4532         if (!check->amplist)
4533                 return 0;
4534         for (p = check->amplist; p->nid; p++) {
4535                 if (p->nid == nid)
4536                         break;
4537         }
4538         if (!p->nid)
4539                 return 0; /* nothing changed */
4540
4541         for (p = check->amplist; p->nid; p++) {
4542                 for (ch = 0; ch < 2; ch++) {
4543                         v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4544                                                    p->idx);
4545                         if (!(v & HDA_AMP_MUTE) && v > 0) {
4546                                 if (!check->power_on) {
4547                                         check->power_on = 1;
4548                                         snd_hda_power_up(codec);
4549                                 }
4550                                 return 1;
4551                         }
4552                 }
4553         }
4554         if (check->power_on) {
4555                 check->power_on = 0;
4556                 snd_hda_power_down(codec);
4557         }
4558         return 0;
4559 }
4560 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
4561 #endif
4562
4563 /*
4564  * Channel mode helper
4565  */
4566
4567 /**
4568  * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4569  */
4570 int snd_hda_ch_mode_info(struct hda_codec *codec,
4571                          struct snd_ctl_elem_info *uinfo,
4572                          const struct hda_channel_mode *chmode,
4573                          int num_chmodes)
4574 {
4575         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4576         uinfo->count = 1;
4577         uinfo->value.enumerated.items = num_chmodes;
4578         if (uinfo->value.enumerated.item >= num_chmodes)
4579                 uinfo->value.enumerated.item = num_chmodes - 1;
4580         sprintf(uinfo->value.enumerated.name, "%dch",
4581                 chmode[uinfo->value.enumerated.item].channels);
4582         return 0;
4583 }
4584 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4585
4586 /**
4587  * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4588  */
4589 int snd_hda_ch_mode_get(struct hda_codec *codec,
4590                         struct snd_ctl_elem_value *ucontrol,
4591                         const struct hda_channel_mode *chmode,
4592                         int num_chmodes,
4593                         int max_channels)
4594 {
4595         int i;
4596
4597         for (i = 0; i < num_chmodes; i++) {
4598                 if (max_channels == chmode[i].channels) {
4599                         ucontrol->value.enumerated.item[0] = i;
4600                         break;
4601                 }
4602         }
4603         return 0;
4604 }
4605 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4606
4607 /**
4608  * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4609  */
4610 int snd_hda_ch_mode_put(struct hda_codec *codec,
4611                         struct snd_ctl_elem_value *ucontrol,
4612                         const struct hda_channel_mode *chmode,
4613                         int num_chmodes,
4614                         int *max_channelsp)
4615 {
4616         unsigned int mode;
4617
4618         mode = ucontrol->value.enumerated.item[0];
4619         if (mode >= num_chmodes)
4620                 return -EINVAL;
4621         if (*max_channelsp == chmode[mode].channels)
4622                 return 0;
4623         /* change the current channel setting */
4624         *max_channelsp = chmode[mode].channels;
4625         if (chmode[mode].sequence)
4626                 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4627         return 1;
4628 }
4629 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4630
4631 /*
4632  * input MUX helper
4633  */
4634
4635 /**
4636  * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4637  */
4638 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4639                            struct snd_ctl_elem_info *uinfo)
4640 {
4641         unsigned int index;
4642
4643         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4644         uinfo->count = 1;
4645         uinfo->value.enumerated.items = imux->num_items;
4646         if (!imux->num_items)
4647                 return 0;
4648         index = uinfo->value.enumerated.item;
4649         if (index >= imux->num_items)
4650                 index = imux->num_items - 1;
4651         strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4652         return 0;
4653 }
4654 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4655
4656 /**
4657  * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4658  */
4659 int snd_hda_input_mux_put(struct hda_codec *codec,
4660                           const struct hda_input_mux *imux,
4661                           struct snd_ctl_elem_value *ucontrol,
4662                           hda_nid_t nid,
4663                           unsigned int *cur_val)
4664 {
4665         unsigned int idx;
4666
4667         if (!imux->num_items)
4668                 return 0;
4669         idx = ucontrol->value.enumerated.item[0];
4670         if (idx >= imux->num_items)
4671                 idx = imux->num_items - 1;
4672         if (*cur_val == idx)
4673                 return 0;
4674         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4675                                   imux->items[idx].index);
4676         *cur_val = idx;
4677         return 1;
4678 }
4679 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4680
4681
4682 /*
4683  * Multi-channel / digital-out PCM helper functions
4684  */
4685
4686 /* setup SPDIF output stream */
4687 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4688                                  unsigned int stream_tag, unsigned int format)
4689 {
4690         struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4691
4692         /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4693         if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4694                 set_dig_out_convert(codec, nid,
4695                                     spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
4696                                     -1);
4697         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4698         if (codec->slave_dig_outs) {
4699                 const hda_nid_t *d;
4700                 for (d = codec->slave_dig_outs; *d; d++)
4701                         snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4702                                                    format);
4703         }
4704         /* turn on again (if needed) */
4705         if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4706                 set_dig_out_convert(codec, nid,
4707                                     spdif->ctls & 0xff, -1);
4708 }
4709
4710 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4711 {
4712         snd_hda_codec_cleanup_stream(codec, nid);
4713         if (codec->slave_dig_outs) {
4714                 const hda_nid_t *d;
4715                 for (d = codec->slave_dig_outs; *d; d++)
4716                         snd_hda_codec_cleanup_stream(codec, *d);
4717         }
4718 }
4719
4720 /**
4721  * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4722  * @bus: HD-audio bus
4723  */
4724 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4725 {
4726         struct hda_codec *codec;
4727
4728         if (!bus)
4729                 return;
4730         list_for_each_entry(codec, &bus->codec_list, list) {
4731                 if (hda_codec_is_power_on(codec) &&
4732                     codec->patch_ops.reboot_notify)
4733                         codec->patch_ops.reboot_notify(codec);
4734         }
4735 }
4736 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
4737
4738 /**
4739  * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4740  */
4741 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4742                                struct hda_multi_out *mout)
4743 {
4744         mutex_lock(&codec->spdif_mutex);
4745         if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4746                 /* already opened as analog dup; reset it once */
4747                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4748         mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4749         mutex_unlock(&codec->spdif_mutex);
4750         return 0;
4751 }
4752 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
4753
4754 /**
4755  * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4756  */
4757 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4758                                   struct hda_multi_out *mout,
4759                                   unsigned int stream_tag,
4760                                   unsigned int format,
4761                                   struct snd_pcm_substream *substream)
4762 {
4763         mutex_lock(&codec->spdif_mutex);
4764         setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4765         mutex_unlock(&codec->spdif_mutex);
4766         return 0;
4767 }
4768 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
4769
4770 /**
4771  * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4772  */
4773 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4774                                   struct hda_multi_out *mout)
4775 {
4776         mutex_lock(&codec->spdif_mutex);
4777         cleanup_dig_out_stream(codec, mout->dig_out_nid);
4778         mutex_unlock(&codec->spdif_mutex);
4779         return 0;
4780 }
4781 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4782
4783 /**
4784  * snd_hda_multi_out_dig_close - release the digital out stream
4785  */
4786 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4787                                 struct hda_multi_out *mout)
4788 {
4789         mutex_lock(&codec->spdif_mutex);
4790         mout->dig_out_used = 0;
4791         mutex_unlock(&codec->spdif_mutex);
4792         return 0;
4793 }
4794 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
4795
4796 /**
4797  * snd_hda_multi_out_analog_open - open analog outputs
4798  *
4799  * Open analog outputs and set up the hw-constraints.
4800  * If the digital outputs can be opened as slave, open the digital
4801  * outputs, too.
4802  */
4803 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4804                                   struct hda_multi_out *mout,
4805                                   struct snd_pcm_substream *substream,
4806                                   struct hda_pcm_stream *hinfo)
4807 {
4808         struct snd_pcm_runtime *runtime = substream->runtime;
4809         runtime->hw.channels_max = mout->max_channels;
4810         if (mout->dig_out_nid) {
4811                 if (!mout->analog_rates) {
4812                         mout->analog_rates = hinfo->rates;
4813                         mout->analog_formats = hinfo->formats;
4814                         mout->analog_maxbps = hinfo->maxbps;
4815                 } else {
4816                         runtime->hw.rates = mout->analog_rates;
4817                         runtime->hw.formats = mout->analog_formats;
4818                         hinfo->maxbps = mout->analog_maxbps;
4819                 }
4820                 if (!mout->spdif_rates) {
4821                         snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4822                                                     &mout->spdif_rates,
4823                                                     &mout->spdif_formats,
4824                                                     &mout->spdif_maxbps);
4825                 }
4826                 mutex_lock(&codec->spdif_mutex);
4827                 if (mout->share_spdif) {
4828                         if ((runtime->hw.rates & mout->spdif_rates) &&
4829                             (runtime->hw.formats & mout->spdif_formats)) {
4830                                 runtime->hw.rates &= mout->spdif_rates;
4831                                 runtime->hw.formats &= mout->spdif_formats;
4832                                 if (mout->spdif_maxbps < hinfo->maxbps)
4833                                         hinfo->maxbps = mout->spdif_maxbps;
4834                         } else {
4835                                 mout->share_spdif = 0;
4836                                 /* FIXME: need notify? */
4837                         }
4838                 }
4839                 mutex_unlock(&codec->spdif_mutex);
4840         }
4841         return snd_pcm_hw_constraint_step(substream->runtime, 0,
4842                                           SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4843 }
4844 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
4845
4846 /**
4847  * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4848  *
4849  * Set up the i/o for analog out.
4850  * When the digital out is available, copy the front out to digital out, too.
4851  */
4852 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4853                                      struct hda_multi_out *mout,
4854                                      unsigned int stream_tag,
4855                                      unsigned int format,
4856                                      struct snd_pcm_substream *substream)
4857 {
4858         const hda_nid_t *nids = mout->dac_nids;
4859         int chs = substream->runtime->channels;
4860         struct hda_spdif_out *spdif;
4861         int i;
4862
4863         mutex_lock(&codec->spdif_mutex);
4864         spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
4865         if (mout->dig_out_nid && mout->share_spdif &&
4866             mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4867                 if (chs == 2 &&
4868                     snd_hda_is_supported_format(codec, mout->dig_out_nid,
4869                                                 format) &&
4870                     !(spdif->status & IEC958_AES0_NONAUDIO)) {
4871                         mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4872                         setup_dig_out_stream(codec, mout->dig_out_nid,
4873                                              stream_tag, format);
4874                 } else {
4875                         mout->dig_out_used = 0;
4876                         cleanup_dig_out_stream(codec, mout->dig_out_nid);
4877                 }
4878         }
4879         mutex_unlock(&codec->spdif_mutex);
4880
4881         /* front */
4882         snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4883                                    0, format);
4884         if (!mout->no_share_stream &&
4885             mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4886                 /* headphone out will just decode front left/right (stereo) */
4887                 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4888                                            0, format);
4889         /* extra outputs copied from front */
4890         for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4891                 if (!mout->no_share_stream && mout->hp_out_nid[i])
4892                         snd_hda_codec_setup_stream(codec,
4893                                                    mout->hp_out_nid[i],
4894                                                    stream_tag, 0, format);
4895         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4896                 if (!mout->no_share_stream && mout->extra_out_nid[i])
4897                         snd_hda_codec_setup_stream(codec,
4898                                                    mout->extra_out_nid[i],
4899                                                    stream_tag, 0, format);
4900
4901         /* surrounds */
4902         for (i = 1; i < mout->num_dacs; i++) {
4903                 if (chs >= (i + 1) * 2) /* independent out */
4904                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4905                                                    i * 2, format);
4906                 else if (!mout->no_share_stream) /* copy front */
4907                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4908                                                    0, format);
4909         }
4910         return 0;
4911 }
4912 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
4913
4914 /**
4915  * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4916  */
4917 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4918                                      struct hda_multi_out *mout)
4919 {
4920         const hda_nid_t *nids = mout->dac_nids;
4921         int i;
4922
4923         for (i = 0; i < mout->num_dacs; i++)
4924                 snd_hda_codec_cleanup_stream(codec, nids[i]);
4925         if (mout->hp_nid)
4926                 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4927         for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4928                 if (mout->hp_out_nid[i])
4929                         snd_hda_codec_cleanup_stream(codec,
4930                                                      mout->hp_out_nid[i]);
4931         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4932                 if (mout->extra_out_nid[i])
4933                         snd_hda_codec_cleanup_stream(codec,
4934                                                      mout->extra_out_nid[i]);
4935         mutex_lock(&codec->spdif_mutex);
4936         if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4937                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4938                 mout->dig_out_used = 0;
4939         }
4940         mutex_unlock(&codec->spdif_mutex);
4941         return 0;
4942 }
4943 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4944
4945 /**
4946  * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
4947  *
4948  * Guess the suitable VREF pin bits to be set as the pin-control value.
4949  * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
4950  */
4951 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
4952 {
4953         unsigned int pincap;
4954         unsigned int oldval;
4955         oldval = snd_hda_codec_read(codec, pin, 0,
4956                                     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4957         pincap = snd_hda_query_pin_caps(codec, pin);
4958         pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
4959         /* Exception: if the default pin setup is vref50, we give it priority */
4960         if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
4961                 return AC_PINCTL_VREF_80;
4962         else if (pincap & AC_PINCAP_VREF_50)
4963                 return AC_PINCTL_VREF_50;
4964         else if (pincap & AC_PINCAP_VREF_100)
4965                 return AC_PINCTL_VREF_100;
4966         else if (pincap & AC_PINCAP_VREF_GRD)
4967                 return AC_PINCTL_VREF_GRD;
4968         return AC_PINCTL_VREF_HIZ;
4969 }
4970 EXPORT_SYMBOL_HDA(snd_hda_get_default_vref);
4971
4972 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
4973                          unsigned int val, bool cached)
4974 {
4975         if (val) {
4976                 unsigned int cap = snd_hda_query_pin_caps(codec, pin);
4977                 if (cap && (val & AC_PINCTL_OUT_EN)) {
4978                         if (!(cap & AC_PINCAP_OUT))
4979                                 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
4980                         else if ((val & AC_PINCTL_HP_EN) &&
4981                                  !(cap & AC_PINCAP_HP_DRV))
4982                                 val &= ~AC_PINCTL_HP_EN;
4983                 }
4984                 if (cap && (val & AC_PINCTL_IN_EN)) {
4985                         if (!(cap & AC_PINCAP_IN))
4986                                 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
4987                 }
4988         }
4989         if (cached)
4990                 return snd_hda_codec_update_cache(codec, pin, 0,
4991                                 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4992         else
4993                 return snd_hda_codec_write(codec, pin, 0,
4994                                            AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4995 }
4996 EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl);
4997
4998 /**
4999  * snd_hda_add_imux_item - Add an item to input_mux
5000  *
5001  * When the same label is used already in the existing items, the number
5002  * suffix is appended to the label.  This label index number is stored
5003  * to type_idx when non-NULL pointer is given.
5004  */
5005 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5006                           int index, int *type_idx)
5007 {
5008         int i, label_idx = 0;
5009         if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5010                 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5011                 return -EINVAL;
5012         }
5013         for (i = 0; i < imux->num_items; i++) {
5014                 if (!strncmp(label, imux->items[i].label, strlen(label)))
5015                         label_idx++;
5016         }
5017         if (type_idx)
5018                 *type_idx = label_idx;
5019         if (label_idx > 0)
5020                 snprintf(imux->items[imux->num_items].label,
5021                          sizeof(imux->items[imux->num_items].label),
5022                          "%s %d", label, label_idx);
5023         else
5024                 strlcpy(imux->items[imux->num_items].label, label,
5025                         sizeof(imux->items[imux->num_items].label));
5026         imux->items[imux->num_items].index = index;
5027         imux->num_items++;
5028         return 0;
5029 }
5030 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5031
5032
5033 #ifdef CONFIG_PM
5034 /*
5035  * power management
5036  */
5037
5038 /**
5039  * snd_hda_suspend - suspend the codecs
5040  * @bus: the HDA bus
5041  *
5042  * Returns 0 if successful.
5043  */
5044 int snd_hda_suspend(struct hda_bus *bus)
5045 {
5046         struct hda_codec *codec;
5047
5048         list_for_each_entry(codec, &bus->codec_list, list) {
5049                 if (hda_codec_is_power_on(codec))
5050                         hda_call_codec_suspend(codec);
5051         }
5052         return 0;
5053 }
5054 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5055
5056 /**
5057  * snd_hda_resume - resume the codecs
5058  * @bus: the HDA bus
5059  *
5060  * Returns 0 if successful.
5061  *
5062  * This function is defined only when POWER_SAVE isn't set.
5063  * In the power-save mode, the codec is resumed dynamically.
5064  */
5065 int snd_hda_resume(struct hda_bus *bus)
5066 {
5067         struct hda_codec *codec;
5068
5069         list_for_each_entry(codec, &bus->codec_list, list) {
5070                 hda_call_codec_resume(codec);
5071         }
5072         return 0;
5073 }
5074 EXPORT_SYMBOL_HDA(snd_hda_resume);
5075 #endif /* CONFIG_PM */
5076
5077 /*
5078  * generic arrays
5079  */
5080
5081 /**
5082  * snd_array_new - get a new element from the given array
5083  * @array: the array object
5084  *
5085  * Get a new element from the given array.  If it exceeds the
5086  * pre-allocated array size, re-allocate the array.
5087  *
5088  * Returns NULL if allocation failed.
5089  */
5090 void *snd_array_new(struct snd_array *array)
5091 {
5092         if (array->used >= array->alloced) {
5093                 int num = array->alloced + array->alloc_align;
5094                 int size = (num + 1) * array->elem_size;
5095                 int oldsize = array->alloced * array->elem_size;
5096                 void *nlist;
5097                 if (snd_BUG_ON(num >= 4096))
5098                         return NULL;
5099                 nlist = krealloc(array->list, size, GFP_KERNEL);
5100                 if (!nlist)
5101                         return NULL;
5102                 memset(nlist + oldsize, 0, size - oldsize);
5103                 array->list = nlist;
5104                 array->alloced = num;
5105         }
5106         return snd_array_elem(array, array->used++);
5107 }
5108 EXPORT_SYMBOL_HDA(snd_array_new);
5109
5110 /**
5111  * snd_array_free - free the given array elements
5112  * @array: the array object
5113  */
5114 void snd_array_free(struct snd_array *array)
5115 {
5116         kfree(array->list);
5117         array->used = 0;
5118         array->alloced = 0;
5119         array->list = NULL;
5120 }
5121 EXPORT_SYMBOL_HDA(snd_array_free);
5122
5123 /**
5124  * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5125  * @pcm: PCM caps bits
5126  * @buf: the string buffer to write
5127  * @buflen: the max buffer length
5128  *
5129  * used by hda_proc.c and hda_eld.c
5130  */
5131 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5132 {
5133         static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5134         int i, j;
5135
5136         for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5137                 if (pcm & (AC_SUPPCM_BITS_8 << i))
5138                         j += snprintf(buf + j, buflen - j,  " %d", bits[i]);
5139
5140         buf[j] = '\0'; /* necessary when j == 0 */
5141 }
5142 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5143
5144 MODULE_DESCRIPTION("HDA codec core");
5145 MODULE_LICENSE("GPL");