sound/pci/hda/hda_codec.c

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