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