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