sound/pci/hda/hda_codec.c

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