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