sound/pci/hda/hda_codec.c

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