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