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