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