sound/pci/hda/hda_codec.c

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