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