sound/pci/hda/hda_codec.c

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