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 <sound/hda_hwdep.h>
  34
  35 #ifdef CONFIG_SND_HDA_POWER_SAVE
  36 /* define this option here to hide as static */
  37 static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT;
  38 module_param(power_save, int, 0644);
  39 MODULE_PARM_DESC(power_save, "Automatic power-saving timeout "
  40                  "(in second, 0 = disable).");
  41 #endif
  42
  43 /*
  44  * vendor / preset table
  45  */
  46
  47 struct hda_vendor_id {
  48         unsigned int id;
  49         const char *name;
  50 };
  51
  52 /* codec vendor labels */
  53 static struct hda_vendor_id hda_vendor_ids[] = {
  54         { 0x1002, "ATI" },
  55         { 0x1057, "Motorola" },
  56         { 0x1095, "Silicon Image" },
  57         { 0x10ec, "Realtek" },
  58         { 0x1106, "VIA" },
  59         { 0x111d, "IDT" },
  60         { 0x11c1, "LSI" },
  61         { 0x11d4, "Analog Devices" },
  62         { 0x13f6, "C-Media" },
  63         { 0x14f1, "Conexant" },
  64         { 0x17e8, "Chrontel" },
  65         { 0x1854, "LG" },
  66         { 0x434d, "C-Media" },
  67         { 0x8384, "SigmaTel" },
  68         {} /* terminator */
  69 };
  70
  71 /* codec presets */
  72 #include "hda_patch.h"
  73
  74
  75 #ifdef CONFIG_SND_HDA_POWER_SAVE
  76 static void hda_power_work(struct work_struct *work);
  77 static void hda_keep_power_on(struct hda_codec *codec);
  78 #else
  79 static inline void hda_keep_power_on(struct hda_codec *codec) {}
  80 #endif
  81
  82 /**
  83  * snd_hda_codec_read - send a command and get the response
  84  * @codec: the HDA codec
  85  * @nid: NID to send the command
  86  * @direct: direct flag
  87  * @verb: the verb to send
  88  * @parm: the parameter for the verb
  89  *
  90  * Send a single command and read the corresponding response.
  91  *
  92  * Returns the obtained response value, or -1 for an error.
  93  */
  94 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
  95                                 int direct,
  96                                 unsigned int verb, unsigned int parm)
  97 {
  98         unsigned int res;
  99         snd_hda_power_up(codec);
 100         mutex_lock(&codec->bus->cmd_mutex);
 101         if (!codec->bus->ops.command(codec, nid, direct, verb, parm))
 102                 res = codec->bus->ops.get_response(codec);
 103         else
 104                 res = (unsigned int)-1;
 105         mutex_unlock(&codec->bus->cmd_mutex);
 106         snd_hda_power_down(codec);
 107         return res;
 108 }
 109
 110 /**
 111  * snd_hda_codec_write - send a single command without waiting for response
 112  * @codec: the HDA codec
 113  * @nid: NID to send the command
 114  * @direct: direct flag
 115  * @verb: the verb to send
 116  * @parm: the parameter for the verb
 117  *
 118  * Send a single command without waiting for response.
 119  *
 120  * Returns 0 if successful, or a negative error code.
 121  */
 122 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
 123                          unsigned int verb, unsigned int parm)
 124 {
 125         int err;
 126         snd_hda_power_up(codec);
 127         mutex_lock(&codec->bus->cmd_mutex);
 128         err = codec->bus->ops.command(codec, nid, direct, verb, parm);
 129         mutex_unlock(&codec->bus->cmd_mutex);
 130         snd_hda_power_down(codec);
 131         return err;
 132 }
 133
 134 /**
 135  * snd_hda_sequence_write - sequence writes
 136  * @codec: the HDA codec
 137  * @seq: VERB array to send
 138  *
 139  * Send the commands sequentially from the given array.
 140  * The array must be terminated with NID=0.
 141  */
 142 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
 143 {
 144         for (; seq->nid; seq++)
 145                 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
 146 }
 147
 148 /**
 149  * snd_hda_get_sub_nodes - get the range of sub nodes
 150  * @codec: the HDA codec
 151  * @nid: NID to parse
 152  * @start_id: the pointer to store the start NID
 153  *
 154  * Parse the NID and store the start NID of its sub-nodes.
 155  * Returns the number of sub-nodes.
 156  */
 157 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
 158                           hda_nid_t *start_id)
 159 {
 160         unsigned int parm;
 161
 162         parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
 163         if (parm == -1)
 164                 return 0;
 165         *start_id = (parm >> 16) & 0x7fff;
 166         return (int)(parm & 0x7fff);
 167 }
 168
 169 /**
 170  * snd_hda_get_connections - get connection list
 171  * @codec: the HDA codec
 172  * @nid: NID to parse
 173  * @conn_list: connection list array
 174  * @max_conns: max. number of connections to store
 175  *
 176  * Parses the connection list of the given widget and stores the list
 177  * of NIDs.
 178  *
 179  * Returns the number of connections, or a negative error code.
 180  */
 181 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
 182                             hda_nid_t *conn_list, int max_conns)
 183 {
 184         unsigned int parm;
 185         int i, conn_len, conns;
 186         unsigned int shift, num_elems, mask;
 187         hda_nid_t prev_nid;
 188
 189         snd_assert(conn_list && max_conns > 0, return -EINVAL);
 190
 191         parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
 192         if (parm & AC_CLIST_LONG) {
 193                 /* long form */
 194                 shift = 16;
 195                 num_elems = 2;
 196         } else {
 197                 /* short form */
 198                 shift = 8;
 199                 num_elems = 4;
 200         }
 201         conn_len = parm & AC_CLIST_LENGTH;
 202         mask = (1 << (shift-1)) - 1;
 203
 204         if (!conn_len)
 205                 return 0; /* no connection */
 206
 207         if (conn_len == 1) {
 208                 /* single connection */
 209                 parm = snd_hda_codec_read(codec, nid, 0,
 210                                           AC_VERB_GET_CONNECT_LIST, 0);
 211                 conn_list[0] = parm & mask;
 212                 return 1;
 213         }
 214
 215         /* multi connection */
 216         conns = 0;
 217         prev_nid = 0;
 218         for (i = 0; i < conn_len; i++) {
 219                 int range_val;
 220                 hda_nid_t val, n;
 221
 222                 if (i % num_elems == 0)
 223                         parm = snd_hda_codec_read(codec, nid, 0,
 224                                                   AC_VERB_GET_CONNECT_LIST, i);
 225                 range_val = !!(parm & (1 << (shift-1))); /* ranges */
 226                 val = parm & mask;
 227                 parm >>= shift;
 228                 if (range_val) {
 229                         /* ranges between the previous and this one */
 230                         if (!prev_nid || prev_nid >= val) {
 231                                 snd_printk(KERN_WARNING "hda_codec: "
 232                                            "invalid dep_range_val %x:%x\n",
 233                                            prev_nid, val);
 234                                 continue;
 235                         }
 236                         for (n = prev_nid + 1; n <= val; n++) {
 237                                 if (conns >= max_conns) {
 238                                         snd_printk(KERN_ERR
 239                                                    "Too many connections\n");
 240                                         return -EINVAL;
 241                                 }
 242                                 conn_list[conns++] = n;
 243                         }
 244                 } else {
 245                         if (conns >= max_conns) {
 246                                 snd_printk(KERN_ERR "Too many connections\n");
 247                                 return -EINVAL;
 248                         }
 249                         conn_list[conns++] = val;
 250                 }
 251                 prev_nid = val;
 252         }
 253         return conns;
 254 }
 255
 256
 257 /**
 258  * snd_hda_queue_unsol_event - add an unsolicited event to queue
 259  * @bus: the BUS
 260  * @res: unsolicited event (lower 32bit of RIRB entry)
 261  * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
 262  *
 263  * Adds the given event to the queue.  The events are processed in
 264  * the workqueue asynchronously.  Call this function in the interrupt
 265  * hanlder when RIRB receives an unsolicited event.
 266  *
 267  * Returns 0 if successful, or a negative error code.
 268  */
 269 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
 270 {
 271         struct hda_bus_unsolicited *unsol;
 272         unsigned int wp;
 273
 274         unsol = bus->unsol;
 275         if (!unsol)
 276                 return 0;
 277
 278         wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
 279         unsol->wp = wp;
 280
 281         wp <<= 1;
 282         unsol->queue[wp] = res;
 283         unsol->queue[wp + 1] = res_ex;
 284
 285         schedule_work(&unsol->work);
 286
 287         return 0;
 288 }
 289
 290 /*
 291  * process queueud unsolicited events
 292  */
 293 static void process_unsol_events(struct work_struct *work)
 294 {
 295         struct hda_bus_unsolicited *unsol =
 296                 container_of(work, struct hda_bus_unsolicited, work);
 297         struct hda_bus *bus = unsol->bus;
 298         struct hda_codec *codec;
 299         unsigned int rp, caddr, res;
 300
 301         while (unsol->rp != unsol->wp) {
 302                 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
 303                 unsol->rp = rp;
 304                 rp <<= 1;
 305                 res = unsol->queue[rp];
 306                 caddr = unsol->queue[rp + 1];
 307                 if (!(caddr & (1 << 4))) /* no unsolicited event? */
 308                         continue;
 309                 codec = bus->caddr_tbl[caddr & 0x0f];
 310                 if (codec && codec->patch_ops.unsol_event)
 311                         codec->patch_ops.unsol_event(codec, res);
 312         }
 313 }
 314
 315 /*
 316  * initialize unsolicited queue
 317  */
 318 static int __devinit init_unsol_queue(struct hda_bus *bus)
 319 {
 320         struct hda_bus_unsolicited *unsol;
 321
 322         if (bus->unsol) /* already initialized */
 323                 return 0;
 324
 325         unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
 326         if (!unsol) {
 327                 snd_printk(KERN_ERR "hda_codec: "
 328                            "can't allocate unsolicited queue\n");
 329                 return -ENOMEM;
 330         }
 331         INIT_WORK(&unsol->work, process_unsol_events);
 332         unsol->bus = bus;
 333         bus->unsol = unsol;
 334         return 0;
 335 }
 336
 337 /*
 338  * destructor
 339  */
 340 static void snd_hda_codec_free(struct hda_codec *codec);
 341
 342 static int snd_hda_bus_free(struct hda_bus *bus)
 343 {
 344         struct hda_codec *codec, *n;
 345
 346         if (!bus)
 347                 return 0;
 348         if (bus->unsol) {
 349                 flush_scheduled_work();
 350                 kfree(bus->unsol);
 351         }
 352         list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
 353                 snd_hda_codec_free(codec);
 354         }
 355         if (bus->ops.private_free)
 356                 bus->ops.private_free(bus);
 357         kfree(bus);
 358         return 0;
 359 }
 360
 361 static int snd_hda_bus_dev_free(struct snd_device *device)
 362 {
 363         struct hda_bus *bus = device->device_data;
 364         return snd_hda_bus_free(bus);
 365 }
 366
 367 /**
 368  * snd_hda_bus_new - create a HDA bus
 369  * @card: the card entry
 370  * @temp: the template for hda_bus information
 371  * @busp: the pointer to store the created bus instance
 372  *
 373  * Returns 0 if successful, or a negative error code.
 374  */
 375 int __devinit snd_hda_bus_new(struct snd_card *card,
 376                               const struct hda_bus_template *temp,
 377                               struct hda_bus **busp)
 378 {
 379         struct hda_bus *bus;
 380         int err;
 381         static struct snd_device_ops dev_ops = {
 382                 .dev_free = snd_hda_bus_dev_free,
 383         };
 384
 385         snd_assert(temp, return -EINVAL);
 386         snd_assert(temp->ops.command && temp->ops.get_response, return -EINVAL);
 387
 388         if (busp)
 389                 *busp = NULL;
 390
 391         bus = kzalloc(sizeof(*bus), GFP_KERNEL);
 392         if (bus == NULL) {
 393                 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
 394                 return -ENOMEM;
 395         }
 396
 397         bus->card = card;
 398         bus->private_data = temp->private_data;
 399         bus->pci = temp->pci;
 400         bus->modelname = temp->modelname;
 401         bus->ops = temp->ops;
 402
 403         mutex_init(&bus->cmd_mutex);
 404         INIT_LIST_HEAD(&bus->codec_list);
 405
 406         err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
 407         if (err < 0) {
 408                 snd_hda_bus_free(bus);
 409                 return err;
 410         }
 411         if (busp)
 412                 *busp = bus;
 413         return 0;
 414 }
 415
 416 #ifdef CONFIG_SND_HDA_GENERIC
 417 #define is_generic_config(codec) \
 418         (codec->bus->modelname && !strcmp(codec->bus->modelname, "generic"))
 419 #else
 420 #define is_generic_config(codec)        0
 421 #endif
 422
 423 /*
 424  * find a matching codec preset
 425  */
 426 static const struct hda_codec_preset __devinit *
 427 find_codec_preset(struct hda_codec *codec)
 428 {
 429         const struct hda_codec_preset **tbl, *preset;
 430
 431         if (is_generic_config(codec))
 432                 return NULL; /* use the generic parser */
 433
 434         for (tbl = hda_preset_tables; *tbl; tbl++) {
 435                 for (preset = *tbl; preset->id; preset++) {
 436                         u32 mask = preset->mask;
 437                         if (preset->afg && preset->afg != codec->afg)
 438                                 continue;
 439                         if (preset->mfg && preset->mfg != codec->mfg)
 440                                 continue;
 441                         if (!mask)
 442                                 mask = ~0;
 443                         if (preset->id == (codec->vendor_id & mask) &&
 444                             (!preset->rev ||
 445                              preset->rev == codec->revision_id))
 446                                 return preset;
 447                 }
 448         }
 449         return NULL;
 450 }
 451
 452 /*
 453  * snd_hda_get_codec_name - store the codec name
 454  */
 455 void snd_hda_get_codec_name(struct hda_codec *codec,
 456                             char *name, int namelen)
 457 {
 458         const struct hda_vendor_id *c;
 459         const char *vendor = NULL;
 460         u16 vendor_id = codec->vendor_id >> 16;
 461         char tmp[16];
 462
 463         for (c = hda_vendor_ids; c->id; c++) {
 464                 if (c->id == vendor_id) {
 465                         vendor = c->name;
 466                         break;
 467                 }
 468         }
 469         if (!vendor) {
 470                 sprintf(tmp, "Generic %04x", vendor_id);
 471                 vendor = tmp;
 472         }
 473         if (codec->preset && codec->preset->name)
 474                 snprintf(name, namelen, "%s %s", vendor, codec->preset->name);
 475         else
 476                 snprintf(name, namelen, "%s ID %x", vendor,
 477                          codec->vendor_id & 0xffff);
 478 }
 479
 480 /*
 481  * look for an AFG and MFG nodes
 482  */
 483 static void __devinit setup_fg_nodes(struct hda_codec *codec)
 484 {
 485         int i, total_nodes;
 486         hda_nid_t nid;
 487
 488         total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
 489         for (i = 0; i < total_nodes; i++, nid++) {
 490                 unsigned int func;
 491                 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
 492                 switch (func & 0xff) {
 493                 case AC_GRP_AUDIO_FUNCTION:
 494                         codec->afg = nid;
 495                         break;
 496                 case AC_GRP_MODEM_FUNCTION:
 497                         codec->mfg = nid;
 498                         break;
 499                 default:
 500                         break;
 501                 }
 502         }
 503 }
 504
 505 /*
 506  * read widget caps for each widget and store in cache
 507  */
 508 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
 509 {
 510         int i;
 511         hda_nid_t nid;
 512
 513         codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
 514                                                  &codec->start_nid);
 515         codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
 516         if (!codec->wcaps)
 517                 return -ENOMEM;
 518         nid = codec->start_nid;
 519         for (i = 0; i < codec->num_nodes; i++, nid++)
 520                 codec->wcaps[i] = snd_hda_param_read(codec, nid,
 521                                                      AC_PAR_AUDIO_WIDGET_CAP);
 522         return 0;
 523 }
 524
 525
 526 static void init_hda_cache(struct hda_cache_rec *cache,
 527                            unsigned int record_size);
 528 static void free_hda_cache(struct hda_cache_rec *cache);
 529
 530 /*
 531  * codec destructor
 532  */
 533 static void snd_hda_codec_free(struct hda_codec *codec)
 534 {
 535         if (!codec)
 536                 return;
 537 #ifdef CONFIG_SND_HDA_POWER_SAVE
 538         cancel_delayed_work(&codec->power_work);
 539         flush_scheduled_work();
 540 #endif
 541         list_del(&codec->list);
 542         codec->bus->caddr_tbl[codec->addr] = NULL;
 543         if (codec->patch_ops.free)
 544                 codec->patch_ops.free(codec);
 545         free_hda_cache(&codec->amp_cache);
 546         free_hda_cache(&codec->cmd_cache);
 547         kfree(codec->wcaps);
 548         kfree(codec);
 549 }
 550
 551 /**
 552  * snd_hda_codec_new - create a HDA codec
 553  * @bus: the bus to assign
 554  * @codec_addr: the codec address
 555  * @codecp: the pointer to store the generated codec
 556  *
 557  * Returns 0 if successful, or a negative error code.
 558  */
 559 int __devinit snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
 560                                 struct hda_codec **codecp)
 561 {
 562         struct hda_codec *codec;
 563         char component[13];
 564         int err;
 565
 566         snd_assert(bus, return -EINVAL);
 567         snd_assert(codec_addr <= HDA_MAX_CODEC_ADDRESS, return -EINVAL);
 568
 569         if (bus->caddr_tbl[codec_addr]) {
 570                 snd_printk(KERN_ERR "hda_codec: "
 571                            "address 0x%x is already occupied\n", codec_addr);
 572                 return -EBUSY;
 573         }
 574
 575         codec = kzalloc(sizeof(*codec), GFP_KERNEL);
 576         if (codec == NULL) {
 577                 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
 578                 return -ENOMEM;
 579         }
 580
 581         codec->bus = bus;
 582         codec->addr = codec_addr;
 583         mutex_init(&codec->spdif_mutex);
 584         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
 585         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
 586
 587 #ifdef CONFIG_SND_HDA_POWER_SAVE
 588         INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
 589         /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
 590          * the caller has to power down appropriatley after initialization
 591          * phase.
 592          */
 593         hda_keep_power_on(codec);
 594 #endif
 595
 596         list_add_tail(&codec->list, &bus->codec_list);
 597         bus->caddr_tbl[codec_addr] = codec;
 598
 599         codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
 600                                               AC_PAR_VENDOR_ID);
 601         if (codec->vendor_id == -1)
 602                 /* read again, hopefully the access method was corrected
 603                  * in the last read...
 604                  */
 605                 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
 606                                                       AC_PAR_VENDOR_ID);
 607         codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
 608                                                  AC_PAR_SUBSYSTEM_ID);
 609         codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
 610                                                 AC_PAR_REV_ID);
 611
 612         setup_fg_nodes(codec);
 613         if (!codec->afg && !codec->mfg) {
 614                 snd_printdd("hda_codec: no AFG or MFG node found\n");
 615                 snd_hda_codec_free(codec);
 616                 return -ENODEV;
 617         }
 618
 619         if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) {
 620                 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
 621                 snd_hda_codec_free(codec);
 622                 return -ENOMEM;
 623         }
 624
 625         if (!codec->subsystem_id) {
 626                 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
 627                 codec->subsystem_id =
 628                         snd_hda_codec_read(codec, nid, 0,
 629                                            AC_VERB_GET_SUBSYSTEM_ID, 0);
 630         }
 631
 632         codec->preset = find_codec_preset(codec);
 633         /* audio codec should override the mixer name */
 634         if (codec->afg || !*bus->card->mixername)
 635                 snd_hda_get_codec_name(codec, bus->card->mixername,
 636                                        sizeof(bus->card->mixername));
 637
 638         if (is_generic_config(codec)) {
 639                 err = snd_hda_parse_generic_codec(codec);
 640                 goto patched;
 641         }
 642         if (codec->preset && codec->preset->patch) {
 643                 err = codec->preset->patch(codec);
 644                 goto patched;
 645         }
 646
 647         /* call the default parser */
 648         err = snd_hda_parse_generic_codec(codec);
 649         if (err < 0)
 650                 printk(KERN_ERR "hda-codec: No codec parser is available\n");
 651
 652  patched:
 653         if (err < 0) {
 654                 snd_hda_codec_free(codec);
 655                 return err;
 656         }
 657
 658         if (codec->patch_ops.unsol_event)
 659                 init_unsol_queue(bus);
 660
 661         snd_hda_codec_proc_new(codec);
 662 #ifdef CONFIG_SND_HDA_HWDEP
 663         snd_hda_create_hwdep(codec);
 664 #endif
 665
 666         sprintf(component, "HDA:%08x", codec->vendor_id);
 667         snd_component_add(codec->bus->card, component);
 668
 669         if (codecp)
 670                 *codecp = codec;
 671         return 0;
 672 }
 673
 674 /**
 675  * snd_hda_codec_setup_stream - set up the codec for streaming
 676  * @codec: the CODEC to set up
 677  * @nid: the NID to set up
 678  * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
 679  * @channel_id: channel id to pass, zero based.
 680  * @format: stream format.
 681  */
 682 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
 683                                 u32 stream_tag,
 684                                 int channel_id, int format)
 685 {
 686         if (!nid)
 687                 return;
 688
 689         snd_printdd("hda_codec_setup_stream: "
 690                     "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
 691                     nid, stream_tag, channel_id, format);
 692         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
 693                             (stream_tag << 4) | channel_id);
 694         msleep(1);
 695         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
 696 }
 697
 698 /*
 699  * amp access functions
 700  */
 701
 702 /* FIXME: more better hash key? */
 703 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
 704 #define INFO_AMP_CAPS   (1<<0)
 705 #define INFO_AMP_VOL(ch)        (1 << (1 + (ch)))
 706
 707 /* initialize the hash table */
 708 static void __devinit init_hda_cache(struct hda_cache_rec *cache,
 709                                      unsigned int record_size)
 710 {
 711         memset(cache, 0, sizeof(*cache));
 712         memset(cache->hash, 0xff, sizeof(cache->hash));
 713         cache->record_size = record_size;
 714 }
 715
 716 static void free_hda_cache(struct hda_cache_rec *cache)
 717 {
 718         kfree(cache->buffer);
 719 }
 720
 721 /* query the hash.  allocate an entry if not found. */
 722 static struct hda_cache_head  *get_alloc_hash(struct hda_cache_rec *cache,
 723                                               u32 key)
 724 {
 725         u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
 726         u16 cur = cache->hash[idx];
 727         struct hda_cache_head *info;
 728
 729         while (cur != 0xffff) {
 730                 info = (struct hda_cache_head *)(cache->buffer +
 731                                                  cur * cache->record_size);
 732                 if (info->key == key)
 733                         return info;
 734                 cur = info->next;
 735         }
 736
 737         /* add a new hash entry */
 738         if (cache->num_entries >= cache->size) {
 739                 /* reallocate the array */
 740                 unsigned int new_size = cache->size + 64;
 741                 void *new_buffer;
 742                 new_buffer = kcalloc(new_size, cache->record_size, GFP_KERNEL);
 743                 if (!new_buffer) {
 744                         snd_printk(KERN_ERR "hda_codec: "
 745                                    "can't malloc amp_info\n");
 746                         return NULL;
 747                 }
 748                 if (cache->buffer) {
 749                         memcpy(new_buffer, cache->buffer,
 750                                cache->size * cache->record_size);
 751                         kfree(cache->buffer);
 752                 }
 753                 cache->size = new_size;
 754                 cache->buffer = new_buffer;
 755         }
 756         cur = cache->num_entries++;
 757         info = (struct hda_cache_head *)(cache->buffer +
 758                                          cur * cache->record_size);
 759         info->key = key;
 760         info->val = 0;
 761         info->next = cache->hash[idx];
 762         cache->hash[idx] = cur;
 763
 764         return info;
 765 }
 766
 767 /* query and allocate an amp hash entry */
 768 static inline struct hda_amp_info *
 769 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
 770 {
 771         return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
 772 }
 773
 774 /*
 775  * query AMP capabilities for the given widget and direction
 776  */
 777 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
 778 {
 779         struct hda_amp_info *info;
 780
 781         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
 782         if (!info)
 783                 return 0;
 784         if (!(info->head.val & INFO_AMP_CAPS)) {
 785                 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
 786                         nid = codec->afg;
 787                 info->amp_caps = snd_hda_param_read(codec, nid,
 788                                                     direction == HDA_OUTPUT ?
 789                                                     AC_PAR_AMP_OUT_CAP :
 790                                                     AC_PAR_AMP_IN_CAP);
 791                 if (info->amp_caps)
 792                         info->head.val |= INFO_AMP_CAPS;
 793         }
 794         return info->amp_caps;
 795 }
 796
 797 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
 798                               unsigned int caps)
 799 {
 800         struct hda_amp_info *info;
 801
 802         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
 803         if (!info)
 804                 return -EINVAL;
 805         info->amp_caps = caps;
 806         info->head.val |= INFO_AMP_CAPS;
 807         return 0;
 808 }
 809
 810 /*
 811  * read the current volume to info
 812  * if the cache exists, read the cache value.
 813  */
 814 static unsigned int get_vol_mute(struct hda_codec *codec,
 815                                  struct hda_amp_info *info, hda_nid_t nid,
 816                                  int ch, int direction, int index)
 817 {
 818         u32 val, parm;
 819
 820         if (info->head.val & INFO_AMP_VOL(ch))
 821                 return info->vol[ch];
 822
 823         parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
 824         parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
 825         parm |= index;
 826         val = snd_hda_codec_read(codec, nid, 0,
 827                                  AC_VERB_GET_AMP_GAIN_MUTE, parm);
 828         info->vol[ch] = val & 0xff;
 829         info->head.val |= INFO_AMP_VOL(ch);
 830         return info->vol[ch];
 831 }
 832
 833 /*
 834  * write the current volume in info to the h/w and update the cache
 835  */
 836 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
 837                          hda_nid_t nid, int ch, int direction, int index,
 838                          int val)
 839 {
 840         u32 parm;
 841
 842         parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
 843         parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
 844         parm |= index << AC_AMP_SET_INDEX_SHIFT;
 845         parm |= val;
 846         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
 847         info->vol[ch] = val;
 848 }
 849
 850 /*
 851  * read AMP value.  The volume is between 0 to 0x7f, 0x80 = mute bit.
 852  */
 853 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
 854                            int direction, int index)
 855 {
 856         struct hda_amp_info *info;
 857         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
 858         if (!info)
 859                 return 0;
 860         return get_vol_mute(codec, info, nid, ch, direction, index);
 861 }
 862
 863 /*
 864  * update the AMP value, mask = bit mask to set, val = the value
 865  */
 866 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
 867                              int direction, int idx, int mask, int val)
 868 {
 869         struct hda_amp_info *info;
 870
 871         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
 872         if (!info)
 873                 return 0;
 874         val &= mask;
 875         val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
 876         if (info->vol[ch] == val)
 877                 return 0;
 878         put_vol_mute(codec, info, nid, ch, direction, idx, val);
 879         return 1;
 880 }
 881
 882 /*
 883  * update the AMP stereo with the same mask and value
 884  */
 885 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
 886                              int direction, int idx, int mask, int val)
 887 {
 888         int ch, ret = 0;
 889         for (ch = 0; ch < 2; ch++)
 890                 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
 891                                                 idx, mask, val);
 892         return ret;
 893 }
 894
 895 #ifdef SND_HDA_NEEDS_RESUME
 896 /* resume the all amp commands from the cache */
 897 void snd_hda_codec_resume_amp(struct hda_codec *codec)
 898 {
 899         struct hda_amp_info *buffer = codec->amp_cache.buffer;
 900         int i;
 901
 902         for (i = 0; i < codec->amp_cache.size; i++, buffer++) {
 903                 u32 key = buffer->head.key;
 904                 hda_nid_t nid;
 905                 unsigned int idx, dir, ch;
 906                 if (!key)
 907                         continue;
 908                 nid = key & 0xff;
 909                 idx = (key >> 16) & 0xff;
 910                 dir = (key >> 24) & 0xff;
 911                 for (ch = 0; ch < 2; ch++) {
 912                         if (!(buffer->head.val & INFO_AMP_VOL(ch)))
 913                                 continue;
 914                         put_vol_mute(codec, buffer, nid, ch, dir, idx,
 915                                      buffer->vol[ch]);
 916                 }
 917         }
 918 }
 919 #endif /* SND_HDA_NEEDS_RESUME */
 920
 921 /*
 922  * AMP control callbacks
 923  */
 924 /* retrieve parameters from private_value */
 925 #define get_amp_nid(kc)         ((kc)->private_value & 0xffff)
 926 #define get_amp_channels(kc)    (((kc)->private_value >> 16) & 0x3)
 927 #define get_amp_direction(kc)   (((kc)->private_value >> 18) & 0x1)
 928 #define get_amp_index(kc)       (((kc)->private_value >> 19) & 0xf)
 929
 930 /* volume */
 931 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
 932                                   struct snd_ctl_elem_info *uinfo)
 933 {
 934         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 935         u16 nid = get_amp_nid(kcontrol);
 936         u8 chs = get_amp_channels(kcontrol);
 937         int dir = get_amp_direction(kcontrol);
 938         u32 caps;
 939
 940         caps = query_amp_caps(codec, nid, dir);
 941         /* num steps */
 942         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
 943         if (!caps) {
 944                 printk(KERN_WARNING "hda_codec: "
 945                        "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
 946                        kcontrol->id.name);
 947                 return -EINVAL;
 948         }
 949         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 950         uinfo->count = chs == 3 ? 2 : 1;
 951         uinfo->value.integer.min = 0;
 952         uinfo->value.integer.max = caps;
 953         return 0;
 954 }
 955
 956 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
 957                                  struct snd_ctl_elem_value *ucontrol)
 958 {
 959         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 960         hda_nid_t nid = get_amp_nid(kcontrol);
 961         int chs = get_amp_channels(kcontrol);
 962         int dir = get_amp_direction(kcontrol);
 963         int idx = get_amp_index(kcontrol);
 964         long *valp = ucontrol->value.integer.value;
 965
 966         if (chs & 1)
 967                 *valp++ = snd_hda_codec_amp_read(codec, nid, 0, dir, idx)
 968                         & HDA_AMP_VOLMASK;
 969         if (chs & 2)
 970                 *valp = snd_hda_codec_amp_read(codec, nid, 1, dir, idx)
 971                         & HDA_AMP_VOLMASK;
 972         return 0;
 973 }
 974
 975 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
 976                                  struct snd_ctl_elem_value *ucontrol)
 977 {
 978         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 979         hda_nid_t nid = get_amp_nid(kcontrol);
 980         int chs = get_amp_channels(kcontrol);
 981         int dir = get_amp_direction(kcontrol);
 982         int idx = get_amp_index(kcontrol);
 983         long *valp = ucontrol->value.integer.value;
 984         int change = 0;
 985
 986         snd_hda_power_up(codec);
 987         if (chs & 1) {
 988                 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
 989                                                   0x7f, *valp);
 990                 valp++;
 991         }
 992         if (chs & 2)
 993                 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
 994                                                    0x7f, *valp);
 995         snd_hda_power_down(codec);
 996         return change;
 997 }
 998
 999 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1000                           unsigned int size, unsigned int __user *_tlv)
1001 {
1002         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1003         hda_nid_t nid = get_amp_nid(kcontrol);
1004         int dir = get_amp_direction(kcontrol);
1005         u32 caps, val1, val2;
1006
1007         if (size < 4 * sizeof(unsigned int))
1008                 return -ENOMEM;
1009         caps = query_amp_caps(codec, nid, dir);
1010         val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1011         val2 = (val2 + 1) * 25;
1012         val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1013         val1 = ((int)val1) * ((int)val2);
1014         if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1015                 return -EFAULT;
1016         if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1017                 return -EFAULT;
1018         if (put_user(val1, _tlv + 2))
1019                 return -EFAULT;
1020         if (put_user(val2, _tlv + 3))
1021                 return -EFAULT;
1022         return 0;
1023 }
1024
1025 /*
1026  * set (static) TLV for virtual master volume; recalculated as max 0dB
1027  */
1028 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1029                              unsigned int *tlv)
1030 {
1031         u32 caps;
1032         int nums, step;
1033
1034         caps = query_amp_caps(codec, nid, dir);
1035         nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1036         step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1037         step = (step + 1) * 25;
1038         tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1039         tlv[1] = 2 * sizeof(unsigned int);
1040         tlv[2] = -nums * step;
1041         tlv[3] = step;
1042 }
1043
1044 /* find a mixer control element with the given name */
1045 static struct snd_kcontrol *
1046 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1047                         const char *name, int idx)
1048 {
1049         struct snd_ctl_elem_id id;
1050         memset(&id, 0, sizeof(id));
1051         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1052         id.index = idx;
1053         strcpy(id.name, name);
1054         return snd_ctl_find_id(codec->bus->card, &id);
1055 }
1056
1057 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1058                                             const char *name)
1059 {
1060         return _snd_hda_find_mixer_ctl(codec, name, 0);
1061 }
1062
1063 /* create a virtual master control and add slaves */
1064 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1065                         unsigned int *tlv, const char **slaves)
1066 {
1067         struct snd_kcontrol *kctl;
1068         const char **s;
1069         int err;
1070
1071         for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1072                 ;
1073         if (!*s) {
1074                 snd_printdd("No slave found for %s\n", name);
1075                 return 0;
1076         }
1077         kctl = snd_ctl_make_virtual_master(name, tlv);
1078         if (!kctl)
1079                 return -ENOMEM;
1080         err = snd_ctl_add(codec->bus->card, kctl);
1081         if (err < 0)
1082                 return err;
1083
1084         for (s = slaves; *s; s++) {
1085                 struct snd_kcontrol *sctl;
1086
1087                 sctl = snd_hda_find_mixer_ctl(codec, *s);
1088                 if (!sctl) {
1089                         snd_printdd("Cannot find slave %s, skipped\n", *s);
1090                         continue;
1091                 }
1092                 err = snd_ctl_add_slave(kctl, sctl);
1093                 if (err < 0)
1094                         return err;
1095         }
1096         return 0;
1097 }
1098
1099 /* switch */
1100 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1101                                   struct snd_ctl_elem_info *uinfo)
1102 {
1103         int chs = get_amp_channels(kcontrol);
1104
1105         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1106         uinfo->count = chs == 3 ? 2 : 1;
1107         uinfo->value.integer.min = 0;
1108         uinfo->value.integer.max = 1;
1109         return 0;
1110 }
1111
1112 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1113                                  struct snd_ctl_elem_value *ucontrol)
1114 {
1115         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1116         hda_nid_t nid = get_amp_nid(kcontrol);
1117         int chs = get_amp_channels(kcontrol);
1118         int dir = get_amp_direction(kcontrol);
1119         int idx = get_amp_index(kcontrol);
1120         long *valp = ucontrol->value.integer.value;
1121
1122         if (chs & 1)
1123                 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1124                            HDA_AMP_MUTE) ? 0 : 1;
1125         if (chs & 2)
1126                 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1127                          HDA_AMP_MUTE) ? 0 : 1;
1128         return 0;
1129 }
1130
1131 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1132                                  struct snd_ctl_elem_value *ucontrol)
1133 {
1134         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1135         hda_nid_t nid = get_amp_nid(kcontrol);
1136         int chs = get_amp_channels(kcontrol);
1137         int dir = get_amp_direction(kcontrol);
1138         int idx = get_amp_index(kcontrol);
1139         long *valp = ucontrol->value.integer.value;
1140         int change = 0;
1141
1142         snd_hda_power_up(codec);
1143         if (chs & 1) {
1144                 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1145                                                   HDA_AMP_MUTE,
1146                                                   *valp ? 0 : HDA_AMP_MUTE);
1147                 valp++;
1148         }
1149         if (chs & 2)
1150                 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1151                                                    HDA_AMP_MUTE,
1152                                                    *valp ? 0 : HDA_AMP_MUTE);
1153 #ifdef CONFIG_SND_HDA_POWER_SAVE
1154         if (codec->patch_ops.check_power_status)
1155                 codec->patch_ops.check_power_status(codec, nid);
1156 #endif
1157         snd_hda_power_down(codec);
1158         return change;
1159 }
1160
1161 /*
1162  * bound volume controls
1163  *
1164  * bind multiple volumes (# indices, from 0)
1165  */
1166
1167 #define AMP_VAL_IDX_SHIFT       19
1168 #define AMP_VAL_IDX_MASK        (0x0f<<19)
1169
1170 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1171                                   struct snd_ctl_elem_value *ucontrol)
1172 {
1173         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1174         unsigned long pval;
1175         int err;
1176
1177         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1178         pval = kcontrol->private_value;
1179         kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1180         err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1181         kcontrol->private_value = pval;
1182         mutex_unlock(&codec->spdif_mutex);
1183         return err;
1184 }
1185
1186 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1187                                   struct snd_ctl_elem_value *ucontrol)
1188 {
1189         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1190         unsigned long pval;
1191         int i, indices, err = 0, change = 0;
1192
1193         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1194         pval = kcontrol->private_value;
1195         indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1196         for (i = 0; i < indices; i++) {
1197                 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1198                         (i << AMP_VAL_IDX_SHIFT);
1199                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1200                 if (err < 0)
1201                         break;
1202                 change |= err;
1203         }
1204         kcontrol->private_value = pval;
1205         mutex_unlock(&codec->spdif_mutex);
1206         return err < 0 ? err : change;
1207 }
1208
1209 /*
1210  * generic bound volume/swtich controls
1211  */
1212 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1213                                  struct snd_ctl_elem_info *uinfo)
1214 {
1215         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1216         struct hda_bind_ctls *c;
1217         int err;
1218
1219         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1220         c = (struct hda_bind_ctls *)kcontrol->private_value;
1221         kcontrol->private_value = *c->values;
1222         err = c->ops->info(kcontrol, uinfo);
1223         kcontrol->private_value = (long)c;
1224         mutex_unlock(&codec->spdif_mutex);
1225         return err;
1226 }
1227
1228 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1229                                 struct snd_ctl_elem_value *ucontrol)
1230 {
1231         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1232         struct hda_bind_ctls *c;
1233         int err;
1234
1235         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1236         c = (struct hda_bind_ctls *)kcontrol->private_value;
1237         kcontrol->private_value = *c->values;
1238         err = c->ops->get(kcontrol, ucontrol);
1239         kcontrol->private_value = (long)c;
1240         mutex_unlock(&codec->spdif_mutex);
1241         return err;
1242 }
1243
1244 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1245                                 struct snd_ctl_elem_value *ucontrol)
1246 {
1247         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1248         struct hda_bind_ctls *c;
1249         unsigned long *vals;
1250         int err = 0, change = 0;
1251
1252         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1253         c = (struct hda_bind_ctls *)kcontrol->private_value;
1254         for (vals = c->values; *vals; vals++) {
1255                 kcontrol->private_value = *vals;
1256                 err = c->ops->put(kcontrol, ucontrol);
1257                 if (err < 0)
1258                         break;
1259                 change |= err;
1260         }
1261         kcontrol->private_value = (long)c;
1262         mutex_unlock(&codec->spdif_mutex);
1263         return err < 0 ? err : change;
1264 }
1265
1266 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1267                            unsigned int size, unsigned int __user *tlv)
1268 {
1269         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1270         struct hda_bind_ctls *c;
1271         int err;
1272
1273         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1274         c = (struct hda_bind_ctls *)kcontrol->private_value;
1275         kcontrol->private_value = *c->values;
1276         err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1277         kcontrol->private_value = (long)c;
1278         mutex_unlock(&codec->spdif_mutex);
1279         return err;
1280 }
1281
1282 struct hda_ctl_ops snd_hda_bind_vol = {
1283         .info = snd_hda_mixer_amp_volume_info,
1284         .get = snd_hda_mixer_amp_volume_get,
1285         .put = snd_hda_mixer_amp_volume_put,
1286         .tlv = snd_hda_mixer_amp_tlv
1287 };
1288
1289 struct hda_ctl_ops snd_hda_bind_sw = {
1290         .info = snd_hda_mixer_amp_switch_info,
1291         .get = snd_hda_mixer_amp_switch_get,
1292         .put = snd_hda_mixer_amp_switch_put,
1293         .tlv = snd_hda_mixer_amp_tlv
1294 };
1295
1296 /*
1297  * SPDIF out controls
1298  */
1299
1300 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1301                                    struct snd_ctl_elem_info *uinfo)
1302 {
1303         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1304         uinfo->count = 1;
1305         return 0;
1306 }
1307
1308 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1309                                    struct snd_ctl_elem_value *ucontrol)
1310 {
1311         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1312                                            IEC958_AES0_NONAUDIO |
1313                                            IEC958_AES0_CON_EMPHASIS_5015 |
1314                                            IEC958_AES0_CON_NOT_COPYRIGHT;
1315         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1316                                            IEC958_AES1_CON_ORIGINAL;
1317         return 0;
1318 }
1319
1320 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1321                                    struct snd_ctl_elem_value *ucontrol)
1322 {
1323         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1324                                            IEC958_AES0_NONAUDIO |
1325                                            IEC958_AES0_PRO_EMPHASIS_5015;
1326         return 0;
1327 }
1328
1329 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1330                                      struct snd_ctl_elem_value *ucontrol)
1331 {
1332         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1333
1334         ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1335         ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1336         ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1337         ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1338
1339         return 0;
1340 }
1341
1342 /* convert from SPDIF status bits to HDA SPDIF bits
1343  * bit 0 (DigEn) is always set zero (to be filled later)
1344  */
1345 static unsigned short convert_from_spdif_status(unsigned int sbits)
1346 {
1347         unsigned short val = 0;
1348
1349         if (sbits & IEC958_AES0_PROFESSIONAL)
1350                 val |= AC_DIG1_PROFESSIONAL;
1351         if (sbits & IEC958_AES0_NONAUDIO)
1352                 val |= AC_DIG1_NONAUDIO;
1353         if (sbits & IEC958_AES0_PROFESSIONAL) {
1354                 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1355                     IEC958_AES0_PRO_EMPHASIS_5015)
1356                         val |= AC_DIG1_EMPHASIS;
1357         } else {
1358                 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1359                     IEC958_AES0_CON_EMPHASIS_5015)
1360                         val |= AC_DIG1_EMPHASIS;
1361                 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1362                         val |= AC_DIG1_COPYRIGHT;
1363                 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1364                         val |= AC_DIG1_LEVEL;
1365                 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1366         }
1367         return val;
1368 }
1369
1370 /* convert to SPDIF status bits from HDA SPDIF bits
1371  */
1372 static unsigned int convert_to_spdif_status(unsigned short val)
1373 {
1374         unsigned int sbits = 0;
1375
1376         if (val & AC_DIG1_NONAUDIO)
1377                 sbits |= IEC958_AES0_NONAUDIO;
1378         if (val & AC_DIG1_PROFESSIONAL)
1379                 sbits |= IEC958_AES0_PROFESSIONAL;
1380         if (sbits & IEC958_AES0_PROFESSIONAL) {
1381                 if (sbits & AC_DIG1_EMPHASIS)
1382                         sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1383         } else {
1384                 if (val & AC_DIG1_EMPHASIS)
1385                         sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1386                 if (!(val & AC_DIG1_COPYRIGHT))
1387                         sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1388                 if (val & AC_DIG1_LEVEL)
1389                         sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1390                 sbits |= val & (0x7f << 8);
1391         }
1392         return sbits;
1393 }
1394
1395 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1396                                      struct snd_ctl_elem_value *ucontrol)
1397 {
1398         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1399         hda_nid_t nid = kcontrol->private_value;
1400         unsigned short val;
1401         int change;
1402
1403         mutex_lock(&codec->spdif_mutex);
1404         codec->spdif_status = ucontrol->value.iec958.status[0] |
1405                 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1406                 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1407                 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1408         val = convert_from_spdif_status(codec->spdif_status);
1409         val |= codec->spdif_ctls & 1;
1410         change = codec->spdif_ctls != val;
1411         codec->spdif_ctls = val;
1412
1413         if (change) {
1414                 snd_hda_codec_write_cache(codec, nid, 0,
1415                                           AC_VERB_SET_DIGI_CONVERT_1,
1416                                           val & 0xff);
1417                 snd_hda_codec_write_cache(codec, nid, 0,
1418                                           AC_VERB_SET_DIGI_CONVERT_2,
1419                                           val >> 8);
1420         }
1421
1422         mutex_unlock(&codec->spdif_mutex);
1423         return change;
1424 }
1425
1426 #define snd_hda_spdif_out_switch_info   snd_ctl_boolean_mono_info
1427
1428 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1429                                         struct snd_ctl_elem_value *ucontrol)
1430 {
1431         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1432
1433         ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1434         return 0;
1435 }
1436
1437 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1438                                         struct snd_ctl_elem_value *ucontrol)
1439 {
1440         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1441         hda_nid_t nid = kcontrol->private_value;
1442         unsigned short val;
1443         int change;
1444
1445         mutex_lock(&codec->spdif_mutex);
1446         val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1447         if (ucontrol->value.integer.value[0])
1448                 val |= AC_DIG1_ENABLE;
1449         change = codec->spdif_ctls != val;
1450         if (change) {
1451                 codec->spdif_ctls = val;
1452                 snd_hda_codec_write_cache(codec, nid, 0,
1453                                           AC_VERB_SET_DIGI_CONVERT_1,
1454                                           val & 0xff);
1455                 /* unmute amp switch (if any) */
1456                 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1457                     (val & AC_DIG1_ENABLE))
1458                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1459                                                  HDA_AMP_MUTE, 0);
1460         }
1461         mutex_unlock(&codec->spdif_mutex);
1462         return change;
1463 }
1464
1465 static struct snd_kcontrol_new dig_mixes[] = {
1466         {
1467                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1468                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1469                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1470                 .info = snd_hda_spdif_mask_info,
1471                 .get = snd_hda_spdif_cmask_get,
1472         },
1473         {
1474                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1475                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1476                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1477                 .info = snd_hda_spdif_mask_info,
1478                 .get = snd_hda_spdif_pmask_get,
1479         },
1480         {
1481                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1482                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1483                 .info = snd_hda_spdif_mask_info,
1484                 .get = snd_hda_spdif_default_get,
1485                 .put = snd_hda_spdif_default_put,
1486         },
1487         {
1488                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1489                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1490                 .info = snd_hda_spdif_out_switch_info,
1491                 .get = snd_hda_spdif_out_switch_get,
1492                 .put = snd_hda_spdif_out_switch_put,
1493         },
1494         { } /* end */
1495 };
1496
1497 #define SPDIF_MAX_IDX   4       /* 4 instances should be enough to probe */
1498
1499 /**
1500  * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1501  * @codec: the HDA codec
1502  * @nid: audio out widget NID
1503  *
1504  * Creates controls related with the SPDIF output.
1505  * Called from each patch supporting the SPDIF out.
1506  *
1507  * Returns 0 if successful, or a negative error code.
1508  */
1509 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1510 {
1511         int err;
1512         struct snd_kcontrol *kctl;
1513         struct snd_kcontrol_new *dig_mix;
1514         int idx;
1515
1516         for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1517                 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1518                                              idx))
1519                         break;
1520         }
1521         if (idx >= SPDIF_MAX_IDX) {
1522                 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1523                 return -EBUSY;
1524         }
1525         for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1526                 kctl = snd_ctl_new1(dig_mix, codec);
1527                 kctl->id.index = idx;
1528                 kctl->private_value = nid;
1529                 err = snd_ctl_add(codec->bus->card, kctl);
1530                 if (err < 0)
1531                         return err;
1532         }
1533         codec->spdif_ctls =
1534                 snd_hda_codec_read(codec, nid, 0,
1535                                    AC_VERB_GET_DIGI_CONVERT_1, 0);
1536         codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1537         return 0;
1538 }
1539
1540 /*
1541  * SPDIF sharing with analog output
1542  */
1543 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1544                               struct snd_ctl_elem_value *ucontrol)
1545 {
1546         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1547         ucontrol->value.integer.value[0] = mout->share_spdif;
1548         return 0;
1549 }
1550
1551 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1552                               struct snd_ctl_elem_value *ucontrol)
1553 {
1554         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1555         mout->share_spdif = !!ucontrol->value.integer.value[0];
1556         return 0;
1557 }
1558
1559 static struct snd_kcontrol_new spdif_share_sw = {
1560         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1561         .name = "IEC958 Default PCM Playback Switch",
1562         .info = snd_ctl_boolean_mono_info,
1563         .get = spdif_share_sw_get,
1564         .put = spdif_share_sw_put,
1565 };
1566
1567 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
1568                                   struct hda_multi_out *mout)
1569 {
1570         if (!mout->dig_out_nid)
1571                 return 0;
1572         /* ATTENTION: here mout is passed as private_data, instead of codec */
1573         return snd_ctl_add(codec->bus->card,
1574                            snd_ctl_new1(&spdif_share_sw, mout));
1575 }
1576
1577 /*
1578  * SPDIF input
1579  */
1580
1581 #define snd_hda_spdif_in_switch_info    snd_hda_spdif_out_switch_info
1582
1583 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
1584                                        struct snd_ctl_elem_value *ucontrol)
1585 {
1586         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1587
1588         ucontrol->value.integer.value[0] = codec->spdif_in_enable;
1589         return 0;
1590 }
1591
1592 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
1593                                        struct snd_ctl_elem_value *ucontrol)
1594 {
1595         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1596         hda_nid_t nid = kcontrol->private_value;
1597         unsigned int val = !!ucontrol->value.integer.value[0];
1598         int change;
1599
1600         mutex_lock(&codec->spdif_mutex);
1601         change = codec->spdif_in_enable != val;
1602         if (change) {
1603                 codec->spdif_in_enable = val;
1604                 snd_hda_codec_write_cache(codec, nid, 0,
1605                                           AC_VERB_SET_DIGI_CONVERT_1, val);
1606         }
1607         mutex_unlock(&codec->spdif_mutex);
1608         return change;
1609 }
1610
1611 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
1612                                        struct snd_ctl_elem_value *ucontrol)
1613 {
1614         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1615         hda_nid_t nid = kcontrol->private_value;
1616         unsigned short val;
1617         unsigned int sbits;
1618
1619         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1620         sbits = convert_to_spdif_status(val);
1621         ucontrol->value.iec958.status[0] = sbits;
1622         ucontrol->value.iec958.status[1] = sbits >> 8;
1623         ucontrol->value.iec958.status[2] = sbits >> 16;
1624         ucontrol->value.iec958.status[3] = sbits >> 24;
1625         return 0;
1626 }
1627
1628 static struct snd_kcontrol_new dig_in_ctls[] = {
1629         {
1630                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1631                 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
1632                 .info = snd_hda_spdif_in_switch_info,
1633                 .get = snd_hda_spdif_in_switch_get,
1634                 .put = snd_hda_spdif_in_switch_put,
1635         },
1636         {
1637                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1638                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1639                 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1640                 .info = snd_hda_spdif_mask_info,
1641                 .get = snd_hda_spdif_in_status_get,
1642         },
1643         { } /* end */
1644 };
1645
1646 /**
1647  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1648  * @codec: the HDA codec
1649  * @nid: audio in widget NID
1650  *
1651  * Creates controls related with the SPDIF input.
1652  * Called from each patch supporting the SPDIF in.
1653  *
1654  * Returns 0 if successful, or a negative error code.
1655  */
1656 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1657 {
1658         int err;
1659         struct snd_kcontrol *kctl;
1660         struct snd_kcontrol_new *dig_mix;
1661         int idx;
1662
1663         for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1664                 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
1665                                              idx))
1666                         break;
1667         }
1668         if (idx >= SPDIF_MAX_IDX) {
1669                 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
1670                 return -EBUSY;
1671         }
1672         for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
1673                 kctl = snd_ctl_new1(dig_mix, codec);
1674                 kctl->private_value = nid;
1675                 err = snd_ctl_add(codec->bus->card, kctl);
1676                 if (err < 0)
1677                         return err;
1678         }
1679         codec->spdif_in_enable =
1680                 snd_hda_codec_read(codec, nid, 0,
1681                                    AC_VERB_GET_DIGI_CONVERT_1, 0) &
1682                 AC_DIG1_ENABLE;
1683         return 0;
1684 }
1685
1686 #ifdef SND_HDA_NEEDS_RESUME
1687 /*
1688  * command cache
1689  */
1690
1691 /* build a 32bit cache key with the widget id and the command parameter */
1692 #define build_cmd_cache_key(nid, verb)  ((verb << 8) | nid)
1693 #define get_cmd_cache_nid(key)          ((key) & 0xff)
1694 #define get_cmd_cache_cmd(key)          (((key) >> 8) & 0xffff)
1695
1696 /**
1697  * snd_hda_codec_write_cache - send a single command with caching
1698  * @codec: the HDA codec
1699  * @nid: NID to send the command
1700  * @direct: direct flag
1701  * @verb: the verb to send
1702  * @parm: the parameter for the verb
1703  *
1704  * Send a single command without waiting for response.
1705  *
1706  * Returns 0 if successful, or a negative error code.
1707  */
1708 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
1709                               int direct, unsigned int verb, unsigned int parm)
1710 {
1711         int err;
1712         snd_hda_power_up(codec);
1713         mutex_lock(&codec->bus->cmd_mutex);
1714         err = codec->bus->ops.command(codec, nid, direct, verb, parm);
1715         if (!err) {
1716                 struct hda_cache_head *c;
1717                 u32 key = build_cmd_cache_key(nid, verb);
1718                 c = get_alloc_hash(&codec->cmd_cache, key);
1719                 if (c)
1720                         c->val = parm;
1721         }
1722         mutex_unlock(&codec->bus->cmd_mutex);
1723         snd_hda_power_down(codec);
1724         return err;
1725 }
1726
1727 /* resume the all commands from the cache */
1728 void snd_hda_codec_resume_cache(struct hda_codec *codec)
1729 {
1730         struct hda_cache_head *buffer = codec->cmd_cache.buffer;
1731         int i;
1732
1733         for (i = 0; i < codec->cmd_cache.size; i++, buffer++) {
1734                 u32 key = buffer->key;
1735                 if (!key)
1736                         continue;
1737                 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
1738                                     get_cmd_cache_cmd(key), buffer->val);
1739         }
1740 }
1741
1742 /**
1743  * snd_hda_sequence_write_cache - sequence writes with caching
1744  * @codec: the HDA codec
1745  * @seq: VERB array to send
1746  *
1747  * Send the commands sequentially from the given array.
1748  * Thte commands are recorded on cache for power-save and resume.
1749  * The array must be terminated with NID=0.
1750  */
1751 void snd_hda_sequence_write_cache(struct hda_codec *codec,
1752                                   const struct hda_verb *seq)
1753 {
1754         for (; seq->nid; seq++)
1755                 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
1756                                           seq->param);
1757 }
1758 #endif /* SND_HDA_NEEDS_RESUME */
1759
1760 /*
1761  * set power state of the codec
1762  */
1763 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1764                                 unsigned int power_state)
1765 {
1766         hda_nid_t nid;
1767         int i;
1768
1769         snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
1770                             power_state);
1771         msleep(10); /* partial workaround for "azx_get_response timeout" */
1772
1773         nid = codec->start_nid;
1774         for (i = 0; i < codec->num_nodes; i++, nid++) {
1775                 unsigned int wcaps = get_wcaps(codec, nid);
1776                 if (wcaps & AC_WCAP_POWER) {
1777                         unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
1778                                 AC_WCAP_TYPE_SHIFT;
1779                         if (wid_type == AC_WID_PIN) {
1780                                 unsigned int pincap;
1781                                 /*
1782                                  * don't power down the widget if it controls
1783                                  * eapd and EAPD_BTLENABLE is set.
1784                                  */
1785                                 pincap = snd_hda_param_read(codec, nid,
1786                                                             AC_PAR_PIN_CAP);
1787                                 if (pincap & AC_PINCAP_EAPD) {
1788                                         int eapd = snd_hda_codec_read(codec,
1789                                                 nid, 0,
1790                                                 AC_VERB_GET_EAPD_BTLENABLE, 0);
1791                                         eapd &= 0x02;
1792                                         if (power_state == AC_PWRST_D3 && eapd)
1793                                                 continue;
1794                                 }
1795                         }
1796                         snd_hda_codec_write(codec, nid, 0,
1797                                             AC_VERB_SET_POWER_STATE,
1798                                             power_state);
1799                 }
1800         }
1801
1802         if (power_state == AC_PWRST_D0) {
1803                 unsigned long end_time;
1804                 int state;
1805                 msleep(10);
1806                 /* wait until the codec reachs to D0 */
1807                 end_time = jiffies + msecs_to_jiffies(500);
1808                 do {
1809                         state = snd_hda_codec_read(codec, fg, 0,
1810                                                    AC_VERB_GET_POWER_STATE, 0);
1811                         if (state == power_state)
1812                                 break;
1813                         msleep(1);
1814                 } while (time_after_eq(end_time, jiffies));
1815         }
1816 }
1817
1818 #ifdef SND_HDA_NEEDS_RESUME
1819 /*
1820  * call suspend and power-down; used both from PM and power-save
1821  */
1822 static void hda_call_codec_suspend(struct hda_codec *codec)
1823 {
1824         if (codec->patch_ops.suspend)
1825                 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
1826         hda_set_power_state(codec,
1827                             codec->afg ? codec->afg : codec->mfg,
1828                             AC_PWRST_D3);
1829 #ifdef CONFIG_SND_HDA_POWER_SAVE
1830         cancel_delayed_work(&codec->power_work);
1831         codec->power_on = 0;
1832         codec->power_transition = 0;
1833 #endif
1834 }
1835
1836 /*
1837  * kick up codec; used both from PM and power-save
1838  */
1839 static void hda_call_codec_resume(struct hda_codec *codec)
1840 {
1841         hda_set_power_state(codec,
1842                             codec->afg ? codec->afg : codec->mfg,
1843                             AC_PWRST_D0);
1844         if (codec->patch_ops.resume)
1845                 codec->patch_ops.resume(codec);
1846         else {
1847                 if (codec->patch_ops.init)
1848                         codec->patch_ops.init(codec);
1849                 snd_hda_codec_resume_amp(codec);
1850                 snd_hda_codec_resume_cache(codec);
1851         }
1852 }
1853 #endif /* SND_HDA_NEEDS_RESUME */
1854
1855
1856 /**
1857  * snd_hda_build_controls - build mixer controls
1858  * @bus: the BUS
1859  *
1860  * Creates mixer controls for each codec included in the bus.
1861  *
1862  * Returns 0 if successful, otherwise a negative error code.
1863  */
1864 int __devinit snd_hda_build_controls(struct hda_bus *bus)
1865 {
1866         struct hda_codec *codec;
1867
1868         list_for_each_entry(codec, &bus->codec_list, list) {
1869                 int err = 0;
1870                 /* fake as if already powered-on */
1871                 hda_keep_power_on(codec);
1872                 /* then fire up */
1873                 hda_set_power_state(codec,
1874                                     codec->afg ? codec->afg : codec->mfg,
1875                                     AC_PWRST_D0);
1876                 /* continue to initialize... */
1877                 if (codec->patch_ops.init)
1878                         err = codec->patch_ops.init(codec);
1879                 if (!err && codec->patch_ops.build_controls)
1880                         err = codec->patch_ops.build_controls(codec);
1881                 snd_hda_power_down(codec);
1882                 if (err < 0)
1883                         return err;
1884         }
1885
1886         return 0;
1887 }
1888
1889 /*
1890  * stream formats
1891  */
1892 struct hda_rate_tbl {
1893         unsigned int hz;
1894         unsigned int alsa_bits;
1895         unsigned int hda_fmt;
1896 };
1897
1898 static struct hda_rate_tbl rate_bits[] = {
1899         /* rate in Hz, ALSA rate bitmask, HDA format value */
1900
1901         /* autodetected value used in snd_hda_query_supported_pcm */
1902         { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
1903         { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
1904         { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
1905         { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
1906         { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
1907         { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
1908         { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
1909         { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
1910         { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
1911         { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
1912         { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
1913 #define AC_PAR_PCM_RATE_BITS    11
1914         /* up to bits 10, 384kHZ isn't supported properly */
1915
1916         /* not autodetected value */
1917         { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
1918
1919         { 0 } /* terminator */
1920 };
1921
1922 /**
1923  * snd_hda_calc_stream_format - calculate format bitset
1924  * @rate: the sample rate
1925  * @channels: the number of channels
1926  * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
1927  * @maxbps: the max. bps
1928  *
1929  * Calculate the format bitset from the given rate, channels and th PCM format.
1930  *
1931  * Return zero if invalid.
1932  */
1933 unsigned int snd_hda_calc_stream_format(unsigned int rate,
1934                                         unsigned int channels,
1935                                         unsigned int format,
1936                                         unsigned int maxbps)
1937 {
1938         int i;
1939         unsigned int val = 0;
1940
1941         for (i = 0; rate_bits[i].hz; i++)
1942                 if (rate_bits[i].hz == rate) {
1943                         val = rate_bits[i].hda_fmt;
1944                         break;
1945                 }
1946         if (!rate_bits[i].hz) {
1947                 snd_printdd("invalid rate %d\n", rate);
1948                 return 0;
1949         }
1950
1951         if (channels == 0 || channels > 8) {
1952                 snd_printdd("invalid channels %d\n", channels);
1953                 return 0;
1954         }
1955         val |= channels - 1;
1956
1957         switch (snd_pcm_format_width(format)) {
1958         case 8:  val |= 0x00; break;
1959         case 16: val |= 0x10; break;
1960         case 20:
1961         case 24:
1962         case 32:
1963                 if (maxbps >= 32)
1964                         val |= 0x40;
1965                 else if (maxbps >= 24)
1966                         val |= 0x30;
1967                 else
1968                         val |= 0x20;
1969                 break;
1970         default:
1971                 snd_printdd("invalid format width %d\n",
1972                             snd_pcm_format_width(format));
1973                 return 0;
1974         }
1975
1976         return val;
1977 }
1978
1979 /**
1980  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
1981  * @codec: the HDA codec
1982  * @nid: NID to query
1983  * @ratesp: the pointer to store the detected rate bitflags
1984  * @formatsp: the pointer to store the detected formats
1985  * @bpsp: the pointer to store the detected format widths
1986  *
1987  * Queries the supported PCM rates and formats.  The NULL @ratesp, @formatsp
1988  * or @bsps argument is ignored.
1989  *
1990  * Returns 0 if successful, otherwise a negative error code.
1991  */
1992 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
1993                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
1994 {
1995         int i;
1996         unsigned int val, streams;
1997
1998         val = 0;
1999         if (nid != codec->afg &&
2000             (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2001                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2002                 if (val == -1)
2003                         return -EIO;
2004         }
2005         if (!val)
2006                 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2007
2008         if (ratesp) {
2009                 u32 rates = 0;
2010                 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2011                         if (val & (1 << i))
2012                                 rates |= rate_bits[i].alsa_bits;
2013                 }
2014                 *ratesp = rates;
2015         }
2016
2017         if (formatsp || bpsp) {
2018                 u64 formats = 0;
2019                 unsigned int bps;
2020                 unsigned int wcaps;
2021
2022                 wcaps = get_wcaps(codec, nid);
2023                 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2024                 if (streams == -1)
2025                         return -EIO;
2026                 if (!streams) {
2027                         streams = snd_hda_param_read(codec, codec->afg,
2028                                                      AC_PAR_STREAM);
2029                         if (streams == -1)
2030                                 return -EIO;
2031                 }
2032
2033                 bps = 0;
2034                 if (streams & AC_SUPFMT_PCM) {
2035                         if (val & AC_SUPPCM_BITS_8) {
2036                                 formats |= SNDRV_PCM_FMTBIT_U8;
2037                                 bps = 8;
2038                         }
2039                         if (val & AC_SUPPCM_BITS_16) {
2040                                 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2041                                 bps = 16;
2042                         }
2043                         if (wcaps & AC_WCAP_DIGITAL) {
2044                                 if (val & AC_SUPPCM_BITS_32)
2045                                         formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2046                                 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2047                                         formats |= SNDRV_PCM_FMTBIT_S32_LE;
2048                                 if (val & AC_SUPPCM_BITS_24)
2049                                         bps = 24;
2050                                 else if (val & AC_SUPPCM_BITS_20)
2051                                         bps = 20;
2052                         } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2053                                           AC_SUPPCM_BITS_32)) {
2054                                 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2055                                 if (val & AC_SUPPCM_BITS_32)
2056                                         bps = 32;
2057                                 else if (val & AC_SUPPCM_BITS_24)
2058                                         bps = 24;
2059                                 else if (val & AC_SUPPCM_BITS_20)
2060                                         bps = 20;
2061                         }
2062                 }
2063                 else if (streams == AC_SUPFMT_FLOAT32) {
2064                         /* should be exclusive */
2065                         formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2066                         bps = 32;
2067                 } else if (streams == AC_SUPFMT_AC3) {
2068                         /* should be exclusive */
2069                         /* temporary hack: we have still no proper support
2070                          * for the direct AC3 stream...
2071                          */
2072                         formats |= SNDRV_PCM_FMTBIT_U8;
2073                         bps = 8;
2074                 }
2075                 if (formatsp)
2076                         *formatsp = formats;
2077                 if (bpsp)
2078                         *bpsp = bps;
2079         }
2080
2081         return 0;
2082 }
2083
2084 /**
2085  * snd_hda_is_supported_format - check whether the given node supports
2086  * the format val
2087  *
2088  * Returns 1 if supported, 0 if not.
2089  */
2090 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2091                                 unsigned int format)
2092 {
2093         int i;
2094         unsigned int val = 0, rate, stream;
2095
2096         if (nid != codec->afg &&
2097             (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2098                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2099                 if (val == -1)
2100                         return 0;
2101         }
2102         if (!val) {
2103                 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2104                 if (val == -1)
2105                         return 0;
2106         }
2107
2108         rate = format & 0xff00;
2109         for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2110                 if (rate_bits[i].hda_fmt == rate) {
2111                         if (val & (1 << i))
2112                                 break;
2113                         return 0;
2114                 }
2115         if (i >= AC_PAR_PCM_RATE_BITS)
2116                 return 0;
2117
2118         stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2119         if (stream == -1)
2120                 return 0;
2121         if (!stream && nid != codec->afg)
2122                 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2123         if (!stream || stream == -1)
2124                 return 0;
2125
2126         if (stream & AC_SUPFMT_PCM) {
2127                 switch (format & 0xf0) {
2128                 case 0x00:
2129                         if (!(val & AC_SUPPCM_BITS_8))
2130                                 return 0;
2131                         break;
2132                 case 0x10:
2133                         if (!(val & AC_SUPPCM_BITS_16))
2134                                 return 0;
2135                         break;
2136                 case 0x20:
2137                         if (!(val & AC_SUPPCM_BITS_20))
2138                                 return 0;
2139                         break;
2140                 case 0x30:
2141                         if (!(val & AC_SUPPCM_BITS_24))
2142                                 return 0;
2143                         break;
2144                 case 0x40:
2145                         if (!(val & AC_SUPPCM_BITS_32))
2146                                 return 0;
2147                         break;
2148                 default:
2149                         return 0;
2150                 }
2151         } else {
2152                 /* FIXME: check for float32 and AC3? */
2153         }
2154
2155         return 1;
2156 }
2157
2158 /*
2159  * PCM stuff
2160  */
2161 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2162                                       struct hda_codec *codec,
2163                                       struct snd_pcm_substream *substream)
2164 {
2165         return 0;
2166 }
2167
2168 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2169                                    struct hda_codec *codec,
2170                                    unsigned int stream_tag,
2171                                    unsigned int format,
2172                                    struct snd_pcm_substream *substream)
2173 {
2174         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2175         return 0;
2176 }
2177
2178 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2179                                    struct hda_codec *codec,
2180                                    struct snd_pcm_substream *substream)
2181 {
2182         snd_hda_codec_setup_stream(codec, hinfo->nid, 0, 0, 0);
2183         return 0;
2184 }
2185
2186 static int __devinit set_pcm_default_values(struct hda_codec *codec,
2187                                             struct hda_pcm_stream *info)
2188 {
2189         /* query support PCM information from the given NID */
2190         if (info->nid && (!info->rates || !info->formats)) {
2191                 snd_hda_query_supported_pcm(codec, info->nid,
2192                                 info->rates ? NULL : &info->rates,
2193                                 info->formats ? NULL : &info->formats,
2194                                 info->maxbps ? NULL : &info->maxbps);
2195         }
2196         if (info->ops.open == NULL)
2197                 info->ops.open = hda_pcm_default_open_close;
2198         if (info->ops.close == NULL)
2199                 info->ops.close = hda_pcm_default_open_close;
2200         if (info->ops.prepare == NULL) {
2201                 snd_assert(info->nid, return -EINVAL);
2202                 info->ops.prepare = hda_pcm_default_prepare;
2203         }
2204         if (info->ops.cleanup == NULL) {
2205                 snd_assert(info->nid, return -EINVAL);
2206                 info->ops.cleanup = hda_pcm_default_cleanup;
2207         }
2208         return 0;
2209 }
2210
2211 /**
2212  * snd_hda_build_pcms - build PCM information
2213  * @bus: the BUS
2214  *
2215  * Create PCM information for each codec included in the bus.
2216  *
2217  * The build_pcms codec patch is requested to set up codec->num_pcms and
2218  * codec->pcm_info properly.  The array is referred by the top-level driver
2219  * to create its PCM instances.
2220  * The allocated codec->pcm_info should be released in codec->patch_ops.free
2221  * callback.
2222  *
2223  * At least, substreams, channels_min and channels_max must be filled for
2224  * each stream.  substreams = 0 indicates that the stream doesn't exist.
2225  * When rates and/or formats are zero, the supported values are queried
2226  * from the given nid.  The nid is used also by the default ops.prepare
2227  * and ops.cleanup callbacks.
2228  *
2229  * The driver needs to call ops.open in its open callback.  Similarly,
2230  * ops.close is supposed to be called in the close callback.
2231  * ops.prepare should be called in the prepare or hw_params callback
2232  * with the proper parameters for set up.
2233  * ops.cleanup should be called in hw_free for clean up of streams.
2234  *
2235  * This function returns 0 if successfull, or a negative error code.
2236  */
2237 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2238 {
2239         struct hda_codec *codec;
2240
2241         list_for_each_entry(codec, &bus->codec_list, list) {
2242                 unsigned int pcm, s;
2243                 int err;
2244                 if (!codec->patch_ops.build_pcms)
2245                         continue;
2246                 err = codec->patch_ops.build_pcms(codec);
2247                 if (err < 0)
2248                         return err;
2249                 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2250                         for (s = 0; s < 2; s++) {
2251                                 struct hda_pcm_stream *info;
2252                                 info = &codec->pcm_info[pcm].stream[s];
2253                                 if (!info->substreams)
2254                                         continue;
2255                                 err = set_pcm_default_values(codec, info);
2256                                 if (err < 0)
2257                                         return err;
2258                         }
2259                 }
2260         }
2261         return 0;
2262 }
2263
2264 /**
2265  * snd_hda_check_board_config - compare the current codec with the config table
2266  * @codec: the HDA codec
2267  * @num_configs: number of config enums
2268  * @models: array of model name strings
2269  * @tbl: configuration table, terminated by null entries
2270  *
2271  * Compares the modelname or PCI subsystem id of the current codec with the
2272  * given configuration table.  If a matching entry is found, returns its
2273  * config value (supposed to be 0 or positive).
2274  *
2275  * If no entries are matching, the function returns a negative value.
2276  */
2277 int snd_hda_check_board_config(struct hda_codec *codec,
2278                                int num_configs, const char **models,
2279                                const struct snd_pci_quirk *tbl)
2280 {
2281         if (codec->bus->modelname && models) {
2282                 int i;
2283                 for (i = 0; i < num_configs; i++) {
2284                         if (models[i] &&
2285                             !strcmp(codec->bus->modelname, models[i])) {
2286                                 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2287                                            "selected\n", models[i]);
2288                                 return i;
2289                         }
2290                 }
2291         }
2292
2293         if (!codec->bus->pci || !tbl)
2294                 return -1;
2295
2296         tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2297         if (!tbl)
2298                 return -1;
2299         if (tbl->value >= 0 && tbl->value < num_configs) {
2300 #ifdef CONFIG_SND_DEBUG_DETECT
2301                 char tmp[10];
2302                 const char *model = NULL;
2303                 if (models)
2304                         model = models[tbl->value];
2305                 if (!model) {
2306                         sprintf(tmp, "#%d", tbl->value);
2307                         model = tmp;
2308                 }
2309                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2310                             "for config %x:%x (%s)\n",
2311                             model, tbl->subvendor, tbl->subdevice,
2312                             (tbl->name ? tbl->name : "Unknown device"));
2313 #endif
2314                 return tbl->value;
2315         }
2316         return -1;
2317 }
2318
2319 /**
2320  * snd_hda_add_new_ctls - create controls from the array
2321  * @codec: the HDA codec
2322  * @knew: the array of struct snd_kcontrol_new
2323  *
2324  * This helper function creates and add new controls in the given array.
2325  * The array must be terminated with an empty entry as terminator.
2326  *
2327  * Returns 0 if successful, or a negative error code.
2328  */
2329 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
2330 {
2331         int err;
2332
2333         for (; knew->name; knew++) {
2334                 struct snd_kcontrol *kctl;
2335                 kctl = snd_ctl_new1(knew, codec);
2336                 if (!kctl)
2337                         return -ENOMEM;
2338                 err = snd_ctl_add(codec->bus->card, kctl);
2339                 if (err < 0) {
2340                         if (!codec->addr)
2341                                 return err;
2342                         kctl = snd_ctl_new1(knew, codec);
2343                         if (!kctl)
2344                                 return -ENOMEM;
2345                         kctl->id.device = codec->addr;
2346                         err = snd_ctl_add(codec->bus->card, kctl);
2347                         if (err < 0)
2348                                 return err;
2349                 }
2350         }
2351         return 0;
2352 }
2353
2354 #ifdef CONFIG_SND_HDA_POWER_SAVE
2355 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2356                                 unsigned int power_state);
2357
2358 static void hda_power_work(struct work_struct *work)
2359 {
2360         struct hda_codec *codec =
2361                 container_of(work, struct hda_codec, power_work.work);
2362
2363         if (!codec->power_on || codec->power_count) {
2364                 codec->power_transition = 0;
2365                 return;
2366         }
2367
2368         hda_call_codec_suspend(codec);
2369         if (codec->bus->ops.pm_notify)
2370                 codec->bus->ops.pm_notify(codec);
2371 }
2372
2373 static void hda_keep_power_on(struct hda_codec *codec)
2374 {
2375         codec->power_count++;
2376         codec->power_on = 1;
2377 }
2378
2379 void snd_hda_power_up(struct hda_codec *codec)
2380 {
2381         codec->power_count++;
2382         if (codec->power_on || codec->power_transition)
2383                 return;
2384
2385         codec->power_on = 1;
2386         if (codec->bus->ops.pm_notify)
2387                 codec->bus->ops.pm_notify(codec);
2388         hda_call_codec_resume(codec);
2389         cancel_delayed_work(&codec->power_work);
2390         codec->power_transition = 0;
2391 }
2392
2393 void snd_hda_power_down(struct hda_codec *codec)
2394 {
2395         --codec->power_count;
2396         if (!codec->power_on || codec->power_count || codec->power_transition)
2397                 return;
2398         if (power_save) {
2399                 codec->power_transition = 1; /* avoid reentrance */
2400                 schedule_delayed_work(&codec->power_work,
2401                                       msecs_to_jiffies(power_save * 1000));
2402         }
2403 }
2404
2405 int snd_hda_check_amp_list_power(struct hda_codec *codec,
2406                                  struct hda_loopback_check *check,
2407                                  hda_nid_t nid)
2408 {
2409         struct hda_amp_list *p;
2410         int ch, v;
2411
2412         if (!check->amplist)
2413                 return 0;
2414         for (p = check->amplist; p->nid; p++) {
2415                 if (p->nid == nid)
2416                         break;
2417         }
2418         if (!p->nid)
2419                 return 0; /* nothing changed */
2420
2421         for (p = check->amplist; p->nid; p++) {
2422                 for (ch = 0; ch < 2; ch++) {
2423                         v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
2424                                                    p->idx);
2425                         if (!(v & HDA_AMP_MUTE) && v > 0) {
2426                                 if (!check->power_on) {
2427                                         check->power_on = 1;
2428                                         snd_hda_power_up(codec);
2429                                 }
2430                                 return 1;
2431                         }
2432                 }
2433         }
2434         if (check->power_on) {
2435                 check->power_on = 0;
2436                 snd_hda_power_down(codec);
2437         }
2438         return 0;
2439 }
2440 #endif
2441
2442 /*
2443  * Channel mode helper
2444  */
2445 int snd_hda_ch_mode_info(struct hda_codec *codec,
2446                          struct snd_ctl_elem_info *uinfo,
2447                          const struct hda_channel_mode *chmode,
2448                          int num_chmodes)
2449 {
2450         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2451         uinfo->count = 1;
2452         uinfo->value.enumerated.items = num_chmodes;
2453         if (uinfo->value.enumerated.item >= num_chmodes)
2454                 uinfo->value.enumerated.item = num_chmodes - 1;
2455         sprintf(uinfo->value.enumerated.name, "%dch",
2456                 chmode[uinfo->value.enumerated.item].channels);
2457         return 0;
2458 }
2459
2460 int snd_hda_ch_mode_get(struct hda_codec *codec,
2461                         struct snd_ctl_elem_value *ucontrol,
2462                         const struct hda_channel_mode *chmode,
2463                         int num_chmodes,
2464                         int max_channels)
2465 {
2466         int i;
2467
2468         for (i = 0; i < num_chmodes; i++) {
2469                 if (max_channels == chmode[i].channels) {
2470                         ucontrol->value.enumerated.item[0] = i;
2471                         break;
2472                 }
2473         }
2474         return 0;
2475 }
2476
2477 int snd_hda_ch_mode_put(struct hda_codec *codec,
2478                         struct snd_ctl_elem_value *ucontrol,
2479                         const struct hda_channel_mode *chmode,
2480                         int num_chmodes,
2481                         int *max_channelsp)
2482 {
2483         unsigned int mode;
2484
2485         mode = ucontrol->value.enumerated.item[0];
2486         if (mode >= num_chmodes)
2487                 return -EINVAL;
2488         if (*max_channelsp == chmode[mode].channels)
2489                 return 0;
2490         /* change the current channel setting */
2491         *max_channelsp = chmode[mode].channels;
2492         if (chmode[mode].sequence)
2493                 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
2494         return 1;
2495 }
2496
2497 /*
2498  * input MUX helper
2499  */
2500 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
2501                            struct snd_ctl_elem_info *uinfo)
2502 {
2503         unsigned int index;
2504
2505         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2506         uinfo->count = 1;
2507         uinfo->value.enumerated.items = imux->num_items;
2508         if (!imux->num_items)
2509                 return 0;
2510         index = uinfo->value.enumerated.item;
2511         if (index >= imux->num_items)
2512                 index = imux->num_items - 1;
2513         strcpy(uinfo->value.enumerated.name, imux->items[index].label);
2514         return 0;
2515 }
2516
2517 int snd_hda_input_mux_put(struct hda_codec *codec,
2518                           const struct hda_input_mux *imux,
2519                           struct snd_ctl_elem_value *ucontrol,
2520                           hda_nid_t nid,
2521                           unsigned int *cur_val)
2522 {
2523         unsigned int idx;
2524
2525         if (!imux->num_items)
2526                 return 0;
2527         idx = ucontrol->value.enumerated.item[0];
2528         if (idx >= imux->num_items)
2529                 idx = imux->num_items - 1;
2530         if (*cur_val == idx)
2531                 return 0;
2532         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
2533                                   imux->items[idx].index);
2534         *cur_val = idx;
2535         return 1;
2536 }
2537
2538
2539 /*
2540  * Multi-channel / digital-out PCM helper functions
2541  */
2542
2543 /* setup SPDIF output stream */
2544 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
2545                                  unsigned int stream_tag, unsigned int format)
2546 {
2547         /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
2548         if (codec->spdif_ctls & AC_DIG1_ENABLE)
2549                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
2550                                     codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff);
2551         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2552         /* turn on again (if needed) */
2553         if (codec->spdif_ctls & AC_DIG1_ENABLE)
2554                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
2555                                     codec->spdif_ctls & 0xff);
2556 }
2557
2558 /*
2559  * open the digital out in the exclusive mode
2560  */
2561 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
2562                                struct hda_multi_out *mout)
2563 {
2564         mutex_lock(&codec->spdif_mutex);
2565         if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
2566                 /* already opened as analog dup; reset it once */
2567                 snd_hda_codec_setup_stream(codec, mout->dig_out_nid, 0, 0, 0);
2568         mout->dig_out_used = HDA_DIG_EXCLUSIVE;
2569         mutex_unlock(&codec->spdif_mutex);
2570         return 0;
2571 }
2572
2573 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
2574                                   struct hda_multi_out *mout,
2575                                   unsigned int stream_tag,
2576                                   unsigned int format,
2577                                   struct snd_pcm_substream *substream)
2578 {
2579         mutex_lock(&codec->spdif_mutex);
2580         setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
2581         mutex_unlock(&codec->spdif_mutex);
2582         return 0;
2583 }
2584
2585 /*
2586  * release the digital out
2587  */
2588 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
2589                                 struct hda_multi_out *mout)
2590 {
2591         mutex_lock(&codec->spdif_mutex);
2592         mout->dig_out_used = 0;
2593         mutex_unlock(&codec->spdif_mutex);
2594         return 0;
2595 }
2596
2597 /*
2598  * set up more restrictions for analog out
2599  */
2600 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
2601                                   struct hda_multi_out *mout,
2602                                   struct snd_pcm_substream *substream,
2603                                   struct hda_pcm_stream *hinfo)
2604 {
2605         struct snd_pcm_runtime *runtime = substream->runtime;
2606         runtime->hw.channels_max = mout->max_channels;
2607         if (mout->dig_out_nid) {
2608                 if (!mout->analog_rates) {
2609                         mout->analog_rates = hinfo->rates;
2610                         mout->analog_formats = hinfo->formats;
2611                         mout->analog_maxbps = hinfo->maxbps;
2612                 } else {
2613                         runtime->hw.rates = mout->analog_rates;
2614                         runtime->hw.formats = mout->analog_formats;
2615                         hinfo->maxbps = mout->analog_maxbps;
2616                 }
2617                 if (!mout->spdif_rates) {
2618                         snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
2619                                                     &mout->spdif_rates,
2620                                                     &mout->spdif_formats,
2621                                                     &mout->spdif_maxbps);
2622                 }
2623                 mutex_lock(&codec->spdif_mutex);
2624                 if (mout->share_spdif) {
2625                         runtime->hw.rates &= mout->spdif_rates;
2626                         runtime->hw.formats &= mout->spdif_formats;
2627                         if (mout->spdif_maxbps < hinfo->maxbps)
2628                                 hinfo->maxbps = mout->spdif_maxbps;
2629                 }
2630         }
2631         mutex_unlock(&codec->spdif_mutex);
2632         return snd_pcm_hw_constraint_step(substream->runtime, 0,
2633                                           SNDRV_PCM_HW_PARAM_CHANNELS, 2);
2634 }
2635
2636 /*
2637  * set up the i/o for analog out
2638  * when the digital out is available, copy the front out to digital out, too.
2639  */
2640 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
2641                                      struct hda_multi_out *mout,
2642                                      unsigned int stream_tag,
2643                                      unsigned int format,
2644                                      struct snd_pcm_substream *substream)
2645 {
2646         hda_nid_t *nids = mout->dac_nids;
2647         int chs = substream->runtime->channels;
2648         int i;
2649
2650         mutex_lock(&codec->spdif_mutex);
2651         if (mout->dig_out_nid && mout->share_spdif &&
2652             mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
2653                 if (chs == 2 &&
2654                     snd_hda_is_supported_format(codec, mout->dig_out_nid,
2655                                                 format) &&
2656                     !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
2657                         mout->dig_out_used = HDA_DIG_ANALOG_DUP;
2658                         setup_dig_out_stream(codec, mout->dig_out_nid,
2659                                              stream_tag, format);
2660                 } else {
2661                         mout->dig_out_used = 0;
2662                         snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
2663                                                    0, 0, 0);
2664                 }
2665         }
2666         mutex_unlock(&codec->spdif_mutex);
2667
2668         /* front */
2669         snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
2670                                    0, format);
2671         if (!mout->no_share_stream &&
2672             mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
2673                 /* headphone out will just decode front left/right (stereo) */
2674                 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
2675                                            0, format);
2676         /* extra outputs copied from front */
2677         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
2678                 if (!mout->no_share_stream && mout->extra_out_nid[i])
2679                         snd_hda_codec_setup_stream(codec,
2680                                                    mout->extra_out_nid[i],
2681                                                    stream_tag, 0, format);
2682
2683         /* surrounds */
2684         for (i = 1; i < mout->num_dacs; i++) {
2685                 if (chs >= (i + 1) * 2) /* independent out */
2686                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
2687                                                    i * 2, format);
2688                 else if (!mout->no_share_stream) /* copy front */
2689                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
2690                                                    0, format);
2691         }
2692         return 0;
2693 }
2694
2695 /*
2696  * clean up the setting for analog out
2697  */
2698 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
2699                                      struct hda_multi_out *mout)
2700 {
2701         hda_nid_t *nids = mout->dac_nids;
2702         int i;
2703
2704         for (i = 0; i < mout->num_dacs; i++)
2705                 snd_hda_codec_setup_stream(codec, nids[i], 0, 0, 0);
2706         if (mout->hp_nid)
2707                 snd_hda_codec_setup_stream(codec, mout->hp_nid, 0, 0, 0);
2708         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
2709                 if (mout->extra_out_nid[i])
2710                         snd_hda_codec_setup_stream(codec,
2711                                                    mout->extra_out_nid[i],
2712                                                    0, 0, 0);
2713         mutex_lock(&codec->spdif_mutex);
2714         if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
2715                 snd_hda_codec_setup_stream(codec, mout->dig_out_nid, 0, 0, 0);
2716                 mout->dig_out_used = 0;
2717         }
2718         mutex_unlock(&codec->spdif_mutex);
2719         return 0;
2720 }
2721
2722 /*
2723  * Helper for automatic ping configuration
2724  */
2725
2726 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
2727 {
2728         for (; *list; list++)
2729                 if (*list == nid)
2730                         return 1;
2731         return 0;
2732 }
2733
2734
2735 /*
2736  * Sort an associated group of pins according to their sequence numbers.
2737  */
2738 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
2739                                   int num_pins)
2740 {
2741         int i, j;
2742         short seq;
2743         hda_nid_t nid;
2744
2745         for (i = 0; i < num_pins; i++) {
2746                 for (j = i + 1; j < num_pins; j++) {
2747                         if (sequences[i] > sequences[j]) {
2748                                 seq = sequences[i];
2749                                 sequences[i] = sequences[j];
2750                                 sequences[j] = seq;
2751                                 nid = pins[i];
2752                                 pins[i] = pins[j];
2753                                 pins[j] = nid;
2754                         }
2755                 }
2756         }
2757 }
2758
2759
2760 /*
2761  * Parse all pin widgets and store the useful pin nids to cfg
2762  *
2763  * The number of line-outs or any primary output is stored in line_outs,
2764  * and the corresponding output pins are assigned to line_out_pins[],
2765  * in the order of front, rear, CLFE, side, ...
2766  *
2767  * If more extra outputs (speaker and headphone) are found, the pins are
2768  * assisnged to hp_pins[] and speaker_pins[], respectively.  If no line-out jack
2769  * is detected, one of speaker of HP pins is assigned as the primary
2770  * output, i.e. to line_out_pins[0].  So, line_outs is always positive
2771  * if any analog output exists.
2772  *
2773  * The analog input pins are assigned to input_pins array.
2774  * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
2775  * respectively.
2776  */
2777 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
2778                                  struct auto_pin_cfg *cfg,
2779                                  hda_nid_t *ignore_nids)
2780 {
2781         hda_nid_t nid, end_nid;
2782         short seq, assoc_line_out, assoc_speaker;
2783         short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
2784         short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
2785         short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
2786
2787         memset(cfg, 0, sizeof(*cfg));
2788
2789         memset(sequences_line_out, 0, sizeof(sequences_line_out));
2790         memset(sequences_speaker, 0, sizeof(sequences_speaker));
2791         memset(sequences_hp, 0, sizeof(sequences_hp));
2792         assoc_line_out = assoc_speaker = 0;
2793
2794         end_nid = codec->start_nid + codec->num_nodes;
2795         for (nid = codec->start_nid; nid < end_nid; nid++) {
2796                 unsigned int wid_caps = get_wcaps(codec, nid);
2797                 unsigned int wid_type =
2798                         (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2799                 unsigned int def_conf;
2800                 short assoc, loc;
2801
2802                 /* read all default configuration for pin complex */
2803                 if (wid_type != AC_WID_PIN)
2804                         continue;
2805                 /* ignore the given nids (e.g. pc-beep returns error) */
2806                 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
2807                         continue;
2808
2809                 def_conf = snd_hda_codec_read(codec, nid, 0,
2810                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
2811                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
2812                         continue;
2813                 loc = get_defcfg_location(def_conf);
2814                 switch (get_defcfg_device(def_conf)) {
2815                 case AC_JACK_LINE_OUT:
2816                         seq = get_defcfg_sequence(def_conf);
2817                         assoc = get_defcfg_association(def_conf);
2818
2819                         if (!(wid_caps & AC_WCAP_STEREO))
2820                                 if (!cfg->mono_out_pin)
2821                                         cfg->mono_out_pin = nid;
2822                         if (!assoc)
2823                                 continue;
2824                         if (!assoc_line_out)
2825                                 assoc_line_out = assoc;
2826                         else if (assoc_line_out != assoc)
2827                                 continue;
2828                         if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
2829                                 continue;
2830                         cfg->line_out_pins[cfg->line_outs] = nid;
2831                         sequences_line_out[cfg->line_outs] = seq;
2832                         cfg->line_outs++;
2833                         break;
2834                 case AC_JACK_SPEAKER:
2835                         seq = get_defcfg_sequence(def_conf);
2836                         assoc = get_defcfg_association(def_conf);
2837                         if (! assoc)
2838                                 continue;
2839                         if (! assoc_speaker)
2840                                 assoc_speaker = assoc;
2841                         else if (assoc_speaker != assoc)
2842                                 continue;
2843                         if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
2844                                 continue;
2845                         cfg->speaker_pins[cfg->speaker_outs] = nid;
2846                         sequences_speaker[cfg->speaker_outs] = seq;
2847                         cfg->speaker_outs++;
2848                         break;
2849                 case AC_JACK_HP_OUT:
2850                         seq = get_defcfg_sequence(def_conf);
2851                         assoc = get_defcfg_association(def_conf);
2852                         if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
2853                                 continue;
2854                         cfg->hp_pins[cfg->hp_outs] = nid;
2855                         sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
2856                         cfg->hp_outs++;
2857                         break;
2858                 case AC_JACK_MIC_IN: {
2859                         int preferred, alt;
2860                         if (loc == AC_JACK_LOC_FRONT) {
2861                                 preferred = AUTO_PIN_FRONT_MIC;
2862                                 alt = AUTO_PIN_MIC;
2863                         } else {
2864                                 preferred = AUTO_PIN_MIC;
2865                                 alt = AUTO_PIN_FRONT_MIC;
2866                         }
2867                         if (!cfg->input_pins[preferred])
2868                                 cfg->input_pins[preferred] = nid;
2869                         else if (!cfg->input_pins[alt])
2870                                 cfg->input_pins[alt] = nid;
2871                         break;
2872                 }
2873                 case AC_JACK_LINE_IN:
2874                         if (loc == AC_JACK_LOC_FRONT)
2875                                 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
2876                         else
2877                                 cfg->input_pins[AUTO_PIN_LINE] = nid;
2878                         break;
2879                 case AC_JACK_CD:
2880                         cfg->input_pins[AUTO_PIN_CD] = nid;
2881                         break;
2882                 case AC_JACK_AUX:
2883                         cfg->input_pins[AUTO_PIN_AUX] = nid;
2884                         break;
2885                 case AC_JACK_SPDIF_OUT:
2886                         cfg->dig_out_pin = nid;
2887                         break;
2888                 case AC_JACK_SPDIF_IN:
2889                         cfg->dig_in_pin = nid;
2890                         break;
2891                 }
2892         }
2893
2894         /* FIX-UP:
2895          * If no line-out is defined but multiple HPs are found,
2896          * some of them might be the real line-outs.
2897          */
2898         if (!cfg->line_outs && cfg->hp_outs > 1) {
2899                 int i = 0;
2900                 while (i < cfg->hp_outs) {
2901                         /* The real HPs should have the sequence 0x0f */
2902                         if ((sequences_hp[i] & 0x0f) == 0x0f) {
2903                                 i++;
2904                                 continue;
2905                         }
2906                         /* Move it to the line-out table */
2907                         cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
2908                         sequences_line_out[cfg->line_outs] = sequences_hp[i];
2909                         cfg->line_outs++;
2910                         cfg->hp_outs--;
2911                         memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
2912                                 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
2913                         memmove(sequences_hp + i - 1, sequences_hp + i,
2914                                 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
2915                 }
2916         }
2917
2918         /* sort by sequence */
2919         sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
2920                               cfg->line_outs);
2921         sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
2922                               cfg->speaker_outs);
2923         sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
2924                               cfg->hp_outs);
2925
2926         /* if we have only one mic, make it AUTO_PIN_MIC */
2927         if (!cfg->input_pins[AUTO_PIN_MIC] &&
2928             cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
2929                 cfg->input_pins[AUTO_PIN_MIC] =
2930                         cfg->input_pins[AUTO_PIN_FRONT_MIC];
2931                 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
2932         }
2933         /* ditto for line-in */
2934         if (!cfg->input_pins[AUTO_PIN_LINE] &&
2935             cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
2936                 cfg->input_pins[AUTO_PIN_LINE] =
2937                         cfg->input_pins[AUTO_PIN_FRONT_LINE];
2938                 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
2939         }
2940
2941         /*
2942          * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
2943          * as a primary output
2944          */
2945         if (!cfg->line_outs) {
2946                 if (cfg->speaker_outs) {
2947                         cfg->line_outs = cfg->speaker_outs;
2948                         memcpy(cfg->line_out_pins, cfg->speaker_pins,
2949                                sizeof(cfg->speaker_pins));
2950                         cfg->speaker_outs = 0;
2951                         memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
2952                         cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
2953                 } else if (cfg->hp_outs) {
2954                         cfg->line_outs = cfg->hp_outs;
2955                         memcpy(cfg->line_out_pins, cfg->hp_pins,
2956                                sizeof(cfg->hp_pins));
2957                         cfg->hp_outs = 0;
2958                         memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
2959                         cfg->line_out_type = AUTO_PIN_HP_OUT;
2960                 }
2961         }
2962
2963         /* Reorder the surround channels
2964          * ALSA sequence is front/surr/clfe/side
2965          * HDA sequence is:
2966          *    4-ch: front/surr  =>  OK as it is
2967          *    6-ch: front/clfe/surr
2968          *    8-ch: front/clfe/rear/side|fc
2969          */
2970         switch (cfg->line_outs) {
2971         case 3:
2972         case 4:
2973                 nid = cfg->line_out_pins[1];
2974                 cfg->line_out_pins[1] = cfg->line_out_pins[2];
2975                 cfg->line_out_pins[2] = nid;
2976                 break;
2977         }
2978
2979         /*
2980          * debug prints of the parsed results
2981          */
2982         snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2983                    cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
2984                    cfg->line_out_pins[2], cfg->line_out_pins[3],
2985                    cfg->line_out_pins[4]);
2986         snd_printd("   speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2987                    cfg->speaker_outs, cfg->speaker_pins[0],
2988                    cfg->speaker_pins[1], cfg->speaker_pins[2],
2989                    cfg->speaker_pins[3], cfg->speaker_pins[4]);
2990         snd_printd("   hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2991                    cfg->hp_outs, cfg->hp_pins[0],
2992                    cfg->hp_pins[1], cfg->hp_pins[2],
2993                    cfg->hp_pins[3], cfg->hp_pins[4]);
2994         snd_printd("   mono: mono_out=0x%x\n", cfg->mono_out_pin);
2995         snd_printd("   inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
2996                    " cd=0x%x, aux=0x%x\n",
2997                    cfg->input_pins[AUTO_PIN_MIC],
2998                    cfg->input_pins[AUTO_PIN_FRONT_MIC],
2999                    cfg->input_pins[AUTO_PIN_LINE],
3000                    cfg->input_pins[AUTO_PIN_FRONT_LINE],
3001                    cfg->input_pins[AUTO_PIN_CD],
3002                    cfg->input_pins[AUTO_PIN_AUX]);
3003
3004         return 0;
3005 }
3006
3007 /* labels for input pins */
3008 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3009         "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3010 };
3011
3012
3013 #ifdef CONFIG_PM
3014 /*
3015  * power management
3016  */
3017
3018 /**
3019  * snd_hda_suspend - suspend the codecs
3020  * @bus: the HDA bus
3021  * @state: suspsend state
3022  *
3023  * Returns 0 if successful.
3024  */
3025 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3026 {
3027         struct hda_codec *codec;
3028
3029         list_for_each_entry(codec, &bus->codec_list, list) {
3030 #ifdef CONFIG_SND_HDA_POWER_SAVE
3031                 if (!codec->power_on)
3032                         continue;
3033 #endif
3034                 hda_call_codec_suspend(codec);
3035         }
3036         return 0;
3037 }
3038
3039 /**
3040  * snd_hda_resume - resume the codecs
3041  * @bus: the HDA bus
3042  * @state: resume state
3043  *
3044  * Returns 0 if successful.
3045  *
3046  * This fucntion is defined only when POWER_SAVE isn't set.
3047  * In the power-save mode, the codec is resumed dynamically.
3048  */
3049 int snd_hda_resume(struct hda_bus *bus)
3050 {
3051         struct hda_codec *codec;
3052
3053         list_for_each_entry(codec, &bus->codec_list, list) {
3054                 if (snd_hda_codec_needs_resume(codec))
3055                         hda_call_codec_resume(codec);
3056         }
3057         return 0;
3058 }
3059 #ifdef CONFIG_SND_HDA_POWER_SAVE
3060 int snd_hda_codecs_inuse(struct hda_bus *bus)
3061 {
3062         struct hda_codec *codec;
3063
3064         list_for_each_entry(codec, &bus->codec_list, list) {
3065                 if (snd_hda_codec_needs_resume(codec))
3066                         return 1;
3067         }
3068         return 0;
3069 }
3070 #endif
3071 #endif