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