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