sound/pci/hda/hda_codec.c

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