sound/pci/hda/hda_codec.c

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