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