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