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