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