sound/pci/hda/hda_codec.c

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