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