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