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