git.oblomov.eu Git - linux-2.6/blob - sound/pci/hda/hda_codec.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
   5  *
   6  *
   7  *  This driver is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This driver is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20  */
  21
  22 #include <linux/init.h>
  23 #include <linux/delay.h>
  24 #include <linux/slab.h>
  25 #include <linux/pci.h>
  26 #include <linux/mutex.h>
  27 #include <sound/core.h>
  28 #include "hda_codec.h"
  29 #include <sound/asoundef.h>
  30 #include <sound/tlv.h>
  31 #include <sound/initval.h>
  32 #include "hda_local.h"
  33 #include <sound/hda_hwdep.h>
  34
  35 /*
  36  * vendor / preset table
  37  */
  38
  39 struct hda_vendor_id {
  40         unsigned int id;
  41         const char *name;
  42 };
  43
  44 /* codec vendor labels */
  45 static struct hda_vendor_id hda_vendor_ids[] = {
  46         { 0x1002, "ATI" },
  47         { 0x1057, "Motorola" },
  48         { 0x1095, "Silicon Image" },
  49         { 0x10de, "Nvidia" },
  50         { 0x10ec, "Realtek" },
  51         { 0x1106, "VIA" },
  52         { 0x111d, "IDT" },
  53         { 0x11c1, "LSI" },
  54         { 0x11d4, "Analog Devices" },
  55         { 0x13f6, "C-Media" },
  56         { 0x14f1, "Conexant" },
  57         { 0x17e8, "Chrontel" },
  58         { 0x1854, "LG" },
  59         { 0x1aec, "Wolfson Microelectronics" },
  60         { 0x434d, "C-Media" },
  61         { 0x8086, "Intel" },
  62         { 0x8384, "SigmaTel" },
  63         {} /* terminator */
  64 };
  65
  66 static DEFINE_MUTEX(preset_mutex);
  67 static LIST_HEAD(hda_preset_tables);
  68
  69 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
  70 {
  71         mutex_lock(&preset_mutex);
  72         list_add_tail(&preset->list, &hda_preset_tables);
  73         mutex_unlock(&preset_mutex);
  74         return 0;
  75 }
  76 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
  77
  78 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
  79 {
  80         mutex_lock(&preset_mutex);
  81         list_del(&preset->list);
  82         mutex_unlock(&preset_mutex);
  83         return 0;
  84 }
  85 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
  86
  87 #ifdef CONFIG_SND_HDA_POWER_SAVE
  88 static void hda_power_work(struct work_struct *work);
  89 static void hda_keep_power_on(struct hda_codec *codec);
  90 #else
  91 static inline void hda_keep_power_on(struct hda_codec *codec) {}
  92 #endif
  93
  94 const char *snd_hda_get_jack_location(u32 cfg)
  95 {
  96         static char *bases[7] = {
  97                 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
  98         };
  99         static unsigned char specials_idx[] = {
 100                 0x07, 0x08,
 101                 0x17, 0x18, 0x19,
 102                 0x37, 0x38
 103         };
 104         static char *specials[] = {
 105                 "Rear Panel", "Drive Bar",
 106                 "Riser", "HDMI", "ATAPI",
 107                 "Mobile-In", "Mobile-Out"
 108         };
 109         int i;
 110         cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
 111         if ((cfg & 0x0f) < 7)
 112                 return bases[cfg & 0x0f];
 113         for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
 114                 if (cfg == specials_idx[i])
 115                         return specials[i];
 116         }
 117         return "UNKNOWN";
 118 }
 119 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
 120
 121 const char *snd_hda_get_jack_connectivity(u32 cfg)
 122 {
 123         static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
 124
 125         return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
 126 }
 127 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
 128
 129 const char *snd_hda_get_jack_type(u32 cfg)
 130 {
 131         static char *jack_types[16] = {
 132                 "Line Out", "Speaker", "HP Out", "CD",
 133                 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
 134                 "Line In", "Aux", "Mic", "Telephony",
 135                 "SPDIF In", "Digitial In", "Reserved", "Other"
 136         };
 137
 138         return jack_types[(cfg & AC_DEFCFG_DEVICE)
 139                                 >> AC_DEFCFG_DEVICE_SHIFT];
 140 }
 141 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
 142
 143 /*
 144  * Compose a 32bit command word to be sent to the HD-audio controller
 145  */
 146 static inline unsigned int
 147 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
 148                unsigned int verb, unsigned int parm)
 149 {
 150         u32 val;
 151
 152         val = (u32)(codec->addr & 0x0f) << 28;
 153         val |= (u32)direct << 27;
 154         val |= (u32)nid << 20;
 155         val |= verb << 8;
 156         val |= parm;
 157         return val;
 158 }
 159
 160 /**
 161  * snd_hda_codec_read - send a command and get the response
 162  * @codec: the HDA codec
 163  * @nid: NID to send the command
 164  * @direct: direct flag
 165  * @verb: the verb to send
 166  * @parm: the parameter for the verb
 167  *
 168  * Send a single command and read the corresponding response.
 169  *
 170  * Returns the obtained response value, or -1 for an error.
 171  */
 172 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
 173                                 int direct,
 174                                 unsigned int verb, unsigned int parm)
 175 {
 176         struct hda_bus *bus = codec->bus;
 177         unsigned int res;
 178
 179         res = make_codec_cmd(codec, nid, direct, verb, parm);
 180         snd_hda_power_up(codec);
 181         mutex_lock(&bus->cmd_mutex);
 182         if (!bus->ops.command(bus, res))
 183                 res = bus->ops.get_response(bus);
 184         else
 185                 res = (unsigned int)-1;
 186         mutex_unlock(&bus->cmd_mutex);
 187         snd_hda_power_down(codec);
 188         return res;
 189 }
 190 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
 191
 192 /**
 193  * snd_hda_codec_write - send a single command without waiting for response
 194  * @codec: the HDA codec
 195  * @nid: NID to send the command
 196  * @direct: direct flag
 197  * @verb: the verb to send
 198  * @parm: the parameter for the verb
 199  *
 200  * Send a single command without waiting for response.
 201  *
 202  * Returns 0 if successful, or a negative error code.
 203  */
 204 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
 205                          unsigned int verb, unsigned int parm)
 206 {
 207         struct hda_bus *bus = codec->bus;
 208         unsigned int res;
 209         int err;
 210
 211         res = make_codec_cmd(codec, nid, direct, verb, parm);
 212         snd_hda_power_up(codec);
 213         mutex_lock(&bus->cmd_mutex);
 214         err = bus->ops.command(bus, res);
 215         mutex_unlock(&bus->cmd_mutex);
 216         snd_hda_power_down(codec);
 217         return err;
 218 }
 219 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
 220
 221 /**
 222  * snd_hda_sequence_write - sequence writes
 223  * @codec: the HDA codec
 224  * @seq: VERB array to send
 225  *
 226  * Send the commands sequentially from the given array.
 227  * The array must be terminated with NID=0.
 228  */
 229 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
 230 {
 231         for (; seq->nid; seq++)
 232                 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
 233 }
 234 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
 235
 236 /**
 237  * snd_hda_get_sub_nodes - get the range of sub nodes
 238  * @codec: the HDA codec
 239  * @nid: NID to parse
 240  * @start_id: the pointer to store the start NID
 241  *
 242  * Parse the NID and store the start NID of its sub-nodes.
 243  * Returns the number of sub-nodes.
 244  */
 245 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
 246                           hda_nid_t *start_id)
 247 {
 248         unsigned int parm;
 249
 250         parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
 251         if (parm == -1)
 252                 return 0;
 253         *start_id = (parm >> 16) & 0x7fff;
 254         return (int)(parm & 0x7fff);
 255 }
 256 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
 257
 258 /**
 259  * snd_hda_get_connections - get connection list
 260  * @codec: the HDA codec
 261  * @nid: NID to parse
 262  * @conn_list: connection list array
 263  * @max_conns: max. number of connections to store
 264  *
 265  * Parses the connection list of the given widget and stores the list
 266  * of NIDs.
 267  *
 268  * Returns the number of connections, or a negative error code.
 269  */
 270 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
 271                             hda_nid_t *conn_list, int max_conns)
 272 {
 273         unsigned int parm;
 274         int i, conn_len, conns;
 275         unsigned int shift, num_elems, mask;
 276         hda_nid_t prev_nid;
 277
 278         if (snd_BUG_ON(!conn_list || max_conns <= 0))
 279                 return -EINVAL;
 280
 281         parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
 282         if (parm & AC_CLIST_LONG) {
 283                 /* long form */
 284                 shift = 16;
 285                 num_elems = 2;
 286         } else {
 287                 /* short form */
 288                 shift = 8;
 289                 num_elems = 4;
 290         }
 291         conn_len = parm & AC_CLIST_LENGTH;
 292         mask = (1 << (shift-1)) - 1;
 293
 294         if (!conn_len)
 295                 return 0; /* no connection */
 296
 297         if (conn_len == 1) {
 298                 /* single connection */
 299                 parm = snd_hda_codec_read(codec, nid, 0,
 300                                           AC_VERB_GET_CONNECT_LIST, 0);
 301                 conn_list[0] = parm & mask;
 302                 return 1;
 303         }
 304
 305         /* multi connection */
 306         conns = 0;
 307         prev_nid = 0;
 308         for (i = 0; i < conn_len; i++) {
 309                 int range_val;
 310                 hda_nid_t val, n;
 311
 312                 if (i % num_elems == 0)
 313                         parm = snd_hda_codec_read(codec, nid, 0,
 314                                                   AC_VERB_GET_CONNECT_LIST, i);
 315                 range_val = !!(parm & (1 << (shift-1))); /* ranges */
 316                 val = parm & mask;
 317                 parm >>= shift;
 318                 if (range_val) {
 319                         /* ranges between the previous and this one */
 320                         if (!prev_nid || prev_nid >= val) {
 321                                 snd_printk(KERN_WARNING "hda_codec: "
 322                                            "invalid dep_range_val %x:%x\n",
 323                                            prev_nid, val);
 324                                 continue;
 325                         }
 326                         for (n = prev_nid + 1; n <= val; n++) {
 327                                 if (conns >= max_conns) {
 328                                         snd_printk(KERN_ERR
 329                                                    "Too many connections\n");
 330                                         return -EINVAL;
 331                                 }
 332                                 conn_list[conns++] = n;
 333                         }
 334                 } else {
 335                         if (conns >= max_conns) {
 336                                 snd_printk(KERN_ERR "Too many connections\n");
 337                                 return -EINVAL;
 338                         }
 339                         conn_list[conns++] = val;
 340                 }
 341                 prev_nid = val;
 342         }
 343         return conns;
 344 }
 345 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
 346
 347
 348 /**
 349  * snd_hda_queue_unsol_event - add an unsolicited event to queue
 350  * @bus: the BUS
 351  * @res: unsolicited event (lower 32bit of RIRB entry)
 352  * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
 353  *
 354  * Adds the given event to the queue.  The events are processed in
 355  * the workqueue asynchronously.  Call this function in the interrupt
 356  * hanlder when RIRB receives an unsolicited event.
 357  *
 358  * Returns 0 if successful, or a negative error code.
 359  */
 360 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
 361 {
 362         struct hda_bus_unsolicited *unsol;
 363         unsigned int wp;
 364
 365         unsol = bus->unsol;
 366         if (!unsol)
 367                 return 0;
 368
 369         wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
 370         unsol->wp = wp;
 371
 372         wp <<= 1;
 373         unsol->queue[wp] = res;
 374         unsol->queue[wp + 1] = res_ex;
 375
 376         queue_work(bus->workq, &unsol->work);
 377
 378         return 0;
 379 }
 380 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
 381
 382 /*
 383  * process queued unsolicited events
 384  */
 385 static void process_unsol_events(struct work_struct *work)
 386 {
 387         struct hda_bus_unsolicited *unsol =
 388                 container_of(work, struct hda_bus_unsolicited, work);
 389         struct hda_bus *bus = unsol->bus;
 390         struct hda_codec *codec;
 391         unsigned int rp, caddr, res;
 392
 393         while (unsol->rp != unsol->wp) {
 394                 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
 395                 unsol->rp = rp;
 396                 rp <<= 1;
 397                 res = unsol->queue[rp];
 398                 caddr = unsol->queue[rp + 1];
 399                 if (!(caddr & (1 << 4))) /* no unsolicited event? */
 400                         continue;
 401                 codec = bus->caddr_tbl[caddr & 0x0f];
 402                 if (codec && codec->patch_ops.unsol_event)
 403                         codec->patch_ops.unsol_event(codec, res);
 404         }
 405 }
 406
 407 /*
 408  * initialize unsolicited queue
 409  */
 410 static int init_unsol_queue(struct hda_bus *bus)
 411 {
 412         struct hda_bus_unsolicited *unsol;
 413
 414         if (bus->unsol) /* already initialized */
 415                 return 0;
 416
 417         unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
 418         if (!unsol) {
 419                 snd_printk(KERN_ERR "hda_codec: "
 420                            "can't allocate unsolicited queue\n");
 421                 return -ENOMEM;
 422         }
 423         INIT_WORK(&unsol->work, process_unsol_events);
 424         unsol->bus = bus;
 425         bus->unsol = unsol;
 426         return 0;
 427 }
 428
 429 /*
 430  * destructor
 431  */
 432 static void snd_hda_codec_free(struct hda_codec *codec);
 433
 434 static int snd_hda_bus_free(struct hda_bus *bus)
 435 {
 436         struct hda_codec *codec, *n;
 437
 438         if (!bus)
 439                 return 0;
 440         if (bus->workq)
 441                 flush_workqueue(bus->workq);
 442         if (bus->unsol)
 443                 kfree(bus->unsol);
 444         list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
 445                 snd_hda_codec_free(codec);
 446         }
 447         if (bus->ops.private_free)
 448                 bus->ops.private_free(bus);
 449         if (bus->workq)
 450                 destroy_workqueue(bus->workq);
 451         kfree(bus);
 452         return 0;
 453 }
 454
 455 static int snd_hda_bus_dev_free(struct snd_device *device)
 456 {
 457         struct hda_bus *bus = device->device_data;
 458         bus->shutdown = 1;
 459         return snd_hda_bus_free(bus);
 460 }
 461
 462 #ifdef CONFIG_SND_HDA_HWDEP
 463 static int snd_hda_bus_dev_register(struct snd_device *device)
 464 {
 465         struct hda_bus *bus = device->device_data;
 466         struct hda_codec *codec;
 467         list_for_each_entry(codec, &bus->codec_list, list) {
 468                 snd_hda_hwdep_add_sysfs(codec);
 469         }
 470         return 0;
 471 }
 472 #else
 473 #define snd_hda_bus_dev_register        NULL
 474 #endif
 475
 476 /**
 477  * snd_hda_bus_new - create a HDA bus
 478  * @card: the card entry
 479  * @temp: the template for hda_bus information
 480  * @busp: the pointer to store the created bus instance
 481  *
 482  * Returns 0 if successful, or a negative error code.
 483  */
 484 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
 485                               const struct hda_bus_template *temp,
 486                               struct hda_bus **busp)
 487 {
 488         struct hda_bus *bus;
 489         int err;
 490         char qname[8];
 491         static struct snd_device_ops dev_ops = {
 492                 .dev_register = snd_hda_bus_dev_register,
 493                 .dev_free = snd_hda_bus_dev_free,
 494         };
 495
 496         if (snd_BUG_ON(!temp))
 497                 return -EINVAL;
 498         if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
 499                 return -EINVAL;
 500
 501         if (busp)
 502                 *busp = NULL;
 503
 504         bus = kzalloc(sizeof(*bus), GFP_KERNEL);
 505         if (bus == NULL) {
 506                 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
 507                 return -ENOMEM;
 508         }
 509
 510         bus->card = card;
 511         bus->private_data = temp->private_data;
 512         bus->pci = temp->pci;
 513         bus->modelname = temp->modelname;
 514         bus->power_save = temp->power_save;
 515         bus->ops = temp->ops;
 516
 517         mutex_init(&bus->cmd_mutex);
 518         INIT_LIST_HEAD(&bus->codec_list);
 519
 520         snprintf(qname, sizeof(qname), "hda%d", card->number);
 521         bus->workq = create_workqueue(qname);
 522         if (!bus->workq) {
 523                 snd_printk(KERN_ERR "cannot create workqueue %s\n", qname);
 524                 kfree(bus);
 525                 return -ENOMEM;
 526         }
 527
 528         err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
 529         if (err < 0) {
 530                 snd_hda_bus_free(bus);
 531                 return err;
 532         }
 533         if (busp)
 534                 *busp = bus;
 535         return 0;
 536 }
 537 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
 538
 539 #ifdef CONFIG_SND_HDA_GENERIC
 540 #define is_generic_config(codec) \
 541         (codec->modelname && !strcmp(codec->modelname, "generic"))
 542 #else
 543 #define is_generic_config(codec)        0
 544 #endif
 545
 546 #ifdef MODULE
 547 #define HDA_MODREQ_MAX_COUNT    2       /* two request_modules()'s */
 548 #else
 549 #define HDA_MODREQ_MAX_COUNT    0       /* all presets are statically linked */
 550 #endif
 551
 552 /*
 553  * find a matching codec preset
 554  */
 555 static const struct hda_codec_preset *
 556 find_codec_preset(struct hda_codec *codec)
 557 {
 558         struct hda_codec_preset_list *tbl;
 559         const struct hda_codec_preset *preset;
 560         int mod_requested = 0;
 561
 562         if (is_generic_config(codec))
 563                 return NULL; /* use the generic parser */
 564
 565  again:
 566         mutex_lock(&preset_mutex);
 567         list_for_each_entry(tbl, &hda_preset_tables, list) {
 568                 if (!try_module_get(tbl->owner)) {
 569                         snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
 570                         continue;
 571                 }
 572                 for (preset = tbl->preset; preset->id; preset++) {
 573                         u32 mask = preset->mask;
 574                         if (preset->afg && preset->afg != codec->afg)
 575                                 continue;
 576                         if (preset->mfg && preset->mfg != codec->mfg)
 577                                 continue;
 578                         if (!mask)
 579                                 mask = ~0;
 580                         if (preset->id == (codec->vendor_id & mask) &&
 581                             (!preset->rev ||
 582                              preset->rev == codec->revision_id)) {
 583                                 mutex_unlock(&preset_mutex);
 584                                 codec->owner = tbl->owner;
 585                                 return preset;
 586                         }
 587                 }
 588                 module_put(tbl->owner);
 589         }
 590         mutex_unlock(&preset_mutex);
 591
 592         if (mod_requested < HDA_MODREQ_MAX_COUNT) {
 593                 char name[32];
 594                 if (!mod_requested)
 595                         snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
 596                                  codec->vendor_id);
 597                 else
 598                         snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
 599                                  (codec->vendor_id >> 16) & 0xffff);
 600                 request_module(name);
 601                 mod_requested++;
 602                 goto again;
 603         }
 604         return NULL;
 605 }
 606
 607 /*
 608  * get_codec_name - store the codec name
 609  */
 610 static int get_codec_name(struct hda_codec *codec)
 611 {
 612         const struct hda_vendor_id *c;
 613         const char *vendor = NULL;
 614         u16 vendor_id = codec->vendor_id >> 16;
 615         char tmp[16], name[32];
 616
 617         for (c = hda_vendor_ids; c->id; c++) {
 618                 if (c->id == vendor_id) {
 619                         vendor = c->name;
 620                         break;
 621                 }
 622         }
 623         if (!vendor) {
 624                 sprintf(tmp, "Generic %04x", vendor_id);
 625                 vendor = tmp;
 626         }
 627         if (codec->preset && codec->preset->name)
 628                 snprintf(name, sizeof(name), "%s %s", vendor,
 629                          codec->preset->name);
 630         else
 631                 snprintf(name, sizeof(name), "%s ID %x", vendor,
 632                          codec->vendor_id & 0xffff);
 633         codec->name = kstrdup(name, GFP_KERNEL);
 634         if (!codec->name)
 635                 return -ENOMEM;
 636         return 0;
 637 }
 638
 639 /*
 640  * look for an AFG and MFG nodes
 641  */
 642 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
 643 {
 644         int i, total_nodes;
 645         hda_nid_t nid;
 646
 647         total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
 648         for (i = 0; i < total_nodes; i++, nid++) {
 649                 unsigned int func;
 650                 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
 651                 switch (func & 0xff) {
 652                 case AC_GRP_AUDIO_FUNCTION:
 653                         codec->afg = nid;
 654                         break;
 655                 case AC_GRP_MODEM_FUNCTION:
 656                         codec->mfg = nid;
 657                         break;
 658                 default:
 659                         break;
 660                 }
 661         }
 662 }
 663
 664 /*
 665  * read widget caps for each widget and store in cache
 666  */
 667 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
 668 {
 669         int i;
 670         hda_nid_t nid;
 671
 672         codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
 673                                                  &codec->start_nid);
 674         codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
 675         if (!codec->wcaps)
 676                 return -ENOMEM;
 677         nid = codec->start_nid;
 678         for (i = 0; i < codec->num_nodes; i++, nid++)
 679                 codec->wcaps[i] = snd_hda_param_read(codec, nid,
 680                                                      AC_PAR_AUDIO_WIDGET_CAP);
 681         return 0;
 682 }
 683
 684
 685 static void init_hda_cache(struct hda_cache_rec *cache,
 686                            unsigned int record_size);
 687 static void free_hda_cache(struct hda_cache_rec *cache);
 688
 689 /*
 690  * codec destructor
 691  */
 692 static void snd_hda_codec_free(struct hda_codec *codec)
 693 {
 694         if (!codec)
 695                 return;
 696 #ifdef CONFIG_SND_HDA_POWER_SAVE
 697         cancel_delayed_work(&codec->power_work);
 698         flush_workqueue(codec->bus->workq);
 699 #endif
 700         list_del(&codec->list);
 701         snd_array_free(&codec->mixers);
 702         codec->bus->caddr_tbl[codec->addr] = NULL;
 703         if (codec->patch_ops.free)
 704                 codec->patch_ops.free(codec);
 705         module_put(codec->owner);
 706         free_hda_cache(&codec->amp_cache);
 707         free_hda_cache(&codec->cmd_cache);
 708         kfree(codec->name);
 709         kfree(codec->modelname);
 710         kfree(codec->wcaps);
 711         kfree(codec);
 712 }
 713
 714 /**
 715  * snd_hda_codec_new - create a HDA codec
 716  * @bus: the bus to assign
 717  * @codec_addr: the codec address
 718  * @codecp: the pointer to store the generated codec
 719  *
 720  * Returns 0 if successful, or a negative error code.
 721  */
 722 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
 723                                     int do_init, struct hda_codec **codecp)
 724 {
 725         struct hda_codec *codec;
 726         char component[31];
 727         int err;
 728
 729         if (snd_BUG_ON(!bus))
 730                 return -EINVAL;
 731         if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
 732                 return -EINVAL;
 733
 734         if (bus->caddr_tbl[codec_addr]) {
 735                 snd_printk(KERN_ERR "hda_codec: "
 736                            "address 0x%x is already occupied\n", codec_addr);
 737                 return -EBUSY;
 738         }
 739
 740         codec = kzalloc(sizeof(*codec), GFP_KERNEL);
 741         if (codec == NULL) {
 742                 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
 743                 return -ENOMEM;
 744         }
 745
 746         codec->bus = bus;
 747         codec->addr = codec_addr;
 748         mutex_init(&codec->spdif_mutex);
 749         mutex_init(&codec->control_mutex);
 750         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
 751         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
 752         snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
 753         if (codec->bus->modelname) {
 754                 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
 755                 if (!codec->modelname) {
 756                         snd_hda_codec_free(codec);
 757                         return -ENODEV;
 758                 }
 759         }
 760
 761 #ifdef CONFIG_SND_HDA_POWER_SAVE
 762         INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
 763         /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
 764          * the caller has to power down appropriatley after initialization
 765          * phase.
 766          */
 767         hda_keep_power_on(codec);
 768 #endif
 769
 770         list_add_tail(&codec->list, &bus->codec_list);
 771         bus->caddr_tbl[codec_addr] = codec;
 772
 773         codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
 774                                               AC_PAR_VENDOR_ID);
 775         if (codec->vendor_id == -1)
 776                 /* read again, hopefully the access method was corrected
 777                  * in the last read...
 778                  */
 779                 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
 780                                                       AC_PAR_VENDOR_ID);
 781         codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
 782                                                  AC_PAR_SUBSYSTEM_ID);
 783         codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
 784                                                 AC_PAR_REV_ID);
 785
 786         setup_fg_nodes(codec);
 787         if (!codec->afg && !codec->mfg) {
 788                 snd_printdd("hda_codec: no AFG or MFG node found\n");
 789                 snd_hda_codec_free(codec);
 790                 return -ENODEV;
 791         }
 792
 793         if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) {
 794                 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
 795                 snd_hda_codec_free(codec);
 796                 return -ENOMEM;
 797         }
 798
 799         if (!codec->subsystem_id) {
 800                 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
 801                 codec->subsystem_id =
 802                         snd_hda_codec_read(codec, nid, 0,
 803                                            AC_VERB_GET_SUBSYSTEM_ID, 0);
 804         }
 805         if (bus->modelname)
 806                 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
 807
 808         if (do_init) {
 809                 err = snd_hda_codec_configure(codec);
 810                 if (err < 0) {
 811                         snd_hda_codec_free(codec);
 812                         return err;
 813                 }
 814         }
 815         snd_hda_codec_proc_new(codec);
 816
 817         snd_hda_create_hwdep(codec);
 818
 819         sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
 820                 codec->subsystem_id, codec->revision_id);
 821         snd_component_add(codec->bus->card, component);
 822
 823         if (codecp)
 824                 *codecp = codec;
 825         return 0;
 826 }
 827 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
 828
 829 int snd_hda_codec_configure(struct hda_codec *codec)
 830 {
 831         int err;
 832
 833         codec->preset = find_codec_preset(codec);
 834         if (!codec->name) {
 835                 err = get_codec_name(codec);
 836                 if (err < 0)
 837                         return err;
 838         }
 839         /* audio codec should override the mixer name */
 840         if (codec->afg || !*codec->bus->card->mixername)
 841                 strlcpy(codec->bus->card->mixername, codec->name,
 842                         sizeof(codec->bus->card->mixername));
 843
 844         if (is_generic_config(codec)) {
 845                 err = snd_hda_parse_generic_codec(codec);
 846                 goto patched;
 847         }
 848         if (codec->preset && codec->preset->patch) {
 849                 err = codec->preset->patch(codec);
 850                 goto patched;
 851         }
 852
 853         /* call the default parser */
 854         err = snd_hda_parse_generic_codec(codec);
 855         if (err < 0)
 856                 printk(KERN_ERR "hda-codec: No codec parser is available\n");
 857
 858  patched:
 859         if (!err && codec->patch_ops.unsol_event)
 860                 err = init_unsol_queue(codec->bus);
 861         return err;
 862 }
 863
 864 /**
 865  * snd_hda_codec_setup_stream - set up the codec for streaming
 866  * @codec: the CODEC to set up
 867  * @nid: the NID to set up
 868  * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
 869  * @channel_id: channel id to pass, zero based.
 870  * @format: stream format.
 871  */
 872 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
 873                                 u32 stream_tag,
 874                                 int channel_id, int format)
 875 {
 876         if (!nid)
 877                 return;
 878
 879         snd_printdd("hda_codec_setup_stream: "
 880                     "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
 881                     nid, stream_tag, channel_id, format);
 882         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
 883                             (stream_tag << 4) | channel_id);
 884         msleep(1);
 885         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
 886 }
 887 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
 888
 889 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
 890 {
 891         if (!nid)
 892                 return;
 893
 894         snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
 895         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
 896 #if 0 /* keep the format */
 897         msleep(1);
 898         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
 899 #endif
 900 }
 901 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
 902
 903 /*
 904  * amp access functions
 905  */
 906
 907 /* FIXME: more better hash key? */
 908 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
 909 #define INFO_AMP_CAPS   (1<<0)
 910 #define INFO_AMP_VOL(ch)        (1 << (1 + (ch)))
 911
 912 /* initialize the hash table */
 913 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
 914                                      unsigned int record_size)
 915 {
 916         memset(cache, 0, sizeof(*cache));
 917         memset(cache->hash, 0xff, sizeof(cache->hash));
 918         snd_array_init(&cache->buf, record_size, 64);
 919 }
 920
 921 static void free_hda_cache(struct hda_cache_rec *cache)
 922 {
 923         snd_array_free(&cache->buf);
 924 }
 925
 926 /* query the hash.  allocate an entry if not found. */
 927 static struct hda_cache_head  *get_alloc_hash(struct hda_cache_rec *cache,
 928                                               u32 key)
 929 {
 930         u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
 931         u16 cur = cache->hash[idx];
 932         struct hda_cache_head *info;
 933
 934         while (cur != 0xffff) {
 935                 info = snd_array_elem(&cache->buf, cur);
 936                 if (info->key == key)
 937                         return info;
 938                 cur = info->next;
 939         }
 940
 941         /* add a new hash entry */
 942         info = snd_array_new(&cache->buf);
 943         if (!info)
 944                 return NULL;
 945         cur = snd_array_index(&cache->buf, info);
 946         info->key = key;
 947         info->val = 0;
 948         info->next = cache->hash[idx];
 949         cache->hash[idx] = cur;
 950
 951         return info;
 952 }
 953
 954 /* query and allocate an amp hash entry */
 955 static inline struct hda_amp_info *
 956 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
 957 {
 958         return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
 959 }
 960
 961 /*
 962  * query AMP capabilities for the given widget and direction
 963  */
 964 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
 965 {
 966         struct hda_amp_info *info;
 967
 968         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
 969         if (!info)
 970                 return 0;
 971         if (!(info->head.val & INFO_AMP_CAPS)) {
 972                 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
 973                         nid = codec->afg;
 974                 info->amp_caps = snd_hda_param_read(codec, nid,
 975                                                     direction == HDA_OUTPUT ?
 976                                                     AC_PAR_AMP_OUT_CAP :
 977                                                     AC_PAR_AMP_IN_CAP);
 978                 if (info->amp_caps)
 979                         info->head.val |= INFO_AMP_CAPS;
 980         }
 981         return info->amp_caps;
 982 }
 983 EXPORT_SYMBOL_HDA(query_amp_caps);
 984
 985 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
 986                               unsigned int caps)
 987 {
 988         struct hda_amp_info *info;
 989
 990         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
 991         if (!info)
 992                 return -EINVAL;
 993         info->amp_caps = caps;
 994         info->head.val |= INFO_AMP_CAPS;
 995         return 0;
 996 }
 997 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
 998
 999 /*
1000  * read the current volume to info
1001  * if the cache exists, read the cache value.
1002  */
1003 static unsigned int get_vol_mute(struct hda_codec *codec,
1004                                  struct hda_amp_info *info, hda_nid_t nid,
1005                                  int ch, int direction, int index)
1006 {
1007         u32 val, parm;
1008
1009         if (info->head.val & INFO_AMP_VOL(ch))
1010                 return info->vol[ch];
1011
1012         parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1013         parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1014         parm |= index;
1015         val = snd_hda_codec_read(codec, nid, 0,
1016                                  AC_VERB_GET_AMP_GAIN_MUTE, parm);
1017         info->vol[ch] = val & 0xff;
1018         info->head.val |= INFO_AMP_VOL(ch);
1019         return info->vol[ch];
1020 }
1021
1022 /*
1023  * write the current volume in info to the h/w and update the cache
1024  */
1025 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1026                          hda_nid_t nid, int ch, int direction, int index,
1027                          int val)
1028 {
1029         u32 parm;
1030
1031         parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1032         parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1033         parm |= index << AC_AMP_SET_INDEX_SHIFT;
1034         parm |= val;
1035         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1036         info->vol[ch] = val;
1037 }
1038
1039 /*
1040  * read AMP value.  The volume is between 0 to 0x7f, 0x80 = mute bit.
1041  */
1042 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1043                            int direction, int index)
1044 {
1045         struct hda_amp_info *info;
1046         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1047         if (!info)
1048                 return 0;
1049         return get_vol_mute(codec, info, nid, ch, direction, index);
1050 }
1051 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1052
1053 /*
1054  * update the AMP value, mask = bit mask to set, val = the value
1055  */
1056 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1057                              int direction, int idx, int mask, int val)
1058 {
1059         struct hda_amp_info *info;
1060
1061         info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1062         if (!info)
1063                 return 0;
1064         val &= mask;
1065         val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1066         if (info->vol[ch] == val)
1067                 return 0;
1068         put_vol_mute(codec, info, nid, ch, direction, idx, val);
1069         return 1;
1070 }
1071 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1072
1073 /*
1074  * update the AMP stereo with the same mask and value
1075  */
1076 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1077                              int direction, int idx, int mask, int val)
1078 {
1079         int ch, ret = 0;
1080         for (ch = 0; ch < 2; ch++)
1081                 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1082                                                 idx, mask, val);
1083         return ret;
1084 }
1085 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1086
1087 #ifdef SND_HDA_NEEDS_RESUME
1088 /* resume the all amp commands from the cache */
1089 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1090 {
1091         struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1092         int i;
1093
1094         for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1095                 u32 key = buffer->head.key;
1096                 hda_nid_t nid;
1097                 unsigned int idx, dir, ch;
1098                 if (!key)
1099                         continue;
1100                 nid = key & 0xff;
1101                 idx = (key >> 16) & 0xff;
1102                 dir = (key >> 24) & 0xff;
1103                 for (ch = 0; ch < 2; ch++) {
1104                         if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1105                                 continue;
1106                         put_vol_mute(codec, buffer, nid, ch, dir, idx,
1107                                      buffer->vol[ch]);
1108                 }
1109         }
1110 }
1111 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1112 #endif /* SND_HDA_NEEDS_RESUME */
1113
1114 /* volume */
1115 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1116                                   struct snd_ctl_elem_info *uinfo)
1117 {
1118         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1119         u16 nid = get_amp_nid(kcontrol);
1120         u8 chs = get_amp_channels(kcontrol);
1121         int dir = get_amp_direction(kcontrol);
1122         u32 caps;
1123
1124         caps = query_amp_caps(codec, nid, dir);
1125         /* num steps */
1126         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1127         if (!caps) {
1128                 printk(KERN_WARNING "hda_codec: "
1129                        "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1130                        kcontrol->id.name);
1131                 return -EINVAL;
1132         }
1133         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1134         uinfo->count = chs == 3 ? 2 : 1;
1135         uinfo->value.integer.min = 0;
1136         uinfo->value.integer.max = caps;
1137         return 0;
1138 }
1139 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1140
1141 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1142                                  struct snd_ctl_elem_value *ucontrol)
1143 {
1144         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1145         hda_nid_t nid = get_amp_nid(kcontrol);
1146         int chs = get_amp_channels(kcontrol);
1147         int dir = get_amp_direction(kcontrol);
1148         int idx = get_amp_index(kcontrol);
1149         long *valp = ucontrol->value.integer.value;
1150
1151         if (chs & 1)
1152                 *valp++ = snd_hda_codec_amp_read(codec, nid, 0, dir, idx)
1153                         & HDA_AMP_VOLMASK;
1154         if (chs & 2)
1155                 *valp = snd_hda_codec_amp_read(codec, nid, 1, dir, idx)
1156                         & HDA_AMP_VOLMASK;
1157         return 0;
1158 }
1159 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1160
1161 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1162                                  struct snd_ctl_elem_value *ucontrol)
1163 {
1164         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1165         hda_nid_t nid = get_amp_nid(kcontrol);
1166         int chs = get_amp_channels(kcontrol);
1167         int dir = get_amp_direction(kcontrol);
1168         int idx = get_amp_index(kcontrol);
1169         long *valp = ucontrol->value.integer.value;
1170         int change = 0;
1171
1172         snd_hda_power_up(codec);
1173         if (chs & 1) {
1174                 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1175                                                   0x7f, *valp);
1176                 valp++;
1177         }
1178         if (chs & 2)
1179                 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1180                                                    0x7f, *valp);
1181         snd_hda_power_down(codec);
1182         return change;
1183 }
1184 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1185
1186 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1187                           unsigned int size, unsigned int __user *_tlv)
1188 {
1189         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1190         hda_nid_t nid = get_amp_nid(kcontrol);
1191         int dir = get_amp_direction(kcontrol);
1192         u32 caps, val1, val2;
1193
1194         if (size < 4 * sizeof(unsigned int))
1195                 return -ENOMEM;
1196         caps = query_amp_caps(codec, nid, dir);
1197         val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1198         val2 = (val2 + 1) * 25;
1199         val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1200         val1 = ((int)val1) * ((int)val2);
1201         if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1202                 return -EFAULT;
1203         if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1204                 return -EFAULT;
1205         if (put_user(val1, _tlv + 2))
1206                 return -EFAULT;
1207         if (put_user(val2, _tlv + 3))
1208                 return -EFAULT;
1209         return 0;
1210 }
1211 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1212
1213 /*
1214  * set (static) TLV for virtual master volume; recalculated as max 0dB
1215  */
1216 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1217                              unsigned int *tlv)
1218 {
1219         u32 caps;
1220         int nums, step;
1221
1222         caps = query_amp_caps(codec, nid, dir);
1223         nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1224         step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1225         step = (step + 1) * 25;
1226         tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1227         tlv[1] = 2 * sizeof(unsigned int);
1228         tlv[2] = -nums * step;
1229         tlv[3] = step;
1230 }
1231 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1232
1233 /* find a mixer control element with the given name */
1234 static struct snd_kcontrol *
1235 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1236                         const char *name, int idx)
1237 {
1238         struct snd_ctl_elem_id id;
1239         memset(&id, 0, sizeof(id));
1240         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1241         id.index = idx;
1242         strcpy(id.name, name);
1243         return snd_ctl_find_id(codec->bus->card, &id);
1244 }
1245
1246 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1247                                             const char *name)
1248 {
1249         return _snd_hda_find_mixer_ctl(codec, name, 0);
1250 }
1251 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1252
1253 /* Add a control element and assign to the codec */
1254 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1255 {
1256         int err;
1257         struct snd_kcontrol **knewp;
1258
1259         err = snd_ctl_add(codec->bus->card, kctl);
1260         if (err < 0)
1261                 return err;
1262         knewp = snd_array_new(&codec->mixers);
1263         if (!knewp)
1264                 return -ENOMEM;
1265         *knewp = kctl;
1266         return 0;
1267 }
1268 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1269
1270 #ifdef CONFIG_SND_HDA_RECONFIG
1271 /* Clear all controls assigned to the given codec */
1272 void snd_hda_ctls_clear(struct hda_codec *codec)
1273 {
1274         int i;
1275         struct snd_kcontrol **kctls = codec->mixers.list;
1276         for (i = 0; i < codec->mixers.used; i++)
1277                 snd_ctl_remove(codec->bus->card, kctls[i]);
1278         snd_array_free(&codec->mixers);
1279 }
1280
1281 void snd_hda_codec_reset(struct hda_codec *codec)
1282 {
1283         int i;
1284
1285 #ifdef CONFIG_SND_HDA_POWER_SAVE
1286         cancel_delayed_work(&codec->power_work);
1287         flush_workqueue(codec->bus->workq);
1288 #endif
1289         snd_hda_ctls_clear(codec);
1290         /* relase PCMs */
1291         for (i = 0; i < codec->num_pcms; i++) {
1292                 if (codec->pcm_info[i].pcm) {
1293                         snd_device_free(codec->bus->card,
1294                                         codec->pcm_info[i].pcm);
1295                         clear_bit(codec->pcm_info[i].device,
1296                                   codec->bus->pcm_dev_bits);
1297                 }
1298         }
1299         if (codec->patch_ops.free)
1300                 codec->patch_ops.free(codec);
1301         codec->proc_widget_hook = NULL;
1302         codec->spec = NULL;
1303         free_hda_cache(&codec->amp_cache);
1304         free_hda_cache(&codec->cmd_cache);
1305         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1306         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1307         codec->num_pcms = 0;
1308         codec->pcm_info = NULL;
1309         codec->preset = NULL;
1310         module_put(codec->owner);
1311         codec->owner = NULL;
1312 }
1313 #endif /* CONFIG_SND_HDA_RECONFIG */
1314
1315 /* create a virtual master control and add slaves */
1316 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1317                         unsigned int *tlv, const char **slaves)
1318 {
1319         struct snd_kcontrol *kctl;
1320         const char **s;
1321         int err;
1322
1323         for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1324                 ;
1325         if (!*s) {
1326                 snd_printdd("No slave found for %s\n", name);
1327                 return 0;
1328         }
1329         kctl = snd_ctl_make_virtual_master(name, tlv);
1330         if (!kctl)
1331                 return -ENOMEM;
1332         err = snd_hda_ctl_add(codec, kctl);
1333         if (err < 0)
1334                 return err;
1335
1336         for (s = slaves; *s; s++) {
1337                 struct snd_kcontrol *sctl;
1338
1339                 sctl = snd_hda_find_mixer_ctl(codec, *s);
1340                 if (!sctl) {
1341                         snd_printdd("Cannot find slave %s, skipped\n", *s);
1342                         continue;
1343                 }
1344                 err = snd_ctl_add_slave(kctl, sctl);
1345                 if (err < 0)
1346                         return err;
1347         }
1348         return 0;
1349 }
1350 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1351
1352 /* switch */
1353 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1354                                   struct snd_ctl_elem_info *uinfo)
1355 {
1356         int chs = get_amp_channels(kcontrol);
1357
1358         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1359         uinfo->count = chs == 3 ? 2 : 1;
1360         uinfo->value.integer.min = 0;
1361         uinfo->value.integer.max = 1;
1362         return 0;
1363 }
1364 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1365
1366 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1367                                  struct snd_ctl_elem_value *ucontrol)
1368 {
1369         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1370         hda_nid_t nid = get_amp_nid(kcontrol);
1371         int chs = get_amp_channels(kcontrol);
1372         int dir = get_amp_direction(kcontrol);
1373         int idx = get_amp_index(kcontrol);
1374         long *valp = ucontrol->value.integer.value;
1375
1376         if (chs & 1)
1377                 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1378                            HDA_AMP_MUTE) ? 0 : 1;
1379         if (chs & 2)
1380                 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1381                          HDA_AMP_MUTE) ? 0 : 1;
1382         return 0;
1383 }
1384 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1385
1386 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1387                                  struct snd_ctl_elem_value *ucontrol)
1388 {
1389         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1390         hda_nid_t nid = get_amp_nid(kcontrol);
1391         int chs = get_amp_channels(kcontrol);
1392         int dir = get_amp_direction(kcontrol);
1393         int idx = get_amp_index(kcontrol);
1394         long *valp = ucontrol->value.integer.value;
1395         int change = 0;
1396
1397         snd_hda_power_up(codec);
1398         if (chs & 1) {
1399                 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1400                                                   HDA_AMP_MUTE,
1401                                                   *valp ? 0 : HDA_AMP_MUTE);
1402                 valp++;
1403         }
1404         if (chs & 2)
1405                 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1406                                                    HDA_AMP_MUTE,
1407                                                    *valp ? 0 : HDA_AMP_MUTE);
1408 #ifdef CONFIG_SND_HDA_POWER_SAVE
1409         if (codec->patch_ops.check_power_status)
1410                 codec->patch_ops.check_power_status(codec, nid);
1411 #endif
1412         snd_hda_power_down(codec);
1413         return change;
1414 }
1415 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1416
1417 /*
1418  * bound volume controls
1419  *
1420  * bind multiple volumes (# indices, from 0)
1421  */
1422
1423 #define AMP_VAL_IDX_SHIFT       19
1424 #define AMP_VAL_IDX_MASK        (0x0f<<19)
1425
1426 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1427                                   struct snd_ctl_elem_value *ucontrol)
1428 {
1429         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1430         unsigned long pval;
1431         int err;
1432
1433         mutex_lock(&codec->control_mutex);
1434         pval = kcontrol->private_value;
1435         kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1436         err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1437         kcontrol->private_value = pval;
1438         mutex_unlock(&codec->control_mutex);
1439         return err;
1440 }
1441 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1442
1443 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1444                                   struct snd_ctl_elem_value *ucontrol)
1445 {
1446         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1447         unsigned long pval;
1448         int i, indices, err = 0, change = 0;
1449
1450         mutex_lock(&codec->control_mutex);
1451         pval = kcontrol->private_value;
1452         indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1453         for (i = 0; i < indices; i++) {
1454                 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1455                         (i << AMP_VAL_IDX_SHIFT);
1456                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1457                 if (err < 0)
1458                         break;
1459                 change |= err;
1460         }
1461         kcontrol->private_value = pval;
1462         mutex_unlock(&codec->control_mutex);
1463         return err < 0 ? err : change;
1464 }
1465 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1466
1467 /*
1468  * generic bound volume/swtich controls
1469  */
1470 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1471                                  struct snd_ctl_elem_info *uinfo)
1472 {
1473         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1474         struct hda_bind_ctls *c;
1475         int err;
1476
1477         mutex_lock(&codec->control_mutex);
1478         c = (struct hda_bind_ctls *)kcontrol->private_value;
1479         kcontrol->private_value = *c->values;
1480         err = c->ops->info(kcontrol, uinfo);
1481         kcontrol->private_value = (long)c;
1482         mutex_unlock(&codec->control_mutex);
1483         return err;
1484 }
1485 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1486
1487 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1488                                 struct snd_ctl_elem_value *ucontrol)
1489 {
1490         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1491         struct hda_bind_ctls *c;
1492         int err;
1493
1494         mutex_lock(&codec->control_mutex);
1495         c = (struct hda_bind_ctls *)kcontrol->private_value;
1496         kcontrol->private_value = *c->values;
1497         err = c->ops->get(kcontrol, ucontrol);
1498         kcontrol->private_value = (long)c;
1499         mutex_unlock(&codec->control_mutex);
1500         return err;
1501 }
1502 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1503
1504 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1505                                 struct snd_ctl_elem_value *ucontrol)
1506 {
1507         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1508         struct hda_bind_ctls *c;
1509         unsigned long *vals;
1510         int err = 0, change = 0;
1511
1512         mutex_lock(&codec->control_mutex);
1513         c = (struct hda_bind_ctls *)kcontrol->private_value;
1514         for (vals = c->values; *vals; vals++) {
1515                 kcontrol->private_value = *vals;
1516                 err = c->ops->put(kcontrol, ucontrol);
1517                 if (err < 0)
1518                         break;
1519                 change |= err;
1520         }
1521         kcontrol->private_value = (long)c;
1522         mutex_unlock(&codec->control_mutex);
1523         return err < 0 ? err : change;
1524 }
1525 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1526
1527 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1528                            unsigned int size, unsigned int __user *tlv)
1529 {
1530         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1531         struct hda_bind_ctls *c;
1532         int err;
1533
1534         mutex_lock(&codec->control_mutex);
1535         c = (struct hda_bind_ctls *)kcontrol->private_value;
1536         kcontrol->private_value = *c->values;
1537         err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1538         kcontrol->private_value = (long)c;
1539         mutex_unlock(&codec->control_mutex);
1540         return err;
1541 }
1542 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1543
1544 struct hda_ctl_ops snd_hda_bind_vol = {
1545         .info = snd_hda_mixer_amp_volume_info,
1546         .get = snd_hda_mixer_amp_volume_get,
1547         .put = snd_hda_mixer_amp_volume_put,
1548         .tlv = snd_hda_mixer_amp_tlv
1549 };
1550 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1551
1552 struct hda_ctl_ops snd_hda_bind_sw = {
1553         .info = snd_hda_mixer_amp_switch_info,
1554         .get = snd_hda_mixer_amp_switch_get,
1555         .put = snd_hda_mixer_amp_switch_put,
1556         .tlv = snd_hda_mixer_amp_tlv
1557 };
1558 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1559
1560 /*
1561  * SPDIF out controls
1562  */
1563
1564 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1565                                    struct snd_ctl_elem_info *uinfo)
1566 {
1567         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1568         uinfo->count = 1;
1569         return 0;
1570 }
1571
1572 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1573                                    struct snd_ctl_elem_value *ucontrol)
1574 {
1575         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1576                                            IEC958_AES0_NONAUDIO |
1577                                            IEC958_AES0_CON_EMPHASIS_5015 |
1578                                            IEC958_AES0_CON_NOT_COPYRIGHT;
1579         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1580                                            IEC958_AES1_CON_ORIGINAL;
1581         return 0;
1582 }
1583
1584 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1585                                    struct snd_ctl_elem_value *ucontrol)
1586 {
1587         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1588                                            IEC958_AES0_NONAUDIO |
1589                                            IEC958_AES0_PRO_EMPHASIS_5015;
1590         return 0;
1591 }
1592
1593 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1594                                      struct snd_ctl_elem_value *ucontrol)
1595 {
1596         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1597
1598         ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1599         ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1600         ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1601         ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1602
1603         return 0;
1604 }
1605
1606 /* convert from SPDIF status bits to HDA SPDIF bits
1607  * bit 0 (DigEn) is always set zero (to be filled later)
1608  */
1609 static unsigned short convert_from_spdif_status(unsigned int sbits)
1610 {
1611         unsigned short val = 0;
1612
1613         if (sbits & IEC958_AES0_PROFESSIONAL)
1614                 val |= AC_DIG1_PROFESSIONAL;
1615         if (sbits & IEC958_AES0_NONAUDIO)
1616                 val |= AC_DIG1_NONAUDIO;
1617         if (sbits & IEC958_AES0_PROFESSIONAL) {
1618                 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1619                     IEC958_AES0_PRO_EMPHASIS_5015)
1620                         val |= AC_DIG1_EMPHASIS;
1621         } else {
1622                 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1623                     IEC958_AES0_CON_EMPHASIS_5015)
1624                         val |= AC_DIG1_EMPHASIS;
1625                 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1626                         val |= AC_DIG1_COPYRIGHT;
1627                 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1628                         val |= AC_DIG1_LEVEL;
1629                 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1630         }
1631         return val;
1632 }
1633
1634 /* convert to SPDIF status bits from HDA SPDIF bits
1635  */
1636 static unsigned int convert_to_spdif_status(unsigned short val)
1637 {
1638         unsigned int sbits = 0;
1639
1640         if (val & AC_DIG1_NONAUDIO)
1641                 sbits |= IEC958_AES0_NONAUDIO;
1642         if (val & AC_DIG1_PROFESSIONAL)
1643                 sbits |= IEC958_AES0_PROFESSIONAL;
1644         if (sbits & IEC958_AES0_PROFESSIONAL) {
1645                 if (sbits & AC_DIG1_EMPHASIS)
1646                         sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1647         } else {
1648                 if (val & AC_DIG1_EMPHASIS)
1649                         sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1650                 if (!(val & AC_DIG1_COPYRIGHT))
1651                         sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1652                 if (val & AC_DIG1_LEVEL)
1653                         sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1654                 sbits |= val & (0x7f << 8);
1655         }
1656         return sbits;
1657 }
1658
1659 /* set digital convert verbs both for the given NID and its slaves */
1660 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1661                         int verb, int val)
1662 {
1663         hda_nid_t *d;
1664
1665         snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1666         d = codec->slave_dig_outs;
1667         if (!d)
1668                 return;
1669         for (; *d; d++)
1670                 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1671 }
1672
1673 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1674                                        int dig1, int dig2)
1675 {
1676         if (dig1 != -1)
1677                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1678         if (dig2 != -1)
1679                 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1680 }
1681
1682 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1683                                      struct snd_ctl_elem_value *ucontrol)
1684 {
1685         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1686         hda_nid_t nid = kcontrol->private_value;
1687         unsigned short val;
1688         int change;
1689
1690         mutex_lock(&codec->spdif_mutex);
1691         codec->spdif_status = ucontrol->value.iec958.status[0] |
1692                 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1693                 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1694                 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1695         val = convert_from_spdif_status(codec->spdif_status);
1696         val |= codec->spdif_ctls & 1;
1697         change = codec->spdif_ctls != val;
1698         codec->spdif_ctls = val;
1699
1700         if (change)
1701                 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1702
1703         mutex_unlock(&codec->spdif_mutex);
1704         return change;
1705 }
1706
1707 #define snd_hda_spdif_out_switch_info   snd_ctl_boolean_mono_info
1708
1709 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1710                                         struct snd_ctl_elem_value *ucontrol)
1711 {
1712         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1713
1714         ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1715         return 0;
1716 }
1717
1718 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1719                                         struct snd_ctl_elem_value *ucontrol)
1720 {
1721         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1722         hda_nid_t nid = kcontrol->private_value;
1723         unsigned short val;
1724         int change;
1725
1726         mutex_lock(&codec->spdif_mutex);
1727         val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1728         if (ucontrol->value.integer.value[0])
1729                 val |= AC_DIG1_ENABLE;
1730         change = codec->spdif_ctls != val;
1731         if (change) {
1732                 codec->spdif_ctls = val;
1733                 set_dig_out_convert(codec, nid, val & 0xff, -1);
1734                 /* unmute amp switch (if any) */
1735                 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1736                     (val & AC_DIG1_ENABLE))
1737                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1738                                                  HDA_AMP_MUTE, 0);
1739         }
1740         mutex_unlock(&codec->spdif_mutex);
1741         return change;
1742 }
1743
1744 static struct snd_kcontrol_new dig_mixes[] = {
1745         {
1746                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1747                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1748                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1749                 .info = snd_hda_spdif_mask_info,
1750                 .get = snd_hda_spdif_cmask_get,
1751         },
1752         {
1753                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1754                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1755                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1756                 .info = snd_hda_spdif_mask_info,
1757                 .get = snd_hda_spdif_pmask_get,
1758         },
1759         {
1760                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1761                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1762                 .info = snd_hda_spdif_mask_info,
1763                 .get = snd_hda_spdif_default_get,
1764                 .put = snd_hda_spdif_default_put,
1765         },
1766         {
1767                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1768                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1769                 .info = snd_hda_spdif_out_switch_info,
1770                 .get = snd_hda_spdif_out_switch_get,
1771                 .put = snd_hda_spdif_out_switch_put,
1772         },
1773         { } /* end */
1774 };
1775
1776 #define SPDIF_MAX_IDX   4       /* 4 instances should be enough to probe */
1777
1778 /**
1779  * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1780  * @codec: the HDA codec
1781  * @nid: audio out widget NID
1782  *
1783  * Creates controls related with the SPDIF output.
1784  * Called from each patch supporting the SPDIF out.
1785  *
1786  * Returns 0 if successful, or a negative error code.
1787  */
1788 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1789 {
1790         int err;
1791         struct snd_kcontrol *kctl;
1792         struct snd_kcontrol_new *dig_mix;
1793         int idx;
1794
1795         for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1796                 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1797                                              idx))
1798                         break;
1799         }
1800         if (idx >= SPDIF_MAX_IDX) {
1801                 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1802                 return -EBUSY;
1803         }
1804         for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1805                 kctl = snd_ctl_new1(dig_mix, codec);
1806                 if (!kctl)
1807                         return -ENOMEM;
1808                 kctl->id.index = idx;
1809                 kctl->private_value = nid;
1810                 err = snd_hda_ctl_add(codec, kctl);
1811                 if (err < 0)
1812                         return err;
1813         }
1814         codec->spdif_ctls =
1815                 snd_hda_codec_read(codec, nid, 0,
1816                                    AC_VERB_GET_DIGI_CONVERT_1, 0);
1817         codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1818         return 0;
1819 }
1820 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1821
1822 /*
1823  * SPDIF sharing with analog output
1824  */
1825 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1826                               struct snd_ctl_elem_value *ucontrol)
1827 {
1828         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1829         ucontrol->value.integer.value[0] = mout->share_spdif;
1830         return 0;
1831 }
1832
1833 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1834                               struct snd_ctl_elem_value *ucontrol)
1835 {
1836         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1837         mout->share_spdif = !!ucontrol->value.integer.value[0];
1838         return 0;
1839 }
1840
1841 static struct snd_kcontrol_new spdif_share_sw = {
1842         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1843         .name = "IEC958 Default PCM Playback Switch",
1844         .info = snd_ctl_boolean_mono_info,
1845         .get = spdif_share_sw_get,
1846         .put = spdif_share_sw_put,
1847 };
1848
1849 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
1850                                   struct hda_multi_out *mout)
1851 {
1852         if (!mout->dig_out_nid)
1853                 return 0;
1854         /* ATTENTION: here mout is passed as private_data, instead of codec */
1855         return snd_hda_ctl_add(codec,
1856                            snd_ctl_new1(&spdif_share_sw, mout));
1857 }
1858 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
1859
1860 /*
1861  * SPDIF input
1862  */
1863
1864 #define snd_hda_spdif_in_switch_info    snd_hda_spdif_out_switch_info
1865
1866 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
1867                                        struct snd_ctl_elem_value *ucontrol)
1868 {
1869         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1870
1871         ucontrol->value.integer.value[0] = codec->spdif_in_enable;
1872         return 0;
1873 }
1874
1875 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
1876                                        struct snd_ctl_elem_value *ucontrol)
1877 {
1878         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1879         hda_nid_t nid = kcontrol->private_value;
1880         unsigned int val = !!ucontrol->value.integer.value[0];
1881         int change;
1882
1883         mutex_lock(&codec->spdif_mutex);
1884         change = codec->spdif_in_enable != val;
1885         if (change) {
1886                 codec->spdif_in_enable = val;
1887                 snd_hda_codec_write_cache(codec, nid, 0,
1888                                           AC_VERB_SET_DIGI_CONVERT_1, val);
1889         }
1890         mutex_unlock(&codec->spdif_mutex);
1891         return change;
1892 }
1893
1894 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
1895                                        struct snd_ctl_elem_value *ucontrol)
1896 {
1897         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1898         hda_nid_t nid = kcontrol->private_value;
1899         unsigned short val;
1900         unsigned int sbits;
1901
1902         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1903         sbits = convert_to_spdif_status(val);
1904         ucontrol->value.iec958.status[0] = sbits;
1905         ucontrol->value.iec958.status[1] = sbits >> 8;
1906         ucontrol->value.iec958.status[2] = sbits >> 16;
1907         ucontrol->value.iec958.status[3] = sbits >> 24;
1908         return 0;
1909 }
1910
1911 static struct snd_kcontrol_new dig_in_ctls[] = {
1912         {
1913                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1914                 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
1915                 .info = snd_hda_spdif_in_switch_info,
1916                 .get = snd_hda_spdif_in_switch_get,
1917                 .put = snd_hda_spdif_in_switch_put,
1918         },
1919         {
1920                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1921                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1922                 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1923                 .info = snd_hda_spdif_mask_info,
1924                 .get = snd_hda_spdif_in_status_get,
1925         },
1926         { } /* end */
1927 };
1928
1929 /**
1930  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1931  * @codec: the HDA codec
1932  * @nid: audio in widget NID
1933  *
1934  * Creates controls related with the SPDIF input.
1935  * Called from each patch supporting the SPDIF in.
1936  *
1937  * Returns 0 if successful, or a negative error code.
1938  */
1939 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1940 {
1941         int err;
1942         struct snd_kcontrol *kctl;
1943         struct snd_kcontrol_new *dig_mix;
1944         int idx;
1945
1946         for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1947                 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
1948                                              idx))
1949                         break;
1950         }
1951         if (idx >= SPDIF_MAX_IDX) {
1952                 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
1953                 return -EBUSY;
1954         }
1955         for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
1956                 kctl = snd_ctl_new1(dig_mix, codec);
1957                 kctl->private_value = nid;
1958                 err = snd_hda_ctl_add(codec, kctl);
1959                 if (err < 0)
1960                         return err;
1961         }
1962         codec->spdif_in_enable =
1963                 snd_hda_codec_read(codec, nid, 0,
1964                                    AC_VERB_GET_DIGI_CONVERT_1, 0) &
1965                 AC_DIG1_ENABLE;
1966         return 0;
1967 }
1968 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
1969
1970 #ifdef SND_HDA_NEEDS_RESUME
1971 /*
1972  * command cache
1973  */
1974
1975 /* build a 32bit cache key with the widget id and the command parameter */
1976 #define build_cmd_cache_key(nid, verb)  ((verb << 8) | nid)
1977 #define get_cmd_cache_nid(key)          ((key) & 0xff)
1978 #define get_cmd_cache_cmd(key)          (((key) >> 8) & 0xffff)
1979
1980 /**
1981  * snd_hda_codec_write_cache - send a single command with caching
1982  * @codec: the HDA codec
1983  * @nid: NID to send the command
1984  * @direct: direct flag
1985  * @verb: the verb to send
1986  * @parm: the parameter for the verb
1987  *
1988  * Send a single command without waiting for response.
1989  *
1990  * Returns 0 if successful, or a negative error code.
1991  */
1992 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
1993                               int direct, unsigned int verb, unsigned int parm)
1994 {
1995         struct hda_bus *bus = codec->bus;
1996         unsigned int res;
1997         int err;
1998
1999         res = make_codec_cmd(codec, nid, direct, verb, parm);
2000         snd_hda_power_up(codec);
2001         mutex_lock(&bus->cmd_mutex);
2002         err = bus->ops.command(bus, res);
2003         if (!err) {
2004                 struct hda_cache_head *c;
2005                 u32 key = build_cmd_cache_key(nid, verb);
2006                 c = get_alloc_hash(&codec->cmd_cache, key);
2007                 if (c)
2008                         c->val = parm;
2009         }
2010         mutex_unlock(&bus->cmd_mutex);
2011         snd_hda_power_down(codec);
2012         return err;
2013 }
2014 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2015
2016 /* resume the all commands from the cache */
2017 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2018 {
2019         struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2020         int i;
2021
2022         for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2023                 u32 key = buffer->key;
2024                 if (!key)
2025                         continue;
2026                 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2027                                     get_cmd_cache_cmd(key), buffer->val);
2028         }
2029 }
2030 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2031
2032 /**
2033  * snd_hda_sequence_write_cache - sequence writes with caching
2034  * @codec: the HDA codec
2035  * @seq: VERB array to send
2036  *
2037  * Send the commands sequentially from the given array.
2038  * Thte commands are recorded on cache for power-save and resume.
2039  * The array must be terminated with NID=0.
2040  */
2041 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2042                                   const struct hda_verb *seq)
2043 {
2044         for (; seq->nid; seq++)
2045                 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2046                                           seq->param);
2047 }
2048 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2049 #endif /* SND_HDA_NEEDS_RESUME */
2050
2051 /*
2052  * set power state of the codec
2053  */
2054 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2055                                 unsigned int power_state)
2056 {
2057         hda_nid_t nid;
2058         int i;
2059
2060         snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2061                             power_state);
2062         msleep(10); /* partial workaround for "azx_get_response timeout" */
2063
2064         nid = codec->start_nid;
2065         for (i = 0; i < codec->num_nodes; i++, nid++) {
2066                 unsigned int wcaps = get_wcaps(codec, nid);
2067                 if (wcaps & AC_WCAP_POWER) {
2068                         unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2069                                 AC_WCAP_TYPE_SHIFT;
2070                         if (wid_type == AC_WID_PIN) {
2071                                 unsigned int pincap;
2072                                 /*
2073                                  * don't power down the widget if it controls
2074                                  * eapd and EAPD_BTLENABLE is set.
2075                                  */
2076                                 pincap = snd_hda_param_read(codec, nid,
2077                                                             AC_PAR_PIN_CAP);
2078                                 if (pincap & AC_PINCAP_EAPD) {
2079                                         int eapd = snd_hda_codec_read(codec,
2080                                                 nid, 0,
2081                                                 AC_VERB_GET_EAPD_BTLENABLE, 0);
2082                                         eapd &= 0x02;
2083                                         if (power_state == AC_PWRST_D3 && eapd)
2084                                                 continue;
2085                                 }
2086                         }
2087                         snd_hda_codec_write(codec, nid, 0,
2088                                             AC_VERB_SET_POWER_STATE,
2089                                             power_state);
2090                 }
2091         }
2092
2093         if (power_state == AC_PWRST_D0) {
2094                 unsigned long end_time;
2095                 int state;
2096                 msleep(10);
2097                 /* wait until the codec reachs to D0 */
2098                 end_time = jiffies + msecs_to_jiffies(500);
2099                 do {
2100                         state = snd_hda_codec_read(codec, fg, 0,
2101                                                    AC_VERB_GET_POWER_STATE, 0);
2102                         if (state == power_state)
2103                                 break;
2104                         msleep(1);
2105                 } while (time_after_eq(end_time, jiffies));
2106         }
2107 }
2108
2109 #ifdef CONFIG_SND_HDA_HWDEP
2110 /* execute additional init verbs */
2111 static void hda_exec_init_verbs(struct hda_codec *codec)
2112 {
2113         if (codec->init_verbs.list)
2114                 snd_hda_sequence_write(codec, codec->init_verbs.list);
2115 }
2116 #else
2117 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2118 #endif
2119
2120 #ifdef SND_HDA_NEEDS_RESUME
2121 /*
2122  * call suspend and power-down; used both from PM and power-save
2123  */
2124 static void hda_call_codec_suspend(struct hda_codec *codec)
2125 {
2126         if (codec->patch_ops.suspend)
2127                 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2128         hda_set_power_state(codec,
2129                             codec->afg ? codec->afg : codec->mfg,
2130                             AC_PWRST_D3);
2131 #ifdef CONFIG_SND_HDA_POWER_SAVE
2132         cancel_delayed_work(&codec->power_work);
2133         codec->power_on = 0;
2134         codec->power_transition = 0;
2135 #endif
2136 }
2137
2138 /*
2139  * kick up codec; used both from PM and power-save
2140  */
2141 static void hda_call_codec_resume(struct hda_codec *codec)
2142 {
2143         hda_set_power_state(codec,
2144                             codec->afg ? codec->afg : codec->mfg,
2145                             AC_PWRST_D0);
2146         hda_exec_init_verbs(codec);
2147         if (codec->patch_ops.resume)
2148                 codec->patch_ops.resume(codec);
2149         else {
2150                 if (codec->patch_ops.init)
2151                         codec->patch_ops.init(codec);
2152                 snd_hda_codec_resume_amp(codec);
2153                 snd_hda_codec_resume_cache(codec);
2154         }
2155 }
2156 #endif /* SND_HDA_NEEDS_RESUME */
2157
2158
2159 /**
2160  * snd_hda_build_controls - build mixer controls
2161  * @bus: the BUS
2162  *
2163  * Creates mixer controls for each codec included in the bus.
2164  *
2165  * Returns 0 if successful, otherwise a negative error code.
2166  */
2167 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2168 {
2169         struct hda_codec *codec;
2170
2171         list_for_each_entry(codec, &bus->codec_list, list) {
2172                 int err = snd_hda_codec_build_controls(codec);
2173                 if (err < 0)
2174                         return err;
2175         }
2176         return 0;
2177 }
2178 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2179
2180 int snd_hda_codec_build_controls(struct hda_codec *codec)
2181 {
2182         int err = 0;
2183         /* fake as if already powered-on */
2184         hda_keep_power_on(codec);
2185         /* then fire up */
2186         hda_set_power_state(codec,
2187                             codec->afg ? codec->afg : codec->mfg,
2188                             AC_PWRST_D0);
2189         hda_exec_init_verbs(codec);
2190         /* continue to initialize... */
2191         if (codec->patch_ops.init)
2192                 err = codec->patch_ops.init(codec);
2193         if (!err && codec->patch_ops.build_controls)
2194                 err = codec->patch_ops.build_controls(codec);
2195         snd_hda_power_down(codec);
2196         if (err < 0)
2197                 return err;
2198         return 0;
2199 }
2200
2201 /*
2202  * stream formats
2203  */
2204 struct hda_rate_tbl {
2205         unsigned int hz;
2206         unsigned int alsa_bits;
2207         unsigned int hda_fmt;
2208 };
2209
2210 static struct hda_rate_tbl rate_bits[] = {
2211         /* rate in Hz, ALSA rate bitmask, HDA format value */
2212
2213         /* autodetected value used in snd_hda_query_supported_pcm */
2214         { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2215         { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2216         { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2217         { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2218         { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2219         { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2220         { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2221         { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2222         { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2223         { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2224         { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2225 #define AC_PAR_PCM_RATE_BITS    11
2226         /* up to bits 10, 384kHZ isn't supported properly */
2227
2228         /* not autodetected value */
2229         { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2230
2231         { 0 } /* terminator */
2232 };
2233
2234 /**
2235  * snd_hda_calc_stream_format - calculate format bitset
2236  * @rate: the sample rate
2237  * @channels: the number of channels
2238  * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2239  * @maxbps: the max. bps
2240  *
2241  * Calculate the format bitset from the given rate, channels and th PCM format.
2242  *
2243  * Return zero if invalid.
2244  */
2245 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2246                                         unsigned int channels,
2247                                         unsigned int format,
2248                                         unsigned int maxbps)
2249 {
2250         int i;
2251         unsigned int val = 0;
2252
2253         for (i = 0; rate_bits[i].hz; i++)
2254                 if (rate_bits[i].hz == rate) {
2255                         val = rate_bits[i].hda_fmt;
2256                         break;
2257                 }
2258         if (!rate_bits[i].hz) {
2259                 snd_printdd("invalid rate %d\n", rate);
2260                 return 0;
2261         }
2262
2263         if (channels == 0 || channels > 8) {
2264                 snd_printdd("invalid channels %d\n", channels);
2265                 return 0;
2266         }
2267         val |= channels - 1;
2268
2269         switch (snd_pcm_format_width(format)) {
2270         case 8:  val |= 0x00; break;
2271         case 16: val |= 0x10; break;
2272         case 20:
2273         case 24:
2274         case 32:
2275                 if (maxbps >= 32)
2276                         val |= 0x40;
2277                 else if (maxbps >= 24)
2278                         val |= 0x30;
2279                 else
2280                         val |= 0x20;
2281                 break;
2282         default:
2283                 snd_printdd("invalid format width %d\n",
2284                             snd_pcm_format_width(format));
2285                 return 0;
2286         }
2287
2288         return val;
2289 }
2290 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2291
2292 /**
2293  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2294  * @codec: the HDA codec
2295  * @nid: NID to query
2296  * @ratesp: the pointer to store the detected rate bitflags
2297  * @formatsp: the pointer to store the detected formats
2298  * @bpsp: the pointer to store the detected format widths
2299  *
2300  * Queries the supported PCM rates and formats.  The NULL @ratesp, @formatsp
2301  * or @bsps argument is ignored.
2302  *
2303  * Returns 0 if successful, otherwise a negative error code.
2304  */
2305 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2306                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2307 {
2308         int i;
2309         unsigned int val, streams;
2310
2311         val = 0;
2312         if (nid != codec->afg &&
2313             (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2314                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2315                 if (val == -1)
2316                         return -EIO;
2317         }
2318         if (!val)
2319                 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2320
2321         if (ratesp) {
2322                 u32 rates = 0;
2323                 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2324                         if (val & (1 << i))
2325                                 rates |= rate_bits[i].alsa_bits;
2326                 }
2327                 *ratesp = rates;
2328         }
2329
2330         if (formatsp || bpsp) {
2331                 u64 formats = 0;
2332                 unsigned int bps;
2333                 unsigned int wcaps;
2334
2335                 wcaps = get_wcaps(codec, nid);
2336                 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2337                 if (streams == -1)
2338                         return -EIO;
2339                 if (!streams) {
2340                         streams = snd_hda_param_read(codec, codec->afg,
2341                                                      AC_PAR_STREAM);
2342                         if (streams == -1)
2343                                 return -EIO;
2344                 }
2345
2346                 bps = 0;
2347                 if (streams & AC_SUPFMT_PCM) {
2348                         if (val & AC_SUPPCM_BITS_8) {
2349                                 formats |= SNDRV_PCM_FMTBIT_U8;
2350                                 bps = 8;
2351                         }
2352                         if (val & AC_SUPPCM_BITS_16) {
2353                                 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2354                                 bps = 16;
2355                         }
2356                         if (wcaps & AC_WCAP_DIGITAL) {
2357                                 if (val & AC_SUPPCM_BITS_32)
2358                                         formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2359                                 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2360                                         formats |= SNDRV_PCM_FMTBIT_S32_LE;
2361                                 if (val & AC_SUPPCM_BITS_24)
2362                                         bps = 24;
2363                                 else if (val & AC_SUPPCM_BITS_20)
2364                                         bps = 20;
2365                         } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2366                                           AC_SUPPCM_BITS_32)) {
2367                                 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2368                                 if (val & AC_SUPPCM_BITS_32)
2369                                         bps = 32;
2370                                 else if (val & AC_SUPPCM_BITS_24)
2371                                         bps = 24;
2372                                 else if (val & AC_SUPPCM_BITS_20)
2373                                         bps = 20;
2374                         }
2375                 }
2376                 else if (streams == AC_SUPFMT_FLOAT32) {
2377                         /* should be exclusive */
2378                         formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2379                         bps = 32;
2380                 } else if (streams == AC_SUPFMT_AC3) {
2381                         /* should be exclusive */
2382                         /* temporary hack: we have still no proper support
2383                          * for the direct AC3 stream...
2384                          */
2385                         formats |= SNDRV_PCM_FMTBIT_U8;
2386                         bps = 8;
2387                 }
2388                 if (formatsp)
2389                         *formatsp = formats;
2390                 if (bpsp)
2391                         *bpsp = bps;
2392         }
2393
2394         return 0;
2395 }
2396
2397 /**
2398  * snd_hda_is_supported_format - check whether the given node supports
2399  * the format val
2400  *
2401  * Returns 1 if supported, 0 if not.
2402  */
2403 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2404                                 unsigned int format)
2405 {
2406         int i;
2407         unsigned int val = 0, rate, stream;
2408
2409         if (nid != codec->afg &&
2410             (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2411                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2412                 if (val == -1)
2413                         return 0;
2414         }
2415         if (!val) {
2416                 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2417                 if (val == -1)
2418                         return 0;
2419         }
2420
2421         rate = format & 0xff00;
2422         for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2423                 if (rate_bits[i].hda_fmt == rate) {
2424                         if (val & (1 << i))
2425                                 break;
2426                         return 0;
2427                 }
2428         if (i >= AC_PAR_PCM_RATE_BITS)
2429                 return 0;
2430
2431         stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2432         if (stream == -1)
2433                 return 0;
2434         if (!stream && nid != codec->afg)
2435                 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2436         if (!stream || stream == -1)
2437                 return 0;
2438
2439         if (stream & AC_SUPFMT_PCM) {
2440                 switch (format & 0xf0) {
2441                 case 0x00:
2442                         if (!(val & AC_SUPPCM_BITS_8))
2443                                 return 0;
2444                         break;
2445                 case 0x10:
2446                         if (!(val & AC_SUPPCM_BITS_16))
2447                                 return 0;
2448                         break;
2449                 case 0x20:
2450                         if (!(val & AC_SUPPCM_BITS_20))
2451                                 return 0;
2452                         break;
2453                 case 0x30:
2454                         if (!(val & AC_SUPPCM_BITS_24))
2455                                 return 0;
2456                         break;
2457                 case 0x40:
2458                         if (!(val & AC_SUPPCM_BITS_32))
2459                                 return 0;
2460                         break;
2461                 default:
2462                         return 0;
2463                 }
2464         } else {
2465                 /* FIXME: check for float32 and AC3? */
2466         }
2467
2468         return 1;
2469 }
2470 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2471
2472 /*
2473  * PCM stuff
2474  */
2475 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2476                                       struct hda_codec *codec,
2477                                       struct snd_pcm_substream *substream)
2478 {
2479         return 0;
2480 }
2481
2482 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2483                                    struct hda_codec *codec,
2484                                    unsigned int stream_tag,
2485                                    unsigned int format,
2486                                    struct snd_pcm_substream *substream)
2487 {
2488         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2489         return 0;
2490 }
2491
2492 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2493                                    struct hda_codec *codec,
2494                                    struct snd_pcm_substream *substream)
2495 {
2496         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2497         return 0;
2498 }
2499
2500 static int set_pcm_default_values(struct hda_codec *codec,
2501                                   struct hda_pcm_stream *info)
2502 {
2503         /* query support PCM information from the given NID */
2504         if (info->nid && (!info->rates || !info->formats)) {
2505                 snd_hda_query_supported_pcm(codec, info->nid,
2506                                 info->rates ? NULL : &info->rates,
2507                                 info->formats ? NULL : &info->formats,
2508                                 info->maxbps ? NULL : &info->maxbps);
2509         }
2510         if (info->ops.open == NULL)
2511                 info->ops.open = hda_pcm_default_open_close;
2512         if (info->ops.close == NULL)
2513                 info->ops.close = hda_pcm_default_open_close;
2514         if (info->ops.prepare == NULL) {
2515                 if (snd_BUG_ON(!info->nid))
2516                         return -EINVAL;
2517                 info->ops.prepare = hda_pcm_default_prepare;
2518         }
2519         if (info->ops.cleanup == NULL) {
2520                 if (snd_BUG_ON(!info->nid))
2521                         return -EINVAL;
2522                 info->ops.cleanup = hda_pcm_default_cleanup;
2523         }
2524         return 0;
2525 }
2526
2527 /*
2528  * get the empty PCM device number to assign
2529  */
2530 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2531 {
2532         static const char *dev_name[HDA_PCM_NTYPES] = {
2533                 "Audio", "SPDIF", "HDMI", "Modem"
2534         };
2535         /* starting device index for each PCM type */
2536         static int dev_idx[HDA_PCM_NTYPES] = {
2537                 [HDA_PCM_TYPE_AUDIO] = 0,
2538                 [HDA_PCM_TYPE_SPDIF] = 1,
2539                 [HDA_PCM_TYPE_HDMI] = 3,
2540                 [HDA_PCM_TYPE_MODEM] = 6
2541         };
2542         /* normal audio device indices; not linear to keep compatibility */
2543         static int audio_idx[4] = { 0, 2, 4, 5 };
2544         int i, dev;
2545
2546         switch (type) {
2547         case HDA_PCM_TYPE_AUDIO:
2548                 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2549                         dev = audio_idx[i];
2550                         if (!test_bit(dev, bus->pcm_dev_bits))
2551                                 break;
2552                 }
2553                 if (i >= ARRAY_SIZE(audio_idx)) {
2554                         snd_printk(KERN_WARNING "Too many audio devices\n");
2555                         return -EAGAIN;
2556                 }
2557                 break;
2558         case HDA_PCM_TYPE_SPDIF:
2559         case HDA_PCM_TYPE_HDMI:
2560         case HDA_PCM_TYPE_MODEM:
2561                 dev = dev_idx[type];
2562                 if (test_bit(dev, bus->pcm_dev_bits)) {
2563                         snd_printk(KERN_WARNING "%s already defined\n",
2564                                    dev_name[type]);
2565                         return -EAGAIN;
2566                 }
2567                 break;
2568         default:
2569                 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2570                 return -EINVAL;
2571         }
2572         set_bit(dev, bus->pcm_dev_bits);
2573         return dev;
2574 }
2575
2576 /*
2577  * attach a new PCM stream
2578  */
2579 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2580 {
2581         struct hda_bus *bus = codec->bus;
2582         struct hda_pcm_stream *info;
2583         int stream, err;
2584
2585         if (snd_BUG_ON(!pcm->name))
2586                 return -EINVAL;
2587         for (stream = 0; stream < 2; stream++) {
2588                 info = &pcm->stream[stream];
2589                 if (info->substreams) {
2590                         err = set_pcm_default_values(codec, info);
2591                         if (err < 0)
2592                                 return err;
2593                 }
2594         }
2595         return bus->ops.attach_pcm(bus, codec, pcm);
2596 }
2597
2598 /* assign all PCMs of the given codec */
2599 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2600 {
2601         unsigned int pcm;
2602         int err;
2603
2604         if (!codec->num_pcms) {
2605                 if (!codec->patch_ops.build_pcms)
2606                         return 0;
2607                 err = codec->patch_ops.build_pcms(codec);
2608                 if (err < 0)
2609                         return err;
2610         }
2611         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2612                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2613                 int dev;
2614
2615                 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2616                         return 0; /* no substreams assigned */
2617
2618                 if (!cpcm->pcm) {
2619                         dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2620                         if (dev < 0)
2621                                 return 0;
2622                         cpcm->device = dev;
2623                         err = snd_hda_attach_pcm(codec, cpcm);
2624                         if (err < 0)
2625                                 return err;
2626                 }
2627         }
2628         return 0;
2629 }
2630
2631 /**
2632  * snd_hda_build_pcms - build PCM information
2633  * @bus: the BUS
2634  *
2635  * Create PCM information for each codec included in the bus.
2636  *
2637  * The build_pcms codec patch is requested to set up codec->num_pcms and
2638  * codec->pcm_info properly.  The array is referred by the top-level driver
2639  * to create its PCM instances.
2640  * The allocated codec->pcm_info should be released in codec->patch_ops.free
2641  * callback.
2642  *
2643  * At least, substreams, channels_min and channels_max must be filled for
2644  * each stream.  substreams = 0 indicates that the stream doesn't exist.
2645  * When rates and/or formats are zero, the supported values are queried
2646  * from the given nid.  The nid is used also by the default ops.prepare
2647  * and ops.cleanup callbacks.
2648  *
2649  * The driver needs to call ops.open in its open callback.  Similarly,
2650  * ops.close is supposed to be called in the close callback.
2651  * ops.prepare should be called in the prepare or hw_params callback
2652  * with the proper parameters for set up.
2653  * ops.cleanup should be called in hw_free for clean up of streams.
2654  *
2655  * This function returns 0 if successfull, or a negative error code.
2656  */
2657 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2658 {
2659         struct hda_codec *codec;
2660
2661         list_for_each_entry(codec, &bus->codec_list, list) {
2662                 int err = snd_hda_codec_build_pcms(codec);
2663                 if (err < 0)
2664                         return err;
2665         }
2666         return 0;
2667 }
2668 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2669
2670 /**
2671  * snd_hda_check_board_config - compare the current codec with the config table
2672  * @codec: the HDA codec
2673  * @num_configs: number of config enums
2674  * @models: array of model name strings
2675  * @tbl: configuration table, terminated by null entries
2676  *
2677  * Compares the modelname or PCI subsystem id of the current codec with the
2678  * given configuration table.  If a matching entry is found, returns its
2679  * config value (supposed to be 0 or positive).
2680  *
2681  * If no entries are matching, the function returns a negative value.
2682  */
2683 int snd_hda_check_board_config(struct hda_codec *codec,
2684                                int num_configs, const char **models,
2685                                const struct snd_pci_quirk *tbl)
2686 {
2687         if (codec->modelname && models) {
2688                 int i;
2689                 for (i = 0; i < num_configs; i++) {
2690                         if (models[i] &&
2691                             !strcmp(codec->modelname, models[i])) {
2692                                 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2693                                            "selected\n", models[i]);
2694                                 return i;
2695                         }
2696                 }
2697         }
2698
2699         if (!codec->bus->pci || !tbl)
2700                 return -1;
2701
2702         tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2703         if (!tbl)
2704                 return -1;
2705         if (tbl->value >= 0 && tbl->value < num_configs) {
2706 #ifdef CONFIG_SND_DEBUG_VERBOSE
2707                 char tmp[10];
2708                 const char *model = NULL;
2709                 if (models)
2710                         model = models[tbl->value];
2711                 if (!model) {
2712                         sprintf(tmp, "#%d", tbl->value);
2713                         model = tmp;
2714                 }
2715                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2716                             "for config %x:%x (%s)\n",
2717                             model, tbl->subvendor, tbl->subdevice,
2718                             (tbl->name ? tbl->name : "Unknown device"));
2719 #endif
2720                 return tbl->value;
2721         }
2722         return -1;
2723 }
2724 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
2725
2726 /**
2727  * snd_hda_check_board_codec_sid_config - compare the current codec
2728                                           subsystem ID with the
2729                                           config table
2730
2731            This is important for Gateway notebooks with SB450 HDA Audio
2732            where the vendor ID of the PCI device is:
2733                 ATI Technologies Inc SB450 HDA Audio [1002:437b]
2734            and the vendor/subvendor are found only at the codec.
2735
2736  * @codec: the HDA codec
2737  * @num_configs: number of config enums
2738  * @models: array of model name strings
2739  * @tbl: configuration table, terminated by null entries
2740  *
2741  * Compares the modelname or PCI subsystem id of the current codec with the
2742  * given configuration table.  If a matching entry is found, returns its
2743  * config value (supposed to be 0 or positive).
2744  *
2745  * If no entries are matching, the function returns a negative value.
2746  */
2747 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
2748                                int num_configs, const char **models,
2749                                const struct snd_pci_quirk *tbl)
2750 {
2751         const struct snd_pci_quirk *q;
2752
2753         /* Search for codec ID */
2754         for (q = tbl; q->subvendor; q++) {
2755                 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
2756
2757                 if (vendorid == codec->subsystem_id)
2758                         break;
2759         }
2760
2761         if (!q->subvendor)
2762                 return -1;
2763
2764         tbl = q;
2765
2766         if (tbl->value >= 0 && tbl->value < num_configs) {
2767 #ifdef CONFIG_SND_DEBUG_DETECT
2768                 char tmp[10];
2769                 const char *model = NULL;
2770                 if (models)
2771                         model = models[tbl->value];
2772                 if (!model) {
2773                         sprintf(tmp, "#%d", tbl->value);
2774                         model = tmp;
2775                 }
2776                 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2777                             "for config %x:%x (%s)\n",
2778                             model, tbl->subvendor, tbl->subdevice,
2779                             (tbl->name ? tbl->name : "Unknown device"));
2780 #endif
2781                 return tbl->value;
2782         }
2783         return -1;
2784 }
2785 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
2786
2787 /**
2788  * snd_hda_add_new_ctls - create controls from the array
2789  * @codec: the HDA codec
2790  * @knew: the array of struct snd_kcontrol_new
2791  *
2792  * This helper function creates and add new controls in the given array.
2793  * The array must be terminated with an empty entry as terminator.
2794  *
2795  * Returns 0 if successful, or a negative error code.
2796  */
2797 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
2798 {
2799         int err;
2800
2801         for (; knew->name; knew++) {
2802                 struct snd_kcontrol *kctl;
2803                 kctl = snd_ctl_new1(knew, codec);
2804                 if (!kctl)
2805                         return -ENOMEM;
2806                 err = snd_hda_ctl_add(codec, kctl);
2807                 if (err < 0) {
2808                         if (!codec->addr)
2809                                 return err;
2810                         kctl = snd_ctl_new1(knew, codec);
2811                         if (!kctl)
2812                                 return -ENOMEM;
2813                         kctl->id.device = codec->addr;
2814                         err = snd_hda_ctl_add(codec, kctl);
2815                         if (err < 0)
2816                                 return err;
2817                 }
2818         }
2819         return 0;
2820 }
2821 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
2822
2823 #ifdef CONFIG_SND_HDA_POWER_SAVE
2824 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2825                                 unsigned int power_state);
2826
2827 static void hda_power_work(struct work_struct *work)
2828 {
2829         struct hda_codec *codec =
2830                 container_of(work, struct hda_codec, power_work.work);
2831         struct hda_bus *bus = codec->bus;
2832
2833         if (!codec->power_on || codec->power_count) {
2834                 codec->power_transition = 0;
2835                 return;
2836         }
2837
2838         hda_call_codec_suspend(codec);
2839         if (bus->ops.pm_notify)
2840                 bus->ops.pm_notify(bus);
2841 }
2842
2843 static void hda_keep_power_on(struct hda_codec *codec)
2844 {
2845         codec->power_count++;
2846         codec->power_on = 1;
2847 }
2848
2849 void snd_hda_power_up(struct hda_codec *codec)
2850 {
2851         struct hda_bus *bus = codec->bus;
2852
2853         codec->power_count++;
2854         if (codec->power_on || codec->power_transition)
2855                 return;
2856
2857         codec->power_on = 1;
2858         if (bus->ops.pm_notify)
2859                 bus->ops.pm_notify(bus);
2860         hda_call_codec_resume(codec);
2861         cancel_delayed_work(&codec->power_work);
2862         codec->power_transition = 0;
2863 }
2864 EXPORT_SYMBOL_HDA(snd_hda_power_up);
2865
2866 #define power_save(codec)       \
2867         ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2868
2869 #define power_save(codec)       \
2870         ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2871
2872 void snd_hda_power_down(struct hda_codec *codec)
2873 {
2874         --codec->power_count;
2875         if (!codec->power_on || codec->power_count || codec->power_transition)
2876                 return;
2877         if (power_save(codec)) {
2878                 codec->power_transition = 1; /* avoid reentrance */
2879                 queue_delayed_work(codec->bus->workq, &codec->power_work,
2880                                 msecs_to_jiffies(power_save(codec) * 1000));
2881         }
2882 }
2883 EXPORT_SYMBOL_HDA(snd_hda_power_down);
2884
2885 int snd_hda_check_amp_list_power(struct hda_codec *codec,
2886                                  struct hda_loopback_check *check,
2887                                  hda_nid_t nid)
2888 {
2889         struct hda_amp_list *p;
2890         int ch, v;
2891
2892         if (!check->amplist)
2893                 return 0;
2894         for (p = check->amplist; p->nid; p++) {
2895                 if (p->nid == nid)
2896                         break;
2897         }
2898         if (!p->nid)
2899                 return 0; /* nothing changed */
2900
2901         for (p = check->amplist; p->nid; p++) {
2902                 for (ch = 0; ch < 2; ch++) {
2903                         v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
2904                                                    p->idx);
2905                         if (!(v & HDA_AMP_MUTE) && v > 0) {
2906                                 if (!check->power_on) {
2907                                         check->power_on = 1;
2908                                         snd_hda_power_up(codec);
2909                                 }
2910                                 return 1;
2911                         }
2912                 }
2913         }
2914         if (check->power_on) {
2915                 check->power_on = 0;
2916                 snd_hda_power_down(codec);
2917         }
2918         return 0;
2919 }
2920 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
2921 #endif
2922
2923 /*
2924  * Channel mode helper
2925  */
2926 int snd_hda_ch_mode_info(struct hda_codec *codec,
2927                          struct snd_ctl_elem_info *uinfo,
2928                          const struct hda_channel_mode *chmode,
2929                          int num_chmodes)
2930 {
2931         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2932         uinfo->count = 1;
2933         uinfo->value.enumerated.items = num_chmodes;
2934         if (uinfo->value.enumerated.item >= num_chmodes)
2935                 uinfo->value.enumerated.item = num_chmodes - 1;
2936         sprintf(uinfo->value.enumerated.name, "%dch",
2937                 chmode[uinfo->value.enumerated.item].channels);
2938         return 0;
2939 }
2940 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
2941
2942 int snd_hda_ch_mode_get(struct hda_codec *codec,
2943                         struct snd_ctl_elem_value *ucontrol,
2944                         const struct hda_channel_mode *chmode,
2945                         int num_chmodes,
2946                         int max_channels)
2947 {
2948         int i;
2949
2950         for (i = 0; i < num_chmodes; i++) {
2951                 if (max_channels == chmode[i].channels) {
2952                         ucontrol->value.enumerated.item[0] = i;
2953                         break;
2954                 }
2955         }
2956         return 0;
2957 }
2958 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
2959
2960 int snd_hda_ch_mode_put(struct hda_codec *codec,
2961                         struct snd_ctl_elem_value *ucontrol,
2962                         const struct hda_channel_mode *chmode,
2963                         int num_chmodes,
2964                         int *max_channelsp)
2965 {
2966         unsigned int mode;
2967
2968         mode = ucontrol->value.enumerated.item[0];
2969         if (mode >= num_chmodes)
2970                 return -EINVAL;
2971         if (*max_channelsp == chmode[mode].channels)
2972                 return 0;
2973         /* change the current channel setting */
2974         *max_channelsp = chmode[mode].channels;
2975         if (chmode[mode].sequence)
2976                 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
2977         return 1;
2978 }
2979 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
2980
2981 /*
2982  * input MUX helper
2983  */
2984 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
2985                            struct snd_ctl_elem_info *uinfo)
2986 {
2987         unsigned int index;
2988
2989         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2990         uinfo->count = 1;
2991         uinfo->value.enumerated.items = imux->num_items;
2992         if (!imux->num_items)
2993                 return 0;
2994         index = uinfo->value.enumerated.item;
2995         if (index >= imux->num_items)
2996                 index = imux->num_items - 1;
2997         strcpy(uinfo->value.enumerated.name, imux->items[index].label);
2998         return 0;
2999 }
3000 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3001
3002 int snd_hda_input_mux_put(struct hda_codec *codec,
3003                           const struct hda_input_mux *imux,
3004                           struct snd_ctl_elem_value *ucontrol,
3005                           hda_nid_t nid,
3006                           unsigned int *cur_val)
3007 {
3008         unsigned int idx;
3009
3010         if (!imux->num_items)
3011                 return 0;
3012         idx = ucontrol->value.enumerated.item[0];
3013         if (idx >= imux->num_items)
3014                 idx = imux->num_items - 1;
3015         if (*cur_val == idx)
3016                 return 0;
3017         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3018                                   imux->items[idx].index);
3019         *cur_val = idx;
3020         return 1;
3021 }
3022 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3023
3024
3025 /*
3026  * Multi-channel / digital-out PCM helper functions
3027  */
3028
3029 /* setup SPDIF output stream */
3030 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3031                                  unsigned int stream_tag, unsigned int format)
3032 {
3033         /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3034         if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3035                 set_dig_out_convert(codec, nid,
3036                                     codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3037                                     -1);
3038         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3039         if (codec->slave_dig_outs) {
3040                 hda_nid_t *d;
3041                 for (d = codec->slave_dig_outs; *d; d++)
3042                         snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3043                                                    format);
3044         }
3045         /* turn on again (if needed) */
3046         if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3047                 set_dig_out_convert(codec, nid,
3048                                     codec->spdif_ctls & 0xff, -1);
3049 }
3050
3051 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3052 {
3053         snd_hda_codec_cleanup_stream(codec, nid);
3054         if (codec->slave_dig_outs) {
3055                 hda_nid_t *d;
3056                 for (d = codec->slave_dig_outs; *d; d++)
3057                         snd_hda_codec_cleanup_stream(codec, *d);
3058         }
3059 }
3060
3061 /*
3062  * open the digital out in the exclusive mode
3063  */
3064 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3065                                struct hda_multi_out *mout)
3066 {
3067         mutex_lock(&codec->spdif_mutex);
3068         if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3069                 /* already opened as analog dup; reset it once */
3070                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3071         mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3072         mutex_unlock(&codec->spdif_mutex);
3073         return 0;
3074 }
3075 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3076
3077 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3078                                   struct hda_multi_out *mout,
3079                                   unsigned int stream_tag,
3080                                   unsigned int format,
3081                                   struct snd_pcm_substream *substream)
3082 {
3083         mutex_lock(&codec->spdif_mutex);
3084         setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3085         mutex_unlock(&codec->spdif_mutex);
3086         return 0;
3087 }
3088 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3089
3090 /*
3091  * release the digital out
3092  */
3093 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3094                                 struct hda_multi_out *mout)
3095 {
3096         mutex_lock(&codec->spdif_mutex);
3097         mout->dig_out_used = 0;
3098         mutex_unlock(&codec->spdif_mutex);
3099         return 0;
3100 }
3101 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3102
3103 /*
3104  * set up more restrictions for analog out
3105  */
3106 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3107                                   struct hda_multi_out *mout,
3108                                   struct snd_pcm_substream *substream,
3109                                   struct hda_pcm_stream *hinfo)
3110 {
3111         struct snd_pcm_runtime *runtime = substream->runtime;
3112         runtime->hw.channels_max = mout->max_channels;
3113         if (mout->dig_out_nid) {
3114                 if (!mout->analog_rates) {
3115                         mout->analog_rates = hinfo->rates;
3116                         mout->analog_formats = hinfo->formats;
3117                         mout->analog_maxbps = hinfo->maxbps;
3118                 } else {
3119                         runtime->hw.rates = mout->analog_rates;
3120                         runtime->hw.formats = mout->analog_formats;
3121                         hinfo->maxbps = mout->analog_maxbps;
3122                 }
3123                 if (!mout->spdif_rates) {
3124                         snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3125                                                     &mout->spdif_rates,
3126                                                     &mout->spdif_formats,
3127                                                     &mout->spdif_maxbps);
3128                 }
3129                 mutex_lock(&codec->spdif_mutex);
3130                 if (mout->share_spdif) {
3131                         runtime->hw.rates &= mout->spdif_rates;
3132                         runtime->hw.formats &= mout->spdif_formats;
3133                         if (mout->spdif_maxbps < hinfo->maxbps)
3134                                 hinfo->maxbps = mout->spdif_maxbps;
3135                 }
3136                 mutex_unlock(&codec->spdif_mutex);
3137         }
3138         return snd_pcm_hw_constraint_step(substream->runtime, 0,
3139                                           SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3140 }
3141 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3142
3143 /*
3144  * set up the i/o for analog out
3145  * when the digital out is available, copy the front out to digital out, too.
3146  */
3147 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3148                                      struct hda_multi_out *mout,
3149                                      unsigned int stream_tag,
3150                                      unsigned int format,
3151                                      struct snd_pcm_substream *substream)
3152 {
3153         hda_nid_t *nids = mout->dac_nids;
3154         int chs = substream->runtime->channels;
3155         int i;
3156
3157         mutex_lock(&codec->spdif_mutex);
3158         if (mout->dig_out_nid && mout->share_spdif &&
3159             mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3160                 if (chs == 2 &&
3161                     snd_hda_is_supported_format(codec, mout->dig_out_nid,
3162                                                 format) &&
3163                     !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3164                         mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3165                         setup_dig_out_stream(codec, mout->dig_out_nid,
3166                                              stream_tag, format);
3167                 } else {
3168                         mout->dig_out_used = 0;
3169                         cleanup_dig_out_stream(codec, mout->dig_out_nid);
3170                 }
3171         }
3172         mutex_unlock(&codec->spdif_mutex);
3173
3174         /* front */
3175         snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3176                                    0, format);
3177         if (!mout->no_share_stream &&
3178             mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3179                 /* headphone out will just decode front left/right (stereo) */
3180                 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3181                                            0, format);
3182         /* extra outputs copied from front */
3183         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3184                 if (!mout->no_share_stream && mout->extra_out_nid[i])
3185                         snd_hda_codec_setup_stream(codec,
3186                                                    mout->extra_out_nid[i],
3187                                                    stream_tag, 0, format);
3188
3189         /* surrounds */
3190         for (i = 1; i < mout->num_dacs; i++) {
3191                 if (chs >= (i + 1) * 2) /* independent out */
3192                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3193                                                    i * 2, format);
3194                 else if (!mout->no_share_stream) /* copy front */
3195                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3196                                                    0, format);
3197         }
3198         return 0;
3199 }
3200 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3201
3202 /*
3203  * clean up the setting for analog out
3204  */
3205 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3206                                      struct hda_multi_out *mout)
3207 {
3208         hda_nid_t *nids = mout->dac_nids;
3209         int i;
3210
3211         for (i = 0; i < mout->num_dacs; i++)
3212                 snd_hda_codec_cleanup_stream(codec, nids[i]);
3213         if (mout->hp_nid)
3214                 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3215         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3216                 if (mout->extra_out_nid[i])
3217                         snd_hda_codec_cleanup_stream(codec,
3218                                                      mout->extra_out_nid[i]);
3219         mutex_lock(&codec->spdif_mutex);
3220         if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3221                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3222                 mout->dig_out_used = 0;
3223         }
3224         mutex_unlock(&codec->spdif_mutex);
3225         return 0;
3226 }
3227 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3228
3229 /*
3230  * Helper for automatic pin configuration
3231  */
3232
3233 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3234 {
3235         for (; *list; list++)
3236                 if (*list == nid)
3237                         return 1;
3238         return 0;
3239 }
3240
3241
3242 /*
3243  * Sort an associated group of pins according to their sequence numbers.
3244  */
3245 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3246                                   int num_pins)
3247 {
3248         int i, j;
3249         short seq;
3250         hda_nid_t nid;
3251
3252         for (i = 0; i < num_pins; i++) {
3253                 for (j = i + 1; j < num_pins; j++) {
3254                         if (sequences[i] > sequences[j]) {
3255                                 seq = sequences[i];
3256                                 sequences[i] = sequences[j];
3257                                 sequences[j] = seq;
3258                                 nid = pins[i];
3259                                 pins[i] = pins[j];
3260                                 pins[j] = nid;
3261                         }
3262                 }
3263         }
3264 }
3265
3266
3267 /*
3268  * Parse all pin widgets and store the useful pin nids to cfg
3269  *
3270  * The number of line-outs or any primary output is stored in line_outs,
3271  * and the corresponding output pins are assigned to line_out_pins[],
3272  * in the order of front, rear, CLFE, side, ...
3273  *
3274  * If more extra outputs (speaker and headphone) are found, the pins are
3275  * assisnged to hp_pins[] and speaker_pins[], respectively.  If no line-out jack
3276  * is detected, one of speaker of HP pins is assigned as the primary
3277  * output, i.e. to line_out_pins[0].  So, line_outs is always positive
3278  * if any analog output exists.
3279  *
3280  * The analog input pins are assigned to input_pins array.
3281  * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3282  * respectively.
3283  */
3284 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3285                                  struct auto_pin_cfg *cfg,
3286                                  hda_nid_t *ignore_nids)
3287 {
3288         hda_nid_t nid, end_nid;
3289         short seq, assoc_line_out, assoc_speaker;
3290         short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3291         short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3292         short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3293
3294         memset(cfg, 0, sizeof(*cfg));
3295
3296         memset(sequences_line_out, 0, sizeof(sequences_line_out));
3297         memset(sequences_speaker, 0, sizeof(sequences_speaker));
3298         memset(sequences_hp, 0, sizeof(sequences_hp));
3299         assoc_line_out = assoc_speaker = 0;
3300
3301         end_nid = codec->start_nid + codec->num_nodes;
3302         for (nid = codec->start_nid; nid < end_nid; nid++) {
3303                 unsigned int wid_caps = get_wcaps(codec, nid);
3304                 unsigned int wid_type =
3305                         (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3306                 unsigned int def_conf;
3307                 short assoc, loc;
3308
3309                 /* read all default configuration for pin complex */
3310                 if (wid_type != AC_WID_PIN)
3311                         continue;
3312                 /* ignore the given nids (e.g. pc-beep returns error) */
3313                 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3314                         continue;
3315
3316                 def_conf = snd_hda_codec_read(codec, nid, 0,
3317                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
3318                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3319                         continue;
3320                 loc = get_defcfg_location(def_conf);
3321                 switch (get_defcfg_device(def_conf)) {
3322                 case AC_JACK_LINE_OUT:
3323                         seq = get_defcfg_sequence(def_conf);
3324                         assoc = get_defcfg_association(def_conf);
3325
3326                         if (!(wid_caps & AC_WCAP_STEREO))
3327                                 if (!cfg->mono_out_pin)
3328                                         cfg->mono_out_pin = nid;
3329                         if (!assoc)
3330                                 continue;
3331                         if (!assoc_line_out)
3332                                 assoc_line_out = assoc;
3333                         else if (assoc_line_out != assoc)
3334                                 continue;
3335                         if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3336                                 continue;
3337                         cfg->line_out_pins[cfg->line_outs] = nid;
3338                         sequences_line_out[cfg->line_outs] = seq;
3339                         cfg->line_outs++;
3340                         break;
3341                 case AC_JACK_SPEAKER:
3342                         seq = get_defcfg_sequence(def_conf);
3343                         assoc = get_defcfg_association(def_conf);
3344                         if (! assoc)
3345                                 continue;
3346                         if (! assoc_speaker)
3347                                 assoc_speaker = assoc;
3348                         else if (assoc_speaker != assoc)
3349                                 continue;
3350                         if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3351                                 continue;
3352                         cfg->speaker_pins[cfg->speaker_outs] = nid;
3353                         sequences_speaker[cfg->speaker_outs] = seq;
3354                         cfg->speaker_outs++;
3355                         break;
3356                 case AC_JACK_HP_OUT:
3357                         seq = get_defcfg_sequence(def_conf);
3358                         assoc = get_defcfg_association(def_conf);
3359                         if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3360                                 continue;
3361                         cfg->hp_pins[cfg->hp_outs] = nid;
3362                         sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3363                         cfg->hp_outs++;
3364                         break;
3365                 case AC_JACK_MIC_IN: {
3366                         int preferred, alt;
3367                         if (loc == AC_JACK_LOC_FRONT) {
3368                                 preferred = AUTO_PIN_FRONT_MIC;
3369                                 alt = AUTO_PIN_MIC;
3370                         } else {
3371                                 preferred = AUTO_PIN_MIC;
3372                                 alt = AUTO_PIN_FRONT_MIC;
3373                         }
3374                         if (!cfg->input_pins[preferred])
3375                                 cfg->input_pins[preferred] = nid;
3376                         else if (!cfg->input_pins[alt])
3377                                 cfg->input_pins[alt] = nid;
3378                         break;
3379                 }
3380                 case AC_JACK_LINE_IN:
3381                         if (loc == AC_JACK_LOC_FRONT)
3382                                 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3383                         else
3384                                 cfg->input_pins[AUTO_PIN_LINE] = nid;
3385                         break;
3386                 case AC_JACK_CD:
3387                         cfg->input_pins[AUTO_PIN_CD] = nid;
3388                         break;
3389                 case AC_JACK_AUX:
3390                         cfg->input_pins[AUTO_PIN_AUX] = nid;
3391                         break;
3392                 case AC_JACK_SPDIF_OUT:
3393                         cfg->dig_out_pin = nid;
3394                         break;
3395                 case AC_JACK_SPDIF_IN:
3396                         cfg->dig_in_pin = nid;
3397                         break;
3398                 }
3399         }
3400
3401         /* FIX-UP:
3402          * If no line-out is defined but multiple HPs are found,
3403          * some of them might be the real line-outs.
3404          */
3405         if (!cfg->line_outs && cfg->hp_outs > 1) {
3406                 int i = 0;
3407                 while (i < cfg->hp_outs) {
3408                         /* The real HPs should have the sequence 0x0f */
3409                         if ((sequences_hp[i] & 0x0f) == 0x0f) {
3410                                 i++;
3411                                 continue;
3412                         }
3413                         /* Move it to the line-out table */
3414                         cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3415                         sequences_line_out[cfg->line_outs] = sequences_hp[i];
3416                         cfg->line_outs++;
3417                         cfg->hp_outs--;
3418                         memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3419                                 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3420                         memmove(sequences_hp + i - 1, sequences_hp + i,
3421                                 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3422                 }
3423         }
3424
3425         /* sort by sequence */
3426         sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3427                               cfg->line_outs);
3428         sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3429                               cfg->speaker_outs);
3430         sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3431                               cfg->hp_outs);
3432
3433         /* if we have only one mic, make it AUTO_PIN_MIC */
3434         if (!cfg->input_pins[AUTO_PIN_MIC] &&
3435             cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3436                 cfg->input_pins[AUTO_PIN_MIC] =
3437                         cfg->input_pins[AUTO_PIN_FRONT_MIC];
3438                 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3439         }
3440         /* ditto for line-in */
3441         if (!cfg->input_pins[AUTO_PIN_LINE] &&
3442             cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3443                 cfg->input_pins[AUTO_PIN_LINE] =
3444                         cfg->input_pins[AUTO_PIN_FRONT_LINE];
3445                 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3446         }
3447
3448         /*
3449          * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3450          * as a primary output
3451          */
3452         if (!cfg->line_outs) {
3453                 if (cfg->speaker_outs) {
3454                         cfg->line_outs = cfg->speaker_outs;
3455                         memcpy(cfg->line_out_pins, cfg->speaker_pins,
3456                                sizeof(cfg->speaker_pins));
3457                         cfg->speaker_outs = 0;
3458                         memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3459                         cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3460                 } else if (cfg->hp_outs) {
3461                         cfg->line_outs = cfg->hp_outs;
3462                         memcpy(cfg->line_out_pins, cfg->hp_pins,
3463                                sizeof(cfg->hp_pins));
3464                         cfg->hp_outs = 0;
3465                         memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3466                         cfg->line_out_type = AUTO_PIN_HP_OUT;
3467                 }
3468         }
3469
3470         /* Reorder the surround channels
3471          * ALSA sequence is front/surr/clfe/side
3472          * HDA sequence is:
3473          *    4-ch: front/surr  =>  OK as it is
3474          *    6-ch: front/clfe/surr
3475          *    8-ch: front/clfe/rear/side|fc
3476          */
3477         switch (cfg->line_outs) {
3478         case 3:
3479         case 4:
3480                 nid = cfg->line_out_pins[1];
3481                 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3482                 cfg->line_out_pins[2] = nid;
3483                 break;
3484         }
3485
3486         /*
3487          * debug prints of the parsed results
3488          */
3489         snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3490                    cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3491                    cfg->line_out_pins[2], cfg->line_out_pins[3],
3492                    cfg->line_out_pins[4]);
3493         snd_printd("   speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3494                    cfg->speaker_outs, cfg->speaker_pins[0],
3495                    cfg->speaker_pins[1], cfg->speaker_pins[2],
3496                    cfg->speaker_pins[3], cfg->speaker_pins[4]);
3497         snd_printd("   hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3498                    cfg->hp_outs, cfg->hp_pins[0],
3499                    cfg->hp_pins[1], cfg->hp_pins[2],
3500                    cfg->hp_pins[3], cfg->hp_pins[4]);
3501         snd_printd("   mono: mono_out=0x%x\n", cfg->mono_out_pin);
3502         snd_printd("   inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3503                    " cd=0x%x, aux=0x%x\n",
3504                    cfg->input_pins[AUTO_PIN_MIC],
3505                    cfg->input_pins[AUTO_PIN_FRONT_MIC],
3506                    cfg->input_pins[AUTO_PIN_LINE],
3507                    cfg->input_pins[AUTO_PIN_FRONT_LINE],
3508                    cfg->input_pins[AUTO_PIN_CD],
3509                    cfg->input_pins[AUTO_PIN_AUX]);
3510
3511         return 0;
3512 }
3513 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3514
3515 /* labels for input pins */
3516 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3517         "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3518 };
3519 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3520
3521
3522 #ifdef CONFIG_PM
3523 /*
3524  * power management
3525  */
3526
3527 /**
3528  * snd_hda_suspend - suspend the codecs
3529  * @bus: the HDA bus
3530  * @state: suspsend state
3531  *
3532  * Returns 0 if successful.
3533  */
3534 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3535 {
3536         struct hda_codec *codec;
3537
3538         list_for_each_entry(codec, &bus->codec_list, list) {
3539 #ifdef CONFIG_SND_HDA_POWER_SAVE
3540                 if (!codec->power_on)
3541                         continue;
3542 #endif
3543                 hda_call_codec_suspend(codec);
3544         }
3545         return 0;
3546 }
3547 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3548
3549 /**
3550  * snd_hda_resume - resume the codecs
3551  * @bus: the HDA bus
3552  *
3553  * Returns 0 if successful.
3554  *
3555  * This fucntion is defined only when POWER_SAVE isn't set.
3556  * In the power-save mode, the codec is resumed dynamically.
3557  */
3558 int snd_hda_resume(struct hda_bus *bus)
3559 {
3560         struct hda_codec *codec;
3561
3562         list_for_each_entry(codec, &bus->codec_list, list) {
3563                 if (snd_hda_codec_needs_resume(codec))
3564                         hda_call_codec_resume(codec);
3565         }
3566         return 0;
3567 }
3568 EXPORT_SYMBOL_HDA(snd_hda_resume);
3569 #endif /* CONFIG_PM */
3570
3571 /*
3572  * generic arrays
3573  */
3574
3575 /* get a new element from the given array
3576  * if it exceeds the pre-allocated array size, re-allocate the array
3577  */
3578 void *snd_array_new(struct snd_array *array)
3579 {
3580         if (array->used >= array->alloced) {
3581                 int num = array->alloced + array->alloc_align;
3582                 void *nlist;
3583                 if (snd_BUG_ON(num >= 4096))
3584                         return NULL;
3585                 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3586                 if (!nlist)
3587                         return NULL;
3588                 if (array->list) {
3589                         memcpy(nlist, array->list,
3590                                array->elem_size * array->alloced);
3591                         kfree(array->list);
3592                 }
3593                 array->list = nlist;
3594                 array->alloced = num;
3595         }
3596         return snd_array_elem(array, array->used++);
3597 }
3598 EXPORT_SYMBOL_HDA(snd_array_new);
3599
3600 /* free the given array elements */
3601 void snd_array_free(struct snd_array *array)
3602 {
3603         kfree(array->list);
3604         array->used = 0;
3605         array->alloced = 0;
3606         array->list = NULL;
3607 }
3608 EXPORT_SYMBOL_HDA(snd_array_free);
3609
3610 /*
3611  * used by hda_proc.c and hda_eld.c
3612  */
3613 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3614 {
3615         static unsigned int rates[] = {
3616                 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3617                 96000, 176400, 192000, 384000
3618         };
3619         int i, j;
3620
3621         for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3622                 if (pcm & (1 << i))
3623                         j += snprintf(buf + j, buflen - j,  " %d", rates[i]);
3624
3625         buf[j] = '\0'; /* necessary when j == 0 */
3626 }
3627 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3628
3629 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3630 {
3631         static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3632         int i, j;
3633
3634         for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3635                 if (pcm & (AC_SUPPCM_BITS_8 << i))
3636                         j += snprintf(buf + j, buflen - j,  " %d", bits[i]);
3637
3638         buf[j] = '\0'; /* necessary when j == 0 */
3639 }
3640 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
3641
3642 MODULE_DESCRIPTION("HDA codec core");
3643 MODULE_LICENSE("GPL");