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