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