git.oblomov.eu Git - linux-2.6/blob - sound/pci/hda/hda_codec.c

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