sound/pci/hda/hda_codec.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Universal Interface for Intel High Definition Audio Codec
   4  *
   5  * Copyright (c) 2004 Takashi Iwai <[email protected]>
   6  */
   7
   8 #include <linux/init.h>
   9 #include <linux/delay.h>
  10 #include <linux/slab.h>
  11 #include <linux/mutex.h>
  12 #include <linux/module.h>
  13 #include <linux/pm.h>
  14 #include <linux/pm_runtime.h>
  15 #include <sound/core.h>
  16 #include <sound/hda_codec.h>
  17 #include <sound/asoundef.h>
  18 #include <sound/tlv.h>
  19 #include <sound/initval.h>
  20 #include <sound/jack.h>
  21 #include "hda_local.h"
  22 #include "hda_beep.h"
  23 #include "hda_jack.h"
  24 #include <sound/hda_hwdep.h>
  25 #include <sound/hda_component.h>
  26
  27 #define codec_in_pm(codec)              snd_hdac_is_in_pm(&codec->core)
  28 #define hda_codec_is_power_on(codec)    snd_hdac_is_power_on(&codec->core)
  29 #define codec_has_epss(codec) \
  30         ((codec)->core.power_caps & AC_PWRST_EPSS)
  31 #define codec_has_clkstop(codec) \
  32         ((codec)->core.power_caps & AC_PWRST_CLKSTOP)
  33
  34 /*
  35  * Send and receive a verb - passed to exec_verb override for hdac_device
  36  */
  37 static int codec_exec_verb(struct hdac_device *dev, unsigned int cmd,
  38                            unsigned int flags, unsigned int *res)
  39 {
  40         struct hda_codec *codec = container_of(dev, struct hda_codec, core);
  41         struct hda_bus *bus = codec->bus;
  42         int err;
  43
  44         if (cmd == ~0)
  45                 return -1;
  46
  47  again:
  48         snd_hda_power_up_pm(codec);
  49         mutex_lock(&bus->core.cmd_mutex);
  50         if (flags & HDA_RW_NO_RESPONSE_FALLBACK)
  51                 bus->no_response_fallback = 1;
  52         err = snd_hdac_bus_exec_verb_unlocked(&bus->core, codec->core.addr,
  53                                               cmd, res);
  54         bus->no_response_fallback = 0;
  55         mutex_unlock(&bus->core.cmd_mutex);
  56         snd_hda_power_down_pm(codec);
  57         if (!codec_in_pm(codec) && res && err == -EAGAIN) {
  58                 if (bus->response_reset) {
  59                         codec_dbg(codec,
  60                                   "resetting BUS due to fatal communication error\n");
  61                         snd_hda_bus_reset(bus);
  62                 }
  63                 goto again;
  64         }
  65         /* clear reset-flag when the communication gets recovered */
  66         if (!err || codec_in_pm(codec))
  67                 bus->response_reset = 0;
  68         return err;
  69 }
  70
  71 /**
  72  * snd_hda_sequence_write - sequence writes
  73  * @codec: the HDA codec
  74  * @seq: VERB array to send
  75  *
  76  * Send the commands sequentially from the given array.
  77  * The array must be terminated with NID=0.
  78  */
  79 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
  80 {
  81         for (; seq->nid; seq++)
  82                 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
  83 }
  84 EXPORT_SYMBOL_GPL(snd_hda_sequence_write);
  85
  86 /* connection list element */
  87 struct hda_conn_list {
  88         struct list_head list;
  89         int len;
  90         hda_nid_t nid;
  91         hda_nid_t conns[];
  92 };
  93
  94 /* look up the cached results */
  95 static struct hda_conn_list *
  96 lookup_conn_list(struct hda_codec *codec, hda_nid_t nid)
  97 {
  98         struct hda_conn_list *p;
  99         list_for_each_entry(p, &codec->conn_list, list) {
 100                 if (p->nid == nid)
 101                         return p;
 102         }
 103         return NULL;
 104 }
 105
 106 static int add_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
 107                          const hda_nid_t *list)
 108 {
 109         struct hda_conn_list *p;
 110
 111         p = kmalloc(struct_size(p, conns, len), GFP_KERNEL);
 112         if (!p)
 113                 return -ENOMEM;
 114         p->len = len;
 115         p->nid = nid;
 116         memcpy(p->conns, list, len * sizeof(hda_nid_t));
 117         list_add(&p->list, &codec->conn_list);
 118         return 0;
 119 }
 120
 121 static void remove_conn_list(struct hda_codec *codec)
 122 {
 123         while (!list_empty(&codec->conn_list)) {
 124                 struct hda_conn_list *p;
 125                 p = list_first_entry(&codec->conn_list, typeof(*p), list);
 126                 list_del(&p->list);
 127                 kfree(p);
 128         }
 129 }
 130
 131 /* read the connection and add to the cache */
 132 static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
 133 {
 134         hda_nid_t list[32];
 135         hda_nid_t *result = list;
 136         int len;
 137
 138         len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
 139         if (len == -ENOSPC) {
 140                 len = snd_hda_get_num_raw_conns(codec, nid);
 141                 result = kmalloc_array(len, sizeof(hda_nid_t), GFP_KERNEL);
 142                 if (!result)
 143                         return -ENOMEM;
 144                 len = snd_hda_get_raw_connections(codec, nid, result, len);
 145         }
 146         if (len >= 0)
 147                 len = snd_hda_override_conn_list(codec, nid, len, result);
 148         if (result != list)
 149                 kfree(result);
 150         return len;
 151 }
 152
 153 /**
 154  * snd_hda_get_conn_list - get connection list
 155  * @codec: the HDA codec
 156  * @nid: NID to parse
 157  * @listp: the pointer to store NID list
 158  *
 159  * Parses the connection list of the given widget and stores the pointer
 160  * to the list of NIDs.
 161  *
 162  * Returns the number of connections, or a negative error code.
 163  *
 164  * Note that the returned pointer isn't protected against the list
 165  * modification.  If snd_hda_override_conn_list() might be called
 166  * concurrently, protect with a mutex appropriately.
 167  */
 168 int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
 169                           const hda_nid_t **listp)
 170 {
 171         bool added = false;
 172
 173         for (;;) {
 174                 int err;
 175                 const struct hda_conn_list *p;
 176
 177                 /* if the connection-list is already cached, read it */
 178                 p = lookup_conn_list(codec, nid);
 179                 if (p) {
 180                         if (listp)
 181                                 *listp = p->conns;
 182                         return p->len;
 183                 }
 184                 if (snd_BUG_ON(added))
 185                         return -EINVAL;
 186
 187                 err = read_and_add_raw_conns(codec, nid);
 188                 if (err < 0)
 189                         return err;
 190                 added = true;
 191         }
 192 }
 193 EXPORT_SYMBOL_GPL(snd_hda_get_conn_list);
 194
 195 /**
 196  * snd_hda_get_connections - copy connection list
 197  * @codec: the HDA codec
 198  * @nid: NID to parse
 199  * @conn_list: connection list array; when NULL, checks only the size
 200  * @max_conns: max. number of connections to store
 201  *
 202  * Parses the connection list of the given widget and stores the list
 203  * of NIDs.
 204  *
 205  * Returns the number of connections, or a negative error code.
 206  */
 207 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
 208                             hda_nid_t *conn_list, int max_conns)
 209 {
 210         const hda_nid_t *list;
 211         int len = snd_hda_get_conn_list(codec, nid, &list);
 212
 213         if (len > 0 && conn_list) {
 214                 if (len > max_conns) {
 215                         codec_err(codec, "Too many connections %d for NID 0x%x\n",
 216                                    len, nid);
 217                         return -EINVAL;
 218                 }
 219                 memcpy(conn_list, list, len * sizeof(hda_nid_t));
 220         }
 221
 222         return len;
 223 }
 224 EXPORT_SYMBOL_GPL(snd_hda_get_connections);
 225
 226 /**
 227  * snd_hda_override_conn_list - add/modify the connection-list to cache
 228  * @codec: the HDA codec
 229  * @nid: NID to parse
 230  * @len: number of connection list entries
 231  * @list: the list of connection entries
 232  *
 233  * Add or modify the given connection-list to the cache.  If the corresponding
 234  * cache already exists, invalidate it and append a new one.
 235  *
 236  * Returns zero or a negative error code.
 237  */
 238 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
 239                                const hda_nid_t *list)
 240 {
 241         struct hda_conn_list *p;
 242
 243         p = lookup_conn_list(codec, nid);
 244         if (p) {
 245                 list_del(&p->list);
 246                 kfree(p);
 247         }
 248
 249         return add_conn_list(codec, nid, len, list);
 250 }
 251 EXPORT_SYMBOL_GPL(snd_hda_override_conn_list);
 252
 253 /**
 254  * snd_hda_get_conn_index - get the connection index of the given NID
 255  * @codec: the HDA codec
 256  * @mux: NID containing the list
 257  * @nid: NID to select
 258  * @recursive: 1 when searching NID recursively, otherwise 0
 259  *
 260  * Parses the connection list of the widget @mux and checks whether the
 261  * widget @nid is present.  If it is, return the connection index.
 262  * Otherwise it returns -1.
 263  */
 264 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
 265                            hda_nid_t nid, int recursive)
 266 {
 267         const hda_nid_t *conn;
 268         int i, nums;
 269
 270         nums = snd_hda_get_conn_list(codec, mux, &conn);
 271         for (i = 0; i < nums; i++)
 272                 if (conn[i] == nid)
 273                         return i;
 274         if (!recursive)
 275                 return -1;
 276         if (recursive > 10) {
 277                 codec_dbg(codec, "too deep connection for 0x%x\n", nid);
 278                 return -1;
 279         }
 280         recursive++;
 281         for (i = 0; i < nums; i++) {
 282                 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
 283                 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
 284                         continue;
 285                 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
 286                         return i;
 287         }
 288         return -1;
 289 }
 290 EXPORT_SYMBOL_GPL(snd_hda_get_conn_index);
 291
 292 /**
 293  * snd_hda_get_num_devices - get DEVLIST_LEN parameter of the given widget
 294  *  @codec: the HDA codec
 295  *  @nid: NID of the pin to parse
 296  *
 297  * Get the device entry number on the given widget. This is a feature of
 298  * DP MST audio. Each pin can have several device entries in it.
 299  */
 300 unsigned int snd_hda_get_num_devices(struct hda_codec *codec, hda_nid_t nid)
 301 {
 302         unsigned int wcaps = get_wcaps(codec, nid);
 303         unsigned int parm;
 304
 305         if (!codec->dp_mst || !(wcaps & AC_WCAP_DIGITAL) ||
 306             get_wcaps_type(wcaps) != AC_WID_PIN)
 307                 return 0;
 308
 309         parm = snd_hdac_read_parm_uncached(&codec->core, nid, AC_PAR_DEVLIST_LEN);
 310         if (parm == -1)
 311                 parm = 0;
 312         return parm & AC_DEV_LIST_LEN_MASK;
 313 }
 314 EXPORT_SYMBOL_GPL(snd_hda_get_num_devices);
 315
 316 /**
 317  * snd_hda_get_devices - copy device list without cache
 318  * @codec: the HDA codec
 319  * @nid: NID of the pin to parse
 320  * @dev_list: device list array
 321  * @max_devices: max. number of devices to store
 322  *
 323  * Copy the device list. This info is dynamic and so not cached.
 324  * Currently called only from hda_proc.c, so not exported.
 325  */
 326 int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
 327                         u8 *dev_list, int max_devices)
 328 {
 329         unsigned int parm;
 330         int i, dev_len, devices;
 331
 332         parm = snd_hda_get_num_devices(codec, nid);
 333         if (!parm)      /* not multi-stream capable */
 334                 return 0;
 335
 336         dev_len = parm + 1;
 337         dev_len = dev_len < max_devices ? dev_len : max_devices;
 338
 339         devices = 0;
 340         while (devices < dev_len) {
 341                 if (snd_hdac_read(&codec->core, nid,
 342                                   AC_VERB_GET_DEVICE_LIST, devices, &parm))
 343                         break; /* error */
 344
 345                 for (i = 0; i < 8; i++) {
 346                         dev_list[devices] = (u8)parm;
 347                         parm >>= 4;
 348                         devices++;
 349                         if (devices >= dev_len)
 350                                 break;
 351                 }
 352         }
 353         return devices;
 354 }
 355
 356 /**
 357  * snd_hda_get_dev_select - get device entry select on the pin
 358  * @codec: the HDA codec
 359  * @nid: NID of the pin to get device entry select
 360  *
 361  * Get the devcie entry select on the pin. Return the device entry
 362  * id selected on the pin. Return 0 means the first device entry
 363  * is selected or MST is not supported.
 364  */
 365 int snd_hda_get_dev_select(struct hda_codec *codec, hda_nid_t nid)
 366 {
 367         /* not support dp_mst will always return 0, using first dev_entry */
 368         if (!codec->dp_mst)
 369                 return 0;
 370
 371         return snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DEVICE_SEL, 0);
 372 }
 373 EXPORT_SYMBOL_GPL(snd_hda_get_dev_select);
 374
 375 /**
 376  * snd_hda_set_dev_select - set device entry select on the pin
 377  * @codec: the HDA codec
 378  * @nid: NID of the pin to set device entry select
 379  * @dev_id: device entry id to be set
 380  *
 381  * Set the device entry select on the pin nid.
 382  */
 383 int snd_hda_set_dev_select(struct hda_codec *codec, hda_nid_t nid, int dev_id)
 384 {
 385         int ret, num_devices;
 386
 387         /* not support dp_mst will always return 0, using first dev_entry */
 388         if (!codec->dp_mst)
 389                 return 0;
 390
 391         /* AC_PAR_DEVLIST_LEN is 0 based. */
 392         num_devices = snd_hda_get_num_devices(codec, nid) + 1;
 393         /* If Device List Length is 0 (num_device = 1),
 394          * the pin is not multi stream capable.
 395          * Do nothing in this case.
 396          */
 397         if (num_devices == 1)
 398                 return 0;
 399
 400         /* Behavior of setting index being equal to or greater than
 401          * Device List Length is not predictable
 402          */
 403         if (num_devices <= dev_id)
 404                 return -EINVAL;
 405
 406         ret = snd_hda_codec_write(codec, nid, 0,
 407                         AC_VERB_SET_DEVICE_SEL, dev_id);
 408
 409         return ret;
 410 }
 411 EXPORT_SYMBOL_GPL(snd_hda_set_dev_select);
 412
 413 /*
 414  * read widget caps for each widget and store in cache
 415  */
 416 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
 417 {
 418         int i;
 419         hda_nid_t nid;
 420
 421         codec->wcaps = kmalloc_array(codec->core.num_nodes, 4, GFP_KERNEL);
 422         if (!codec->wcaps)
 423                 return -ENOMEM;
 424         nid = codec->core.start_nid;
 425         for (i = 0; i < codec->core.num_nodes; i++, nid++)
 426                 codec->wcaps[i] = snd_hdac_read_parm_uncached(&codec->core,
 427                                         nid, AC_PAR_AUDIO_WIDGET_CAP);
 428         return 0;
 429 }
 430
 431 /* read all pin default configurations and save codec->init_pins */
 432 static int read_pin_defaults(struct hda_codec *codec)
 433 {
 434         hda_nid_t nid;
 435
 436         for_each_hda_codec_node(nid, codec) {
 437                 struct hda_pincfg *pin;
 438                 unsigned int wcaps = get_wcaps(codec, nid);
 439                 unsigned int wid_type = get_wcaps_type(wcaps);
 440                 if (wid_type != AC_WID_PIN)
 441                         continue;
 442                 pin = snd_array_new(&codec->init_pins);
 443                 if (!pin)
 444                         return -ENOMEM;
 445                 pin->nid = nid;
 446                 pin->cfg = snd_hda_codec_read(codec, nid, 0,
 447                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
 448                 /*
 449                  * all device entries are the same widget control so far
 450                  * fixme: if any codec is different, need fix here
 451                  */
 452                 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
 453                                                AC_VERB_GET_PIN_WIDGET_CONTROL,
 454                                                0);
 455         }
 456         return 0;
 457 }
 458
 459 /* look up the given pin config list and return the item matching with NID */
 460 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
 461                                          struct snd_array *array,
 462                                          hda_nid_t nid)
 463 {
 464         struct hda_pincfg *pin;
 465         int i;
 466
 467         snd_array_for_each(array, i, pin) {
 468                 if (pin->nid == nid)
 469                         return pin;
 470         }
 471         return NULL;
 472 }
 473
 474 /* set the current pin config value for the given NID.
 475  * the value is cached, and read via snd_hda_codec_get_pincfg()
 476  */
 477 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
 478                        hda_nid_t nid, unsigned int cfg)
 479 {
 480         struct hda_pincfg *pin;
 481
 482         /* the check below may be invalid when pins are added by a fixup
 483          * dynamically (e.g. via snd_hda_codec_update_widgets()), so disabled
 484          * for now
 485          */
 486         /*
 487         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 488                 return -EINVAL;
 489         */
 490
 491         pin = look_up_pincfg(codec, list, nid);
 492         if (!pin) {
 493                 pin = snd_array_new(list);
 494                 if (!pin)
 495                         return -ENOMEM;
 496                 pin->nid = nid;
 497         }
 498         pin->cfg = cfg;
 499         return 0;
 500 }
 501
 502 /**
 503  * snd_hda_codec_set_pincfg - Override a pin default configuration
 504  * @codec: the HDA codec
 505  * @nid: NID to set the pin config
 506  * @cfg: the pin default config value
 507  *
 508  * Override a pin default configuration value in the cache.
 509  * This value can be read by snd_hda_codec_get_pincfg() in a higher
 510  * priority than the real hardware value.
 511  */
 512 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
 513                              hda_nid_t nid, unsigned int cfg)
 514 {
 515         return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
 516 }
 517 EXPORT_SYMBOL_GPL(snd_hda_codec_set_pincfg);
 518
 519 /**
 520  * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
 521  * @codec: the HDA codec
 522  * @nid: NID to get the pin config
 523  *
 524  * Get the current pin config value of the given pin NID.
 525  * If the pincfg value is cached or overridden via sysfs or driver,
 526  * returns the cached value.
 527  */
 528 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
 529 {
 530         struct hda_pincfg *pin;
 531
 532 #ifdef CONFIG_SND_HDA_RECONFIG
 533         {
 534                 unsigned int cfg = 0;
 535                 mutex_lock(&codec->user_mutex);
 536                 pin = look_up_pincfg(codec, &codec->user_pins, nid);
 537                 if (pin)
 538                         cfg = pin->cfg;
 539                 mutex_unlock(&codec->user_mutex);
 540                 if (cfg)
 541                         return cfg;
 542         }
 543 #endif
 544         pin = look_up_pincfg(codec, &codec->driver_pins, nid);
 545         if (pin)
 546                 return pin->cfg;
 547         pin = look_up_pincfg(codec, &codec->init_pins, nid);
 548         if (pin)
 549                 return pin->cfg;
 550         return 0;
 551 }
 552 EXPORT_SYMBOL_GPL(snd_hda_codec_get_pincfg);
 553
 554 /**
 555  * snd_hda_codec_set_pin_target - remember the current pinctl target value
 556  * @codec: the HDA codec
 557  * @nid: pin NID
 558  * @val: assigned pinctl value
 559  *
 560  * This function stores the given value to a pinctl target value in the
 561  * pincfg table.  This isn't always as same as the actually written value
 562  * but can be referred at any time via snd_hda_codec_get_pin_target().
 563  */
 564 int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
 565                                  unsigned int val)
 566 {
 567         struct hda_pincfg *pin;
 568
 569         pin = look_up_pincfg(codec, &codec->init_pins, nid);
 570         if (!pin)
 571                 return -EINVAL;
 572         pin->target = val;
 573         return 0;
 574 }
 575 EXPORT_SYMBOL_GPL(snd_hda_codec_set_pin_target);
 576
 577 /**
 578  * snd_hda_codec_get_pin_target - return the current pinctl target value
 579  * @codec: the HDA codec
 580  * @nid: pin NID
 581  */
 582 int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
 583 {
 584         struct hda_pincfg *pin;
 585
 586         pin = look_up_pincfg(codec, &codec->init_pins, nid);
 587         if (!pin)
 588                 return 0;
 589         return pin->target;
 590 }
 591 EXPORT_SYMBOL_GPL(snd_hda_codec_get_pin_target);
 592
 593 /**
 594  * snd_hda_shutup_pins - Shut up all pins
 595  * @codec: the HDA codec
 596  *
 597  * Clear all pin controls to shup up before suspend for avoiding click noise.
 598  * The controls aren't cached so that they can be resumed properly.
 599  */
 600 void snd_hda_shutup_pins(struct hda_codec *codec)
 601 {
 602         const struct hda_pincfg *pin;
 603         int i;
 604
 605         /* don't shut up pins when unloading the driver; otherwise it breaks
 606          * the default pin setup at the next load of the driver
 607          */
 608         if (codec->bus->shutdown)
 609                 return;
 610         snd_array_for_each(&codec->init_pins, i, pin) {
 611                 /* use read here for syncing after issuing each verb */
 612                 snd_hda_codec_read(codec, pin->nid, 0,
 613                                    AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
 614         }
 615         codec->pins_shutup = 1;
 616 }
 617 EXPORT_SYMBOL_GPL(snd_hda_shutup_pins);
 618
 619 #ifdef CONFIG_PM
 620 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
 621 static void restore_shutup_pins(struct hda_codec *codec)
 622 {
 623         const struct hda_pincfg *pin;
 624         int i;
 625
 626         if (!codec->pins_shutup)
 627                 return;
 628         if (codec->bus->shutdown)
 629                 return;
 630         snd_array_for_each(&codec->init_pins, i, pin) {
 631                 snd_hda_codec_write(codec, pin->nid, 0,
 632                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 633                                     pin->ctrl);
 634         }
 635         codec->pins_shutup = 0;
 636 }
 637 #endif
 638
 639 static void hda_jackpoll_work(struct work_struct *work)
 640 {
 641         struct hda_codec *codec =
 642                 container_of(work, struct hda_codec, jackpoll_work.work);
 643
 644         /* for non-polling trigger: we need nothing if already powered on */
 645         if (!codec->jackpoll_interval && snd_hdac_is_power_on(&codec->core))
 646                 return;
 647
 648         /* the power-up/down sequence triggers the runtime resume */
 649         snd_hda_power_up_pm(codec);
 650         /* update jacks manually if polling is required, too */
 651         if (codec->jackpoll_interval) {
 652                 snd_hda_jack_set_dirty_all(codec);
 653                 snd_hda_jack_poll_all(codec);
 654         }
 655         snd_hda_power_down_pm(codec);
 656
 657         if (!codec->jackpoll_interval)
 658                 return;
 659
 660         schedule_delayed_work(&codec->jackpoll_work,
 661                               codec->jackpoll_interval);
 662 }
 663
 664 /* release all pincfg lists */
 665 static void free_init_pincfgs(struct hda_codec *codec)
 666 {
 667         snd_array_free(&codec->driver_pins);
 668 #ifdef CONFIG_SND_HDA_RECONFIG
 669         snd_array_free(&codec->user_pins);
 670 #endif
 671         snd_array_free(&codec->init_pins);
 672 }
 673
 674 /*
 675  * audio-converter setup caches
 676  */
 677 struct hda_cvt_setup {
 678         hda_nid_t nid;
 679         u8 stream_tag;
 680         u8 channel_id;
 681         u16 format_id;
 682         unsigned char active;   /* cvt is currently used */
 683         unsigned char dirty;    /* setups should be cleared */
 684 };
 685
 686 /* get or create a cache entry for the given audio converter NID */
 687 static struct hda_cvt_setup *
 688 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
 689 {
 690         struct hda_cvt_setup *p;
 691         int i;
 692
 693         snd_array_for_each(&codec->cvt_setups, i, p) {
 694                 if (p->nid == nid)
 695                         return p;
 696         }
 697         p = snd_array_new(&codec->cvt_setups);
 698         if (p)
 699                 p->nid = nid;
 700         return p;
 701 }
 702
 703 /*
 704  * PCM device
 705  */
 706 void snd_hda_codec_pcm_put(struct hda_pcm *pcm)
 707 {
 708         if (refcount_dec_and_test(&pcm->codec->pcm_ref))
 709                 wake_up(&pcm->codec->remove_sleep);
 710 }
 711 EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_put);
 712
 713 struct hda_pcm *snd_hda_codec_pcm_new(struct hda_codec *codec,
 714                                       const char *fmt, ...)
 715 {
 716         struct hda_pcm *pcm;
 717         va_list args;
 718
 719         pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
 720         if (!pcm)
 721                 return NULL;
 722
 723         pcm->codec = codec;
 724         va_start(args, fmt);
 725         pcm->name = kvasprintf(GFP_KERNEL, fmt, args);
 726         va_end(args);
 727         if (!pcm->name) {
 728                 kfree(pcm);
 729                 return NULL;
 730         }
 731
 732         list_add_tail(&pcm->list, &codec->pcm_list_head);
 733         refcount_inc(&codec->pcm_ref);
 734         return pcm;
 735 }
 736 EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_new);
 737
 738 /*
 739  * codec destructor
 740  */
 741 void snd_hda_codec_disconnect_pcms(struct hda_codec *codec)
 742 {
 743         struct hda_pcm *pcm;
 744
 745         list_for_each_entry(pcm, &codec->pcm_list_head, list) {
 746                 if (pcm->disconnected)
 747                         continue;
 748                 if (pcm->pcm)
 749                         snd_device_disconnect(codec->card, pcm->pcm);
 750                 snd_hda_codec_pcm_put(pcm);
 751                 pcm->disconnected = 1;
 752         }
 753 }
 754
 755 static void codec_release_pcms(struct hda_codec *codec)
 756 {
 757         struct hda_pcm *pcm, *n;
 758
 759         list_for_each_entry_safe(pcm, n, &codec->pcm_list_head, list) {
 760                 list_del(&pcm->list);
 761                 if (pcm->pcm)
 762                         snd_device_free(pcm->codec->card, pcm->pcm);
 763                 clear_bit(pcm->device, pcm->codec->bus->pcm_dev_bits);
 764                 kfree(pcm->name);
 765                 kfree(pcm);
 766         }
 767 }
 768
 769 /**
 770  * snd_hda_codec_cleanup_for_unbind - Prepare codec for removal
 771  * @codec: codec device to cleanup
 772  */
 773 void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec)
 774 {
 775         if (codec->core.registered) {
 776                 /* pm_runtime_put() is called in snd_hdac_device_exit() */
 777                 pm_runtime_get_noresume(hda_codec_dev(codec));
 778                 pm_runtime_disable(hda_codec_dev(codec));
 779                 codec->core.registered = 0;
 780         }
 781
 782         snd_hda_codec_disconnect_pcms(codec);
 783         cancel_delayed_work_sync(&codec->jackpoll_work);
 784         if (!codec->in_freeing)
 785                 snd_hda_ctls_clear(codec);
 786         codec_release_pcms(codec);
 787         snd_hda_detach_beep_device(codec);
 788         memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
 789         snd_hda_jack_tbl_clear(codec);
 790         codec->proc_widget_hook = NULL;
 791         codec->spec = NULL;
 792
 793         /* free only driver_pins so that init_pins + user_pins are restored */
 794         snd_array_free(&codec->driver_pins);
 795         snd_array_free(&codec->cvt_setups);
 796         snd_array_free(&codec->spdif_out);
 797         snd_array_free(&codec->verbs);
 798         codec->follower_dig_outs = NULL;
 799         codec->spdif_status_reset = 0;
 800         snd_array_free(&codec->mixers);
 801         snd_array_free(&codec->nids);
 802         remove_conn_list(codec);
 803         snd_hdac_regmap_exit(&codec->core);
 804         codec->configured = 0;
 805         refcount_set(&codec->pcm_ref, 1); /* reset refcount */
 806 }
 807 EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup_for_unbind);
 808
 809 static unsigned int hda_set_power_state(struct hda_codec *codec,
 810                                 unsigned int power_state);
 811
 812 /* enable/disable display power per codec */
 813 void snd_hda_codec_display_power(struct hda_codec *codec, bool enable)
 814 {
 815         if (codec->display_power_control)
 816                 snd_hdac_display_power(&codec->bus->core, codec->addr, enable);
 817 }
 818
 819 /**
 820  * snd_hda_codec_register - Finalize codec initialization
 821  * @codec: codec device to register
 822  *
 823  * Also called from hda_bind.c
 824  */
 825 void snd_hda_codec_register(struct hda_codec *codec)
 826 {
 827         if (codec->core.registered)
 828                 return;
 829         if (device_is_registered(hda_codec_dev(codec))) {
 830                 snd_hda_codec_display_power(codec, true);
 831                 pm_runtime_enable(hda_codec_dev(codec));
 832                 /* it was powered up in snd_hda_codec_new(), now all done */
 833                 snd_hda_power_down(codec);
 834                 codec->core.registered = 1;
 835         }
 836 }
 837 EXPORT_SYMBOL_GPL(snd_hda_codec_register);
 838
 839 static int snd_hda_codec_dev_register(struct snd_device *device)
 840 {
 841         snd_hda_codec_register(device->device_data);
 842         return 0;
 843 }
 844
 845 /**
 846  * snd_hda_codec_unregister - Unregister specified codec device
 847  * @codec: codec device to unregister
 848  */
 849 void snd_hda_codec_unregister(struct hda_codec *codec)
 850 {
 851         codec->in_freeing = 1;
 852         /*
 853          * snd_hda_codec_device_new() is used by legacy HDA and ASoC driver.
 854          * We can't unregister ASoC device since it will be unregistered in
 855          * snd_hdac_ext_bus_device_remove().
 856          */
 857         if (codec->core.type == HDA_DEV_LEGACY)
 858                 snd_hdac_device_unregister(&codec->core);
 859         snd_hda_codec_display_power(codec, false);
 860
 861         /*
 862          * In the case of ASoC HD-audio bus, the device refcount is released in
 863          * snd_hdac_ext_bus_device_remove() explicitly.
 864          */
 865         if (codec->core.type == HDA_DEV_LEGACY)
 866                 put_device(hda_codec_dev(codec));
 867 }
 868 EXPORT_SYMBOL_GPL(snd_hda_codec_unregister);
 869
 870 static int snd_hda_codec_dev_free(struct snd_device *device)
 871 {
 872         snd_hda_codec_unregister(device->device_data);
 873         return 0;
 874 }
 875
 876 static void snd_hda_codec_dev_release(struct device *dev)
 877 {
 878         struct hda_codec *codec = dev_to_hda_codec(dev);
 879
 880         free_init_pincfgs(codec);
 881         snd_hdac_device_exit(&codec->core);
 882         snd_hda_sysfs_clear(codec);
 883         kfree(codec->modelname);
 884         kfree(codec->wcaps);
 885         kfree(codec);
 886 }
 887
 888 #define DEV_NAME_LEN 31
 889
 890 /**
 891  * snd_hda_codec_device_init - allocate HDA codec device
 892  * @bus: codec's parent bus
 893  * @codec_addr: the codec address on the parent bus
 894  * @fmt: format string for the device's name
 895  *
 896  * Returns newly allocated codec device or ERR_PTR() on failure.
 897  */
 898 struct hda_codec *
 899 snd_hda_codec_device_init(struct hda_bus *bus, unsigned int codec_addr,
 900                           const char *fmt, ...)
 901 {
 902         va_list vargs;
 903         char name[DEV_NAME_LEN];
 904         struct hda_codec *codec;
 905         int err;
 906
 907         if (snd_BUG_ON(!bus))
 908                 return ERR_PTR(-EINVAL);
 909         if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
 910                 return ERR_PTR(-EINVAL);
 911
 912         codec = kzalloc(sizeof(*codec), GFP_KERNEL);
 913         if (!codec)
 914                 return ERR_PTR(-ENOMEM);
 915
 916         va_start(vargs, fmt);
 917         vsprintf(name, fmt, vargs);
 918         va_end(vargs);
 919
 920         err = snd_hdac_device_init(&codec->core, &bus->core, name, codec_addr);
 921         if (err < 0) {
 922                 kfree(codec);
 923                 return ERR_PTR(err);
 924         }
 925
 926         codec->bus = bus;
 927         codec->depop_delay = -1;
 928         codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
 929         codec->core.dev.release = snd_hda_codec_dev_release;
 930         codec->core.type = HDA_DEV_LEGACY;
 931
 932         mutex_init(&codec->spdif_mutex);
 933         mutex_init(&codec->control_mutex);
 934         snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
 935         snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
 936         snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
 937         snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
 938         snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
 939         snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
 940         snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
 941         snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
 942         INIT_LIST_HEAD(&codec->conn_list);
 943         INIT_LIST_HEAD(&codec->pcm_list_head);
 944         INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
 945         refcount_set(&codec->pcm_ref, 1);
 946         init_waitqueue_head(&codec->remove_sleep);
 947
 948         return codec;
 949 }
 950 EXPORT_SYMBOL_GPL(snd_hda_codec_device_init);
 951
 952 /**
 953  * snd_hda_codec_new - create a HDA codec
 954  * @bus: the bus to assign
 955  * @card: card for this codec
 956  * @codec_addr: the codec address
 957  * @codecp: the pointer to store the generated codec
 958  *
 959  * Returns 0 if successful, or a negative error code.
 960  */
 961 int snd_hda_codec_new(struct hda_bus *bus, struct snd_card *card,
 962                       unsigned int codec_addr, struct hda_codec **codecp)
 963 {
 964         struct hda_codec *codec;
 965         int ret;
 966
 967         codec = snd_hda_codec_device_init(bus, codec_addr, "hdaudioC%dD%d",
 968                                           card->number, codec_addr);
 969         if (IS_ERR(codec))
 970                 return PTR_ERR(codec);
 971         *codecp = codec;
 972
 973         ret = snd_hda_codec_device_new(bus, card, codec_addr, *codecp, true);
 974         if (ret)
 975                 put_device(hda_codec_dev(*codecp));
 976
 977         return ret;
 978 }
 979 EXPORT_SYMBOL_GPL(snd_hda_codec_new);
 980
 981 int snd_hda_codec_device_new(struct hda_bus *bus, struct snd_card *card,
 982                         unsigned int codec_addr, struct hda_codec *codec,
 983                         bool snddev_managed)
 984 {
 985         char component[31];
 986         hda_nid_t fg;
 987         int err;
 988         static const struct snd_device_ops dev_ops = {
 989                 .dev_register = snd_hda_codec_dev_register,
 990                 .dev_free = snd_hda_codec_dev_free,
 991         };
 992
 993         dev_dbg(card->dev, "%s: entry\n", __func__);
 994
 995         if (snd_BUG_ON(!bus))
 996                 return -EINVAL;
 997         if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
 998                 return -EINVAL;
 999
1000         codec->core.exec_verb = codec_exec_verb;
1001         codec->card = card;
1002         codec->addr = codec_addr;
1003
1004 #ifdef CONFIG_PM
1005         codec->power_jiffies = jiffies;
1006 #endif
1007
1008         snd_hda_sysfs_init(codec);
1009
1010         if (codec->bus->modelname) {
1011                 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1012                 if (!codec->modelname)
1013                         return -ENOMEM;
1014         }
1015
1016         fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
1017         err = read_widget_caps(codec, fg);
1018         if (err < 0)
1019                 return err;
1020         err = read_pin_defaults(codec);
1021         if (err < 0)
1022                 return err;
1023
1024         /* power-up all before initialization */
1025         hda_set_power_state(codec, AC_PWRST_D0);
1026         codec->core.dev.power.power_state = PMSG_ON;
1027
1028         snd_hda_codec_proc_new(codec);
1029
1030         snd_hda_create_hwdep(codec);
1031
1032         sprintf(component, "HDA:%08x,%08x,%08x", codec->core.vendor_id,
1033                 codec->core.subsystem_id, codec->core.revision_id);
1034         snd_component_add(card, component);
1035
1036         if (snddev_managed) {
1037                 /* ASoC features component management instead */
1038                 err = snd_device_new(card, SNDRV_DEV_CODEC, codec, &dev_ops);
1039                 if (err < 0)
1040                         return err;
1041         }
1042
1043 #ifdef CONFIG_PM
1044         /* PM runtime needs to be enabled later after binding codec */
1045         if (codec->core.dev.power.runtime_auto)
1046                 pm_runtime_forbid(&codec->core.dev);
1047         else
1048                 /* Keep the usage_count consistent across subsequent probing */
1049                 pm_runtime_get_noresume(&codec->core.dev);
1050 #endif
1051
1052         return 0;
1053 }
1054 EXPORT_SYMBOL_GPL(snd_hda_codec_device_new);
1055
1056 /**
1057  * snd_hda_codec_update_widgets - Refresh widget caps and pin defaults
1058  * @codec: the HDA codec
1059  *
1060  * Forcibly refresh the all widget caps and the init pin configurations of
1061  * the given codec.
1062  */
1063 int snd_hda_codec_update_widgets(struct hda_codec *codec)
1064 {
1065         hda_nid_t fg;
1066         int err;
1067
1068         err = snd_hdac_refresh_widgets(&codec->core);
1069         if (err < 0)
1070                 return err;
1071
1072         /* Assume the function group node does not change,
1073          * only the widget nodes may change.
1074          */
1075         kfree(codec->wcaps);
1076         fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
1077         err = read_widget_caps(codec, fg);
1078         if (err < 0)
1079                 return err;
1080
1081         snd_array_free(&codec->init_pins);
1082         err = read_pin_defaults(codec);
1083
1084         return err;
1085 }
1086 EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets);
1087
1088 /* update the stream-id if changed */
1089 static void update_pcm_stream_id(struct hda_codec *codec,
1090                                  struct hda_cvt_setup *p, hda_nid_t nid,
1091                                  u32 stream_tag, int channel_id)
1092 {
1093         unsigned int oldval, newval;
1094
1095         if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1096                 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1097                 newval = (stream_tag << 4) | channel_id;
1098                 if (oldval != newval)
1099                         snd_hda_codec_write(codec, nid, 0,
1100                                             AC_VERB_SET_CHANNEL_STREAMID,
1101                                             newval);
1102                 p->stream_tag = stream_tag;
1103                 p->channel_id = channel_id;
1104         }
1105 }
1106
1107 /* update the format-id if changed */
1108 static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1109                               hda_nid_t nid, int format)
1110 {
1111         unsigned int oldval;
1112
1113         if (p->format_id != format) {
1114                 oldval = snd_hda_codec_read(codec, nid, 0,
1115                                             AC_VERB_GET_STREAM_FORMAT, 0);
1116                 if (oldval != format) {
1117                         msleep(1);
1118                         snd_hda_codec_write(codec, nid, 0,
1119                                             AC_VERB_SET_STREAM_FORMAT,
1120                                             format);
1121                 }
1122                 p->format_id = format;
1123         }
1124 }
1125
1126 /**
1127  * snd_hda_codec_setup_stream - set up the codec for streaming
1128  * @codec: the CODEC to set up
1129  * @nid: the NID to set up
1130  * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1131  * @channel_id: channel id to pass, zero based.
1132  * @format: stream format.
1133  */
1134 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1135                                 u32 stream_tag,
1136                                 int channel_id, int format)
1137 {
1138         struct hda_codec *c;
1139         struct hda_cvt_setup *p;
1140         int type;
1141         int i;
1142
1143         if (!nid)
1144                 return;
1145
1146         codec_dbg(codec,
1147                   "hda_codec_setup_stream: NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1148                   nid, stream_tag, channel_id, format);
1149         p = get_hda_cvt_setup(codec, nid);
1150         if (!p)
1151                 return;
1152
1153         if (codec->patch_ops.stream_pm)
1154                 codec->patch_ops.stream_pm(codec, nid, true);
1155         if (codec->pcm_format_first)
1156                 update_pcm_format(codec, p, nid, format);
1157         update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1158         if (!codec->pcm_format_first)
1159                 update_pcm_format(codec, p, nid, format);
1160
1161         p->active = 1;
1162         p->dirty = 0;
1163
1164         /* make other inactive cvts with the same stream-tag dirty */
1165         type = get_wcaps_type(get_wcaps(codec, nid));
1166         list_for_each_codec(c, codec->bus) {
1167                 snd_array_for_each(&c->cvt_setups, i, p) {
1168                         if (!p->active && p->stream_tag == stream_tag &&
1169                             get_wcaps_type(get_wcaps(c, p->nid)) == type)
1170                                 p->dirty = 1;
1171                 }
1172         }
1173 }
1174 EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream);
1175
1176 static void really_cleanup_stream(struct hda_codec *codec,
1177                                   struct hda_cvt_setup *q);
1178
1179 /**
1180  * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1181  * @codec: the CODEC to clean up
1182  * @nid: the NID to clean up
1183  * @do_now: really clean up the stream instead of clearing the active flag
1184  */
1185 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1186                                     int do_now)
1187 {
1188         struct hda_cvt_setup *p;
1189
1190         if (!nid)
1191                 return;
1192
1193         if (codec->no_sticky_stream)
1194                 do_now = 1;
1195
1196         codec_dbg(codec, "hda_codec_cleanup_stream: NID=0x%x\n", nid);
1197         p = get_hda_cvt_setup(codec, nid);
1198         if (p) {
1199                 /* here we just clear the active flag when do_now isn't set;
1200                  * actual clean-ups will be done later in
1201                  * purify_inactive_streams() called from snd_hda_codec_prpapre()
1202                  */
1203                 if (do_now)
1204                         really_cleanup_stream(codec, p);
1205                 else
1206                         p->active = 0;
1207         }
1208 }
1209 EXPORT_SYMBOL_GPL(__snd_hda_codec_cleanup_stream);
1210
1211 static void really_cleanup_stream(struct hda_codec *codec,
1212                                   struct hda_cvt_setup *q)
1213 {
1214         hda_nid_t nid = q->nid;
1215         if (q->stream_tag || q->channel_id)
1216                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1217         if (q->format_id)
1218                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1219 );
1220         memset(q, 0, sizeof(*q));
1221         q->nid = nid;
1222         if (codec->patch_ops.stream_pm)
1223                 codec->patch_ops.stream_pm(codec, nid, false);
1224 }
1225
1226 /* clean up the all conflicting obsolete streams */
1227 static void purify_inactive_streams(struct hda_codec *codec)
1228 {
1229         struct hda_codec *c;
1230         struct hda_cvt_setup *p;
1231         int i;
1232
1233         list_for_each_codec(c, codec->bus) {
1234                 snd_array_for_each(&c->cvt_setups, i, p) {
1235                         if (p->dirty)
1236                                 really_cleanup_stream(c, p);
1237                 }
1238         }
1239 }
1240
1241 #ifdef CONFIG_PM
1242 /* clean up all streams; called from suspend */
1243 static void hda_cleanup_all_streams(struct hda_codec *codec)
1244 {
1245         struct hda_cvt_setup *p;
1246         int i;
1247
1248         snd_array_for_each(&codec->cvt_setups, i, p) {
1249                 if (p->stream_tag)
1250                         really_cleanup_stream(codec, p);
1251         }
1252 }
1253 #endif
1254
1255 /*
1256  * amp access functions
1257  */
1258
1259 /**
1260  * query_amp_caps - query AMP capabilities
1261  * @codec: the HD-auio codec
1262  * @nid: the NID to query
1263  * @direction: either #HDA_INPUT or #HDA_OUTPUT
1264  *
1265  * Query AMP capabilities for the given widget and direction.
1266  * Returns the obtained capability bits.
1267  *
1268  * When cap bits have been already read, this doesn't read again but
1269  * returns the cached value.
1270  */
1271 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1272 {
1273         if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1274                 nid = codec->core.afg;
1275         return snd_hda_param_read(codec, nid,
1276                                   direction == HDA_OUTPUT ?
1277                                   AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1278 }
1279 EXPORT_SYMBOL_GPL(query_amp_caps);
1280
1281 /**
1282  * snd_hda_check_amp_caps - query AMP capabilities
1283  * @codec: the HD-audio codec
1284  * @nid: the NID to query
1285  * @dir: either #HDA_INPUT or #HDA_OUTPUT
1286  * @bits: bit mask to check the result
1287  *
1288  * Check whether the widget has the given amp capability for the direction.
1289  */
1290 bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
1291                            int dir, unsigned int bits)
1292 {
1293         if (!nid)
1294                 return false;
1295         if (get_wcaps(codec, nid) & (1 << (dir + 1)))
1296                 if (query_amp_caps(codec, nid, dir) & bits)
1297                         return true;
1298         return false;
1299 }
1300 EXPORT_SYMBOL_GPL(snd_hda_check_amp_caps);
1301
1302 /**
1303  * snd_hda_override_amp_caps - Override the AMP capabilities
1304  * @codec: the CODEC to clean up
1305  * @nid: the NID to clean up
1306  * @dir: either #HDA_INPUT or #HDA_OUTPUT
1307  * @caps: the capability bits to set
1308  *
1309  * Override the cached AMP caps bits value by the given one.
1310  * This function is useful if the driver needs to adjust the AMP ranges,
1311  * e.g. limit to 0dB, etc.
1312  *
1313  * Returns zero if successful or a negative error code.
1314  */
1315 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1316                               unsigned int caps)
1317 {
1318         unsigned int parm;
1319
1320         snd_hda_override_wcaps(codec, nid,
1321                                get_wcaps(codec, nid) | AC_WCAP_AMP_OVRD);
1322         parm = dir == HDA_OUTPUT ? AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP;
1323         return snd_hdac_override_parm(&codec->core, nid, parm, caps);
1324 }
1325 EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
1326
1327 static unsigned int encode_amp(struct hda_codec *codec, hda_nid_t nid,
1328                                int ch, int dir, int idx)
1329 {
1330         unsigned int cmd = snd_hdac_regmap_encode_amp(nid, ch, dir, idx);
1331
1332         /* enable fake mute if no h/w mute but min=mute */
1333         if ((query_amp_caps(codec, nid, dir) &
1334              (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) == AC_AMPCAP_MIN_MUTE)
1335                 cmd |= AC_AMP_FAKE_MUTE;
1336         return cmd;
1337 }
1338
1339 /**
1340  * snd_hda_codec_amp_update - update the AMP mono value
1341  * @codec: HD-audio codec
1342  * @nid: NID to read the AMP value
1343  * @ch: channel to update (0 or 1)
1344  * @dir: #HDA_INPUT or #HDA_OUTPUT
1345  * @idx: the index value (only for input direction)
1346  * @mask: bit mask to set
1347  * @val: the bits value to set
1348  *
1349  * Update the AMP values for the given channel, direction and index.
1350  */
1351 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid,
1352                              int ch, int dir, int idx, int mask, int val)
1353 {
1354         unsigned int cmd = encode_amp(codec, nid, ch, dir, idx);
1355
1356         return snd_hdac_regmap_update_raw(&codec->core, cmd, mask, val);
1357 }
1358 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update);
1359
1360 /**
1361  * snd_hda_codec_amp_stereo - update the AMP stereo values
1362  * @codec: HD-audio codec
1363  * @nid: NID to read the AMP value
1364  * @direction: #HDA_INPUT or #HDA_OUTPUT
1365  * @idx: the index value (only for input direction)
1366  * @mask: bit mask to set
1367  * @val: the bits value to set
1368  *
1369  * Update the AMP values like snd_hda_codec_amp_update(), but for a
1370  * stereo widget with the same mask and value.
1371  */
1372 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1373                              int direction, int idx, int mask, int val)
1374 {
1375         int ch, ret = 0;
1376
1377         if (snd_BUG_ON(mask & ~0xff))
1378                 mask &= 0xff;
1379         for (ch = 0; ch < 2; ch++)
1380                 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1381                                                 idx, mask, val);
1382         return ret;
1383 }
1384 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
1385
1386 /**
1387  * snd_hda_codec_amp_init - initialize the AMP value
1388  * @codec: the HDA codec
1389  * @nid: NID to read the AMP value
1390  * @ch: channel (left=0 or right=1)
1391  * @dir: #HDA_INPUT or #HDA_OUTPUT
1392  * @idx: the index value (only for input direction)
1393  * @mask: bit mask to set
1394  * @val: the bits value to set
1395  *
1396  * Works like snd_hda_codec_amp_update() but it writes the value only at
1397  * the first access.  If the amp was already initialized / updated beforehand,
1398  * this does nothing.
1399  */
1400 int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
1401                            int dir, int idx, int mask, int val)
1402 {
1403         unsigned int cmd = encode_amp(codec, nid, ch, dir, idx);
1404
1405         if (!codec->core.regmap)
1406                 return -EINVAL;
1407         return snd_hdac_regmap_update_raw_once(&codec->core, cmd, mask, val);
1408 }
1409 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init);
1410
1411 /**
1412  * snd_hda_codec_amp_init_stereo - initialize the stereo AMP value
1413  * @codec: the HDA codec
1414  * @nid: NID to read the AMP value
1415  * @dir: #HDA_INPUT or #HDA_OUTPUT
1416  * @idx: the index value (only for input direction)
1417  * @mask: bit mask to set
1418  * @val: the bits value to set
1419  *
1420  * Call snd_hda_codec_amp_init() for both stereo channels.
1421  */
1422 int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
1423                                   int dir, int idx, int mask, int val)
1424 {
1425         int ch, ret = 0;
1426
1427         if (snd_BUG_ON(mask & ~0xff))
1428                 mask &= 0xff;
1429         for (ch = 0; ch < 2; ch++)
1430                 ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
1431                                               idx, mask, val);
1432         return ret;
1433 }
1434 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo);
1435
1436 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1437                              unsigned int ofs)
1438 {
1439         u32 caps = query_amp_caps(codec, nid, dir);
1440         /* get num steps */
1441         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1442         if (ofs < caps)
1443                 caps -= ofs;
1444         return caps;
1445 }
1446
1447 /**
1448  * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1449  * @kcontrol: referred ctl element
1450  * @uinfo: pointer to get/store the data
1451  *
1452  * The control element is supposed to have the private_value field
1453  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1454  */
1455 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1456                                   struct snd_ctl_elem_info *uinfo)
1457 {
1458         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1459         u16 nid = get_amp_nid(kcontrol);
1460         u8 chs = get_amp_channels(kcontrol);
1461         int dir = get_amp_direction(kcontrol);
1462         unsigned int ofs = get_amp_offset(kcontrol);
1463
1464         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1465         uinfo->count = chs == 3 ? 2 : 1;
1466         uinfo->value.integer.min = 0;
1467         uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1468         if (!uinfo->value.integer.max) {
1469                 codec_warn(codec,
1470                            "num_steps = 0 for NID=0x%x (ctl = %s)\n",
1471                            nid, kcontrol->id.name);
1472                 return -EINVAL;
1473         }
1474         return 0;
1475 }
1476 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
1477
1478
1479 static inline unsigned int
1480 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1481                int ch, int dir, int idx, unsigned int ofs)
1482 {
1483         unsigned int val;
1484         val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1485         val &= HDA_AMP_VOLMASK;
1486         if (val >= ofs)
1487                 val -= ofs;
1488         else
1489                 val = 0;
1490         return val;
1491 }
1492
1493 static inline int
1494 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1495                  int ch, int dir, int idx, unsigned int ofs,
1496                  unsigned int val)
1497 {
1498         unsigned int maxval;
1499
1500         if (val > 0)
1501                 val += ofs;
1502         /* ofs = 0: raw max value */
1503         maxval = get_amp_max_value(codec, nid, dir, 0);
1504         if (val > maxval)
1505                 val = maxval;
1506         return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1507                                         HDA_AMP_VOLMASK, val);
1508 }
1509
1510 /**
1511  * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1512  * @kcontrol: ctl element
1513  * @ucontrol: pointer to get/store the data
1514  *
1515  * The control element is supposed to have the private_value field
1516  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1517  */
1518 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1519                                  struct snd_ctl_elem_value *ucontrol)
1520 {
1521         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1522         hda_nid_t nid = get_amp_nid(kcontrol);
1523         int chs = get_amp_channels(kcontrol);
1524         int dir = get_amp_direction(kcontrol);
1525         int idx = get_amp_index(kcontrol);
1526         unsigned int ofs = get_amp_offset(kcontrol);
1527         long *valp = ucontrol->value.integer.value;
1528
1529         if (chs & 1)
1530                 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1531         if (chs & 2)
1532                 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1533         return 0;
1534 }
1535 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
1536
1537 /**
1538  * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1539  * @kcontrol: ctl element
1540  * @ucontrol: pointer to get/store the data
1541  *
1542  * The control element is supposed to have the private_value field
1543  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1544  */
1545 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1546                                  struct snd_ctl_elem_value *ucontrol)
1547 {
1548         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1549         hda_nid_t nid = get_amp_nid(kcontrol);
1550         int chs = get_amp_channels(kcontrol);
1551         int dir = get_amp_direction(kcontrol);
1552         int idx = get_amp_index(kcontrol);
1553         unsigned int ofs = get_amp_offset(kcontrol);
1554         long *valp = ucontrol->value.integer.value;
1555         int change = 0;
1556
1557         if (chs & 1) {
1558                 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1559                 valp++;
1560         }
1561         if (chs & 2)
1562                 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1563         return change;
1564 }
1565 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
1566
1567 /* inquiry the amp caps and convert to TLV */
1568 static void get_ctl_amp_tlv(struct snd_kcontrol *kcontrol, unsigned int *tlv)
1569 {
1570         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1571         hda_nid_t nid = get_amp_nid(kcontrol);
1572         int dir = get_amp_direction(kcontrol);
1573         unsigned int ofs = get_amp_offset(kcontrol);
1574         bool min_mute = get_amp_min_mute(kcontrol);
1575         u32 caps, val1, val2;
1576
1577         caps = query_amp_caps(codec, nid, dir);
1578         val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1579         val2 = (val2 + 1) * 25;
1580         val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1581         val1 += ofs;
1582         val1 = ((int)val1) * ((int)val2);
1583         if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
1584                 val2 |= TLV_DB_SCALE_MUTE;
1585         tlv[SNDRV_CTL_TLVO_TYPE] = SNDRV_CTL_TLVT_DB_SCALE;
1586         tlv[SNDRV_CTL_TLVO_LEN] = 2 * sizeof(unsigned int);
1587         tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN] = val1;
1588         tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] = val2;
1589 }
1590
1591 /**
1592  * snd_hda_mixer_amp_tlv - TLV callback for a standard AMP mixer volume
1593  * @kcontrol: ctl element
1594  * @op_flag: operation flag
1595  * @size: byte size of input TLV
1596  * @_tlv: TLV data
1597  *
1598  * The control element is supposed to have the private_value field
1599  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1600  */
1601 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1602                           unsigned int size, unsigned int __user *_tlv)
1603 {
1604         unsigned int tlv[4];
1605
1606         if (size < 4 * sizeof(unsigned int))
1607                 return -ENOMEM;
1608         get_ctl_amp_tlv(kcontrol, tlv);
1609         if (copy_to_user(_tlv, tlv, sizeof(tlv)))
1610                 return -EFAULT;
1611         return 0;
1612 }
1613 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
1614
1615 /**
1616  * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1617  * @codec: HD-audio codec
1618  * @nid: NID of a reference widget
1619  * @dir: #HDA_INPUT or #HDA_OUTPUT
1620  * @tlv: TLV data to be stored, at least 4 elements
1621  *
1622  * Set (static) TLV data for a virtual master volume using the AMP caps
1623  * obtained from the reference NID.
1624  * The volume range is recalculated as if the max volume is 0dB.
1625  */
1626 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1627                              unsigned int *tlv)
1628 {
1629         u32 caps;
1630         int nums, step;
1631
1632         caps = query_amp_caps(codec, nid, dir);
1633         nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1634         step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1635         step = (step + 1) * 25;
1636         tlv[SNDRV_CTL_TLVO_TYPE] = SNDRV_CTL_TLVT_DB_SCALE;
1637         tlv[SNDRV_CTL_TLVO_LEN] = 2 * sizeof(unsigned int);
1638         tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN] = -nums * step;
1639         tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] = step;
1640 }
1641 EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
1642
1643 /* find a mixer control element with the given name */
1644 static struct snd_kcontrol *
1645 find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
1646 {
1647         struct snd_ctl_elem_id id;
1648         memset(&id, 0, sizeof(id));
1649         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1650         id.device = dev;
1651         id.index = idx;
1652         if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1653                 return NULL;
1654         strcpy(id.name, name);
1655         return snd_ctl_find_id(codec->card, &id);
1656 }
1657
1658 /**
1659  * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1660  * @codec: HD-audio codec
1661  * @name: ctl id name string
1662  *
1663  * Get the control element with the given id string and IFACE_MIXER.
1664  */
1665 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1666                                             const char *name)
1667 {
1668         return find_mixer_ctl(codec, name, 0, 0);
1669 }
1670 EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
1671
1672 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
1673                                     int start_idx)
1674 {
1675         int i, idx;
1676         /* 16 ctlrs should be large enough */
1677         for (i = 0, idx = start_idx; i < 16; i++, idx++) {
1678                 if (!find_mixer_ctl(codec, name, 0, idx))
1679                         return idx;
1680         }
1681         return -EBUSY;
1682 }
1683
1684 /**
1685  * snd_hda_ctl_add - Add a control element and assign to the codec
1686  * @codec: HD-audio codec
1687  * @nid: corresponding NID (optional)
1688  * @kctl: the control element to assign
1689  *
1690  * Add the given control element to an array inside the codec instance.
1691  * All control elements belonging to a codec are supposed to be added
1692  * by this function so that a proper clean-up works at the free or
1693  * reconfiguration time.
1694  *
1695  * If non-zero @nid is passed, the NID is assigned to the control element.
1696  * The assignment is shown in the codec proc file.
1697  *
1698  * snd_hda_ctl_add() checks the control subdev id field whether
1699  * #HDA_SUBDEV_NID_FLAG bit is set.  If set (and @nid is zero), the lower
1700  * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
1701  * specifies if kctl->private_value is a HDA amplifier value.
1702  */
1703 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
1704                     struct snd_kcontrol *kctl)
1705 {
1706         int err;
1707         unsigned short flags = 0;
1708         struct hda_nid_item *item;
1709
1710         if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
1711                 flags |= HDA_NID_ITEM_AMP;
1712                 if (nid == 0)
1713                         nid = get_amp_nid_(kctl->private_value);
1714         }
1715         if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
1716                 nid = kctl->id.subdevice & 0xffff;
1717         if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
1718                 kctl->id.subdevice = 0;
1719         err = snd_ctl_add(codec->card, kctl);
1720         if (err < 0)
1721                 return err;
1722         item = snd_array_new(&codec->mixers);
1723         if (!item)
1724                 return -ENOMEM;
1725         item->kctl = kctl;
1726         item->nid = nid;
1727         item->flags = flags;
1728         return 0;
1729 }
1730 EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
1731
1732 /**
1733  * snd_hda_add_nid - Assign a NID to a control element
1734  * @codec: HD-audio codec
1735  * @nid: corresponding NID (optional)
1736  * @kctl: the control element to assign
1737  * @index: index to kctl
1738  *
1739  * Add the given control element to an array inside the codec instance.
1740  * This function is used when #snd_hda_ctl_add cannot be used for 1:1
1741  * NID:KCTL mapping - for example "Capture Source" selector.
1742  */
1743 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
1744                     unsigned int index, hda_nid_t nid)
1745 {
1746         struct hda_nid_item *item;
1747
1748         if (nid > 0) {
1749                 item = snd_array_new(&codec->nids);
1750                 if (!item)
1751                         return -ENOMEM;
1752                 item->kctl = kctl;
1753                 item->index = index;
1754                 item->nid = nid;
1755                 return 0;
1756         }
1757         codec_err(codec, "no NID for mapping control %s:%d:%d\n",
1758                   kctl->id.name, kctl->id.index, index);
1759         return -EINVAL;
1760 }
1761 EXPORT_SYMBOL_GPL(snd_hda_add_nid);
1762
1763 /**
1764  * snd_hda_ctls_clear - Clear all controls assigned to the given codec
1765  * @codec: HD-audio codec
1766  */
1767 void snd_hda_ctls_clear(struct hda_codec *codec)
1768 {
1769         int i;
1770         struct hda_nid_item *items = codec->mixers.list;
1771
1772         down_write(&codec->card->controls_rwsem);
1773         for (i = 0; i < codec->mixers.used; i++)
1774                 snd_ctl_remove(codec->card, items[i].kctl);
1775         up_write(&codec->card->controls_rwsem);
1776         snd_array_free(&codec->mixers);
1777         snd_array_free(&codec->nids);
1778 }
1779
1780 /**
1781  * snd_hda_lock_devices - pseudo device locking
1782  * @bus: the BUS
1783  *
1784  * toggle card->shutdown to allow/disallow the device access (as a hack)
1785  */
1786 int snd_hda_lock_devices(struct hda_bus *bus)
1787 {
1788         struct snd_card *card = bus->card;
1789         struct hda_codec *codec;
1790
1791         spin_lock(&card->files_lock);
1792         if (card->shutdown)
1793                 goto err_unlock;
1794         card->shutdown = 1;
1795         if (!list_empty(&card->ctl_files))
1796                 goto err_clear;
1797
1798         list_for_each_codec(codec, bus) {
1799                 struct hda_pcm *cpcm;
1800                 list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
1801                         if (!cpcm->pcm)
1802                                 continue;
1803                         if (cpcm->pcm->streams[0].substream_opened ||
1804                             cpcm->pcm->streams[1].substream_opened)
1805                                 goto err_clear;
1806                 }
1807         }
1808         spin_unlock(&card->files_lock);
1809         return 0;
1810
1811  err_clear:
1812         card->shutdown = 0;
1813  err_unlock:
1814         spin_unlock(&card->files_lock);
1815         return -EINVAL;
1816 }
1817 EXPORT_SYMBOL_GPL(snd_hda_lock_devices);
1818
1819 /**
1820  * snd_hda_unlock_devices - pseudo device unlocking
1821  * @bus: the BUS
1822  */
1823 void snd_hda_unlock_devices(struct hda_bus *bus)
1824 {
1825         struct snd_card *card = bus->card;
1826
1827         spin_lock(&card->files_lock);
1828         card->shutdown = 0;
1829         spin_unlock(&card->files_lock);
1830 }
1831 EXPORT_SYMBOL_GPL(snd_hda_unlock_devices);
1832
1833 /**
1834  * snd_hda_codec_reset - Clear all objects assigned to the codec
1835  * @codec: HD-audio codec
1836  *
1837  * This frees the all PCM and control elements assigned to the codec, and
1838  * clears the caches and restores the pin default configurations.
1839  *
1840  * When a device is being used, it returns -EBSY.  If successfully freed,
1841  * returns zero.
1842  */
1843 int snd_hda_codec_reset(struct hda_codec *codec)
1844 {
1845         struct hda_bus *bus = codec->bus;
1846
1847         if (snd_hda_lock_devices(bus) < 0)
1848                 return -EBUSY;
1849
1850         /* OK, let it free */
1851         device_release_driver(hda_codec_dev(codec));
1852
1853         /* allow device access again */
1854         snd_hda_unlock_devices(bus);
1855         return 0;
1856 }
1857
1858 typedef int (*map_follower_func_t)(struct hda_codec *, void *, struct snd_kcontrol *);
1859
1860 /* apply the function to all matching follower ctls in the mixer list */
1861 static int map_followers(struct hda_codec *codec, const char * const *followers,
1862                          const char *suffix, map_follower_func_t func, void *data)
1863 {
1864         struct hda_nid_item *items;
1865         const char * const *s;
1866         int i, err;
1867
1868         items = codec->mixers.list;
1869         for (i = 0; i < codec->mixers.used; i++) {
1870                 struct snd_kcontrol *sctl = items[i].kctl;
1871                 if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
1872                         continue;
1873                 for (s = followers; *s; s++) {
1874                         char tmpname[sizeof(sctl->id.name)];
1875                         const char *name = *s;
1876                         if (suffix) {
1877                                 snprintf(tmpname, sizeof(tmpname), "%s %s",
1878                                          name, suffix);
1879                                 name = tmpname;
1880                         }
1881                         if (!strcmp(sctl->id.name, name)) {
1882                                 err = func(codec, data, sctl);
1883                                 if (err)
1884                                         return err;
1885                                 break;
1886                         }
1887                 }
1888         }
1889         return 0;
1890 }
1891
1892 static int check_follower_present(struct hda_codec *codec,
1893                                   void *data, struct snd_kcontrol *sctl)
1894 {
1895         return 1;
1896 }
1897
1898 /* call kctl->put with the given value(s) */
1899 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
1900 {
1901         struct snd_ctl_elem_value *ucontrol;
1902         ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
1903         if (!ucontrol)
1904                 return -ENOMEM;
1905         ucontrol->value.integer.value[0] = val;
1906         ucontrol->value.integer.value[1] = val;
1907         kctl->put(kctl, ucontrol);
1908         kfree(ucontrol);
1909         return 0;
1910 }
1911
1912 struct follower_init_arg {
1913         struct hda_codec *codec;
1914         int step;
1915 };
1916
1917 /* initialize the follower volume with 0dB via snd_ctl_apply_vmaster_followers() */
1918 static int init_follower_0dB(struct snd_kcontrol *follower,
1919                              struct snd_kcontrol *kctl,
1920                              void *_arg)
1921 {
1922         struct follower_init_arg *arg = _arg;
1923         int _tlv[4];
1924         const int *tlv = NULL;
1925         int step;
1926         int val;
1927
1928         if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1929                 if (kctl->tlv.c != snd_hda_mixer_amp_tlv) {
1930                         codec_err(arg->codec,
1931                                   "Unexpected TLV callback for follower %s:%d\n",
1932                                   kctl->id.name, kctl->id.index);
1933                         return 0; /* ignore */
1934                 }
1935                 get_ctl_amp_tlv(kctl, _tlv);
1936                 tlv = _tlv;
1937         } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
1938                 tlv = kctl->tlv.p;
1939
1940         if (!tlv || tlv[SNDRV_CTL_TLVO_TYPE] != SNDRV_CTL_TLVT_DB_SCALE)
1941                 return 0;
1942
1943         step = tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP];
1944         step &= ~TLV_DB_SCALE_MUTE;
1945         if (!step)
1946                 return 0;
1947         if (arg->step && arg->step != step) {
1948                 codec_err(arg->codec,
1949                           "Mismatching dB step for vmaster follower (%d!=%d)\n",
1950                           arg->step, step);
1951                 return 0;
1952         }
1953
1954         arg->step = step;
1955         val = -tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN] / step;
1956         if (val > 0) {
1957                 put_kctl_with_value(follower, val);
1958                 return val;
1959         }
1960
1961         return 0;
1962 }
1963
1964 /* unmute the follower via snd_ctl_apply_vmaster_followers() */
1965 static int init_follower_unmute(struct snd_kcontrol *follower,
1966                                 struct snd_kcontrol *kctl,
1967                                 void *_arg)
1968 {
1969         return put_kctl_with_value(follower, 1);
1970 }
1971
1972 static int add_follower(struct hda_codec *codec,
1973                         void *data, struct snd_kcontrol *follower)
1974 {
1975         return snd_ctl_add_follower(data, follower);
1976 }
1977
1978 /**
1979  * __snd_hda_add_vmaster - create a virtual master control and add followers
1980  * @codec: HD-audio codec
1981  * @name: vmaster control name
1982  * @tlv: TLV data (optional)
1983  * @followers: follower control names (optional)
1984  * @suffix: suffix string to each follower name (optional)
1985  * @init_follower_vol: initialize followers to unmute/0dB
1986  * @access: kcontrol access rights
1987  * @ctl_ret: store the vmaster kcontrol in return
1988  *
1989  * Create a virtual master control with the given name.  The TLV data
1990  * must be either NULL or a valid data.
1991  *
1992  * @followers is a NULL-terminated array of strings, each of which is a
1993  * follower control name.  All controls with these names are assigned to
1994  * the new virtual master control.
1995  *
1996  * This function returns zero if successful or a negative error code.
1997  */
1998 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1999                           unsigned int *tlv, const char * const *followers,
2000                           const char *suffix, bool init_follower_vol,
2001                           unsigned int access, struct snd_kcontrol **ctl_ret)
2002 {
2003         struct snd_kcontrol *kctl;
2004         int err;
2005
2006         if (ctl_ret)
2007                 *ctl_ret = NULL;
2008
2009         err = map_followers(codec, followers, suffix, check_follower_present, NULL);
2010         if (err != 1) {
2011                 codec_dbg(codec, "No follower found for %s\n", name);
2012                 return 0;
2013         }
2014         kctl = snd_ctl_make_virtual_master(name, tlv);
2015         if (!kctl)
2016                 return -ENOMEM;
2017         kctl->vd[0].access |= access;
2018         err = snd_hda_ctl_add(codec, 0, kctl);
2019         if (err < 0)
2020                 return err;
2021
2022         err = map_followers(codec, followers, suffix, add_follower, kctl);
2023         if (err < 0)
2024                 return err;
2025
2026         /* init with master mute & zero volume */
2027         put_kctl_with_value(kctl, 0);
2028         if (init_follower_vol) {
2029                 struct follower_init_arg arg = {
2030                         .codec = codec,
2031                         .step = 0,
2032                 };
2033                 snd_ctl_apply_vmaster_followers(kctl,
2034                                                 tlv ? init_follower_0dB : init_follower_unmute,
2035                                                 &arg);
2036         }
2037
2038         if (ctl_ret)
2039                 *ctl_ret = kctl;
2040         return 0;
2041 }
2042 EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster);
2043
2044 /* meta hook to call each driver's vmaster hook */
2045 static void vmaster_hook(void *private_data, int enabled)
2046 {
2047         struct hda_vmaster_mute_hook *hook = private_data;
2048
2049         hook->hook(hook->codec, enabled);
2050 }
2051
2052 /**
2053  * snd_hda_add_vmaster_hook - Add a vmaster hw specific hook
2054  * @codec: the HDA codec
2055  * @hook: the vmaster hook object
2056  *
2057  * Add a hw specific hook (like EAPD) with the given vmaster switch kctl.
2058  */
2059 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2060                              struct hda_vmaster_mute_hook *hook)
2061 {
2062         if (!hook->hook || !hook->sw_kctl)
2063                 return 0;
2064         hook->codec = codec;
2065         snd_ctl_add_vmaster_hook(hook->sw_kctl, vmaster_hook, hook);
2066         return 0;
2067 }
2068 EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook);
2069
2070 /**
2071  * snd_hda_sync_vmaster_hook - Sync vmaster hook
2072  * @hook: the vmaster hook
2073  *
2074  * Call the hook with the current value for synchronization.
2075  * Should be called in init callback.
2076  */
2077 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2078 {
2079         if (!hook->hook || !hook->codec)
2080                 return;
2081         /* don't call vmaster hook in the destructor since it might have
2082          * been already destroyed
2083          */
2084         if (hook->codec->bus->shutdown)
2085                 return;
2086         snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2087 }
2088 EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook);
2089
2090
2091 /**
2092  * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2093  * @kcontrol: referred ctl element
2094  * @uinfo: pointer to get/store the data
2095  *
2096  * The control element is supposed to have the private_value field
2097  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2098  */
2099 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2100                                   struct snd_ctl_elem_info *uinfo)
2101 {
2102         int chs = get_amp_channels(kcontrol);
2103
2104         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2105         uinfo->count = chs == 3 ? 2 : 1;
2106         uinfo->value.integer.min = 0;
2107         uinfo->value.integer.max = 1;
2108         return 0;
2109 }
2110 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
2111
2112 /**
2113  * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2114  * @kcontrol: ctl element
2115  * @ucontrol: pointer to get/store the data
2116  *
2117  * The control element is supposed to have the private_value field
2118  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2119  */
2120 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2121                                  struct snd_ctl_elem_value *ucontrol)
2122 {
2123         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2124         hda_nid_t nid = get_amp_nid(kcontrol);
2125         int chs = get_amp_channels(kcontrol);
2126         int dir = get_amp_direction(kcontrol);
2127         int idx = get_amp_index(kcontrol);
2128         long *valp = ucontrol->value.integer.value;
2129
2130         if (chs & 1)
2131                 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2132                            HDA_AMP_MUTE) ? 0 : 1;
2133         if (chs & 2)
2134                 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2135                          HDA_AMP_MUTE) ? 0 : 1;
2136         return 0;
2137 }
2138 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
2139
2140 /**
2141  * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2142  * @kcontrol: ctl element
2143  * @ucontrol: pointer to get/store the data
2144  *
2145  * The control element is supposed to have the private_value field
2146  * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2147  */
2148 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2149                                  struct snd_ctl_elem_value *ucontrol)
2150 {
2151         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2152         hda_nid_t nid = get_amp_nid(kcontrol);
2153         int chs = get_amp_channels(kcontrol);
2154         int dir = get_amp_direction(kcontrol);
2155         int idx = get_amp_index(kcontrol);
2156         long *valp = ucontrol->value.integer.value;
2157         int change = 0;
2158
2159         if (chs & 1) {
2160                 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2161                                                   HDA_AMP_MUTE,
2162                                                   *valp ? 0 : HDA_AMP_MUTE);
2163                 valp++;
2164         }
2165         if (chs & 2)
2166                 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2167                                                    HDA_AMP_MUTE,
2168                                                    *valp ? 0 : HDA_AMP_MUTE);
2169         hda_call_check_power_status(codec, nid);
2170         return change;
2171 }
2172 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
2173
2174 /*
2175  * SPDIF out controls
2176  */
2177
2178 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2179                                    struct snd_ctl_elem_info *uinfo)
2180 {
2181         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2182         uinfo->count = 1;
2183         return 0;
2184 }
2185
2186 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2187                                    struct snd_ctl_elem_value *ucontrol)
2188 {
2189         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2190                                            IEC958_AES0_NONAUDIO |
2191                                            IEC958_AES0_CON_EMPHASIS_5015 |
2192                                            IEC958_AES0_CON_NOT_COPYRIGHT;
2193         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2194                                            IEC958_AES1_CON_ORIGINAL;
2195         return 0;
2196 }
2197
2198 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2199                                    struct snd_ctl_elem_value *ucontrol)
2200 {
2201         ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2202                                            IEC958_AES0_NONAUDIO |
2203                                            IEC958_AES0_PRO_EMPHASIS_5015;
2204         return 0;
2205 }
2206
2207 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2208                                      struct snd_ctl_elem_value *ucontrol)
2209 {
2210         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2211         int idx = kcontrol->private_value;
2212         struct hda_spdif_out *spdif;
2213
2214         if (WARN_ON(codec->spdif_out.used <= idx))
2215                 return -EINVAL;
2216         mutex_lock(&codec->spdif_mutex);
2217         spdif = snd_array_elem(&codec->spdif_out, idx);
2218         ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2219         ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2220         ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2221         ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2222         mutex_unlock(&codec->spdif_mutex);
2223
2224         return 0;
2225 }
2226
2227 /* convert from SPDIF status bits to HDA SPDIF bits
2228  * bit 0 (DigEn) is always set zero (to be filled later)
2229  */
2230 static unsigned short convert_from_spdif_status(unsigned int sbits)
2231 {
2232         unsigned short val = 0;
2233
2234         if (sbits & IEC958_AES0_PROFESSIONAL)
2235                 val |= AC_DIG1_PROFESSIONAL;
2236         if (sbits & IEC958_AES0_NONAUDIO)
2237                 val |= AC_DIG1_NONAUDIO;
2238         if (sbits & IEC958_AES0_PROFESSIONAL) {
2239                 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2240                     IEC958_AES0_PRO_EMPHASIS_5015)
2241                         val |= AC_DIG1_EMPHASIS;
2242         } else {
2243                 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2244                     IEC958_AES0_CON_EMPHASIS_5015)
2245                         val |= AC_DIG1_EMPHASIS;
2246                 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2247                         val |= AC_DIG1_COPYRIGHT;
2248                 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2249                         val |= AC_DIG1_LEVEL;
2250                 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2251         }
2252         return val;
2253 }
2254
2255 /* convert to SPDIF status bits from HDA SPDIF bits
2256  */
2257 static unsigned int convert_to_spdif_status(unsigned short val)
2258 {
2259         unsigned int sbits = 0;
2260
2261         if (val & AC_DIG1_NONAUDIO)
2262                 sbits |= IEC958_AES0_NONAUDIO;
2263         if (val & AC_DIG1_PROFESSIONAL)
2264                 sbits |= IEC958_AES0_PROFESSIONAL;
2265         if (sbits & IEC958_AES0_PROFESSIONAL) {
2266                 if (val & AC_DIG1_EMPHASIS)
2267                         sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2268         } else {
2269                 if (val & AC_DIG1_EMPHASIS)
2270                         sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2271                 if (!(val & AC_DIG1_COPYRIGHT))
2272                         sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2273                 if (val & AC_DIG1_LEVEL)
2274                         sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2275                 sbits |= val & (0x7f << 8);
2276         }
2277         return sbits;
2278 }
2279
2280 /* set digital convert verbs both for the given NID and its followers */
2281 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2282                         int mask, int val)
2283 {
2284         const hda_nid_t *d;
2285
2286         snd_hdac_regmap_update(&codec->core, nid, AC_VERB_SET_DIGI_CONVERT_1,
2287                                mask, val);
2288         d = codec->follower_dig_outs;
2289         if (!d)
2290                 return;
2291         for (; *d; d++)
2292                 snd_hdac_regmap_update(&codec->core, *d,
2293                                        AC_VERB_SET_DIGI_CONVERT_1, mask, val);
2294 }
2295
2296 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2297                                        int dig1, int dig2)
2298 {
2299         unsigned int mask = 0;
2300         unsigned int val = 0;
2301
2302         if (dig1 != -1) {
2303                 mask |= 0xff;
2304                 val = dig1;
2305         }
2306         if (dig2 != -1) {
2307                 mask |= 0xff00;
2308                 val |= dig2 << 8;
2309         }
2310         set_dig_out(codec, nid, mask, val);
2311 }
2312
2313 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2314                                      struct snd_ctl_elem_value *ucontrol)
2315 {
2316         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2317         int idx = kcontrol->private_value;
2318         struct hda_spdif_out *spdif;
2319         hda_nid_t nid;
2320         unsigned short val;
2321         int change;
2322
2323         if (WARN_ON(codec->spdif_out.used <= idx))
2324                 return -EINVAL;
2325         mutex_lock(&codec->spdif_mutex);
2326         spdif = snd_array_elem(&codec->spdif_out, idx);
2327         nid = spdif->nid;
2328         spdif->status = ucontrol->value.iec958.status[0] |
2329                 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2330                 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2331                 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2332         val = convert_from_spdif_status(spdif->status);
2333         val |= spdif->ctls & 1;
2334         change = spdif->ctls != val;
2335         spdif->ctls = val;
2336         if (change && nid != (u16)-1)
2337                 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2338         mutex_unlock(&codec->spdif_mutex);
2339         return change;
2340 }
2341
2342 #define snd_hda_spdif_out_switch_info   snd_ctl_boolean_mono_info
2343
2344 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2345                                         struct snd_ctl_elem_value *ucontrol)
2346 {
2347         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2348         int idx = kcontrol->private_value;
2349         struct hda_spdif_out *spdif;
2350
2351         if (WARN_ON(codec->spdif_out.used <= idx))
2352                 return -EINVAL;
2353         mutex_lock(&codec->spdif_mutex);
2354         spdif = snd_array_elem(&codec->spdif_out, idx);
2355         ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
2356         mutex_unlock(&codec->spdif_mutex);
2357         return 0;
2358 }
2359
2360 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2361                                   int dig1, int dig2)
2362 {
2363         set_dig_out_convert(codec, nid, dig1, dig2);
2364         /* unmute amp switch (if any) */
2365         if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2366             (dig1 & AC_DIG1_ENABLE))
2367                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2368                                             HDA_AMP_MUTE, 0);
2369 }
2370
2371 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2372                                         struct snd_ctl_elem_value *ucontrol)
2373 {
2374         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2375         int idx = kcontrol->private_value;
2376         struct hda_spdif_out *spdif;
2377         hda_nid_t nid;
2378         unsigned short val;
2379         int change;
2380
2381         if (WARN_ON(codec->spdif_out.used <= idx))
2382                 return -EINVAL;
2383         mutex_lock(&codec->spdif_mutex);
2384         spdif = snd_array_elem(&codec->spdif_out, idx);
2385         nid = spdif->nid;
2386         val = spdif->ctls & ~AC_DIG1_ENABLE;
2387         if (ucontrol->value.integer.value[0])
2388                 val |= AC_DIG1_ENABLE;
2389         change = spdif->ctls != val;
2390         spdif->ctls = val;
2391         if (change && nid != (u16)-1)
2392                 set_spdif_ctls(codec, nid, val & 0xff, -1);
2393         mutex_unlock(&codec->spdif_mutex);
2394         return change;
2395 }
2396
2397 static const struct snd_kcontrol_new dig_mixes[] = {
2398         {
2399                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2400                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2401                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
2402                 .info = snd_hda_spdif_mask_info,
2403                 .get = snd_hda_spdif_cmask_get,
2404         },
2405         {
2406                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2407                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2408                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
2409                 .info = snd_hda_spdif_mask_info,
2410                 .get = snd_hda_spdif_pmask_get,
2411         },
2412         {
2413                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2414                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
2415                 .info = snd_hda_spdif_mask_info,
2416                 .get = snd_hda_spdif_default_get,
2417                 .put = snd_hda_spdif_default_put,
2418         },
2419         {
2420                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2421                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
2422                 .info = snd_hda_spdif_out_switch_info,
2423                 .get = snd_hda_spdif_out_switch_get,
2424                 .put = snd_hda_spdif_out_switch_put,
2425         },
2426         { } /* end */
2427 };
2428
2429 /**
2430  * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
2431  * @codec: the HDA codec
2432  * @associated_nid: NID that new ctls associated with
2433  * @cvt_nid: converter NID
2434  * @type: HDA_PCM_TYPE_*
2435  * Creates controls related with the digital output.
2436  * Called from each patch supporting the digital out.
2437  *
2438  * Returns 0 if successful, or a negative error code.
2439  */
2440 int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
2441                                 hda_nid_t associated_nid,
2442                                 hda_nid_t cvt_nid,
2443                                 int type)
2444 {
2445         int err;
2446         struct snd_kcontrol *kctl;
2447         const struct snd_kcontrol_new *dig_mix;
2448         int idx = 0;
2449         int val = 0;
2450         const int spdif_index = 16;
2451         struct hda_spdif_out *spdif;
2452         struct hda_bus *bus = codec->bus;
2453
2454         if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
2455             type == HDA_PCM_TYPE_SPDIF) {
2456                 idx = spdif_index;
2457         } else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
2458                    type == HDA_PCM_TYPE_HDMI) {
2459                 /* suppose a single SPDIF device */
2460                 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2461                         kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
2462                         if (!kctl)
2463                                 break;
2464                         kctl->id.index = spdif_index;
2465                 }
2466                 bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
2467         }
2468         if (!bus->primary_dig_out_type)
2469                 bus->primary_dig_out_type = type;
2470
2471         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
2472         if (idx < 0) {
2473                 codec_err(codec, "too many IEC958 outputs\n");
2474                 return -EBUSY;
2475         }
2476         spdif = snd_array_new(&codec->spdif_out);
2477         if (!spdif)
2478                 return -ENOMEM;
2479         for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2480                 kctl = snd_ctl_new1(dig_mix, codec);
2481                 if (!kctl)
2482                         return -ENOMEM;
2483                 kctl->id.index = idx;
2484                 kctl->private_value = codec->spdif_out.used - 1;
2485                 err = snd_hda_ctl_add(codec, associated_nid, kctl);
2486                 if (err < 0)
2487                         return err;
2488         }
2489         spdif->nid = cvt_nid;
2490         snd_hdac_regmap_read(&codec->core, cvt_nid,
2491                              AC_VERB_GET_DIGI_CONVERT_1, &val);
2492         spdif->ctls = val;
2493         spdif->status = convert_to_spdif_status(spdif->ctls);
2494         return 0;
2495 }
2496 EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls);
2497
2498 /**
2499  * snd_hda_spdif_out_of_nid - get the hda_spdif_out entry from the given NID
2500  * @codec: the HDA codec
2501  * @nid: widget NID
2502  *
2503  * call within spdif_mutex lock
2504  */
2505 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
2506                                                hda_nid_t nid)
2507 {
2508         struct hda_spdif_out *spdif;
2509         int i;
2510
2511         snd_array_for_each(&codec->spdif_out, i, spdif) {
2512                 if (spdif->nid == nid)
2513                         return spdif;
2514         }
2515         return NULL;
2516 }
2517 EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_nid);
2518
2519 /**
2520  * snd_hda_spdif_ctls_unassign - Unassign the given SPDIF ctl
2521  * @codec: the HDA codec
2522  * @idx: the SPDIF ctl index
2523  *
2524  * Unassign the widget from the given SPDIF control.
2525  */
2526 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
2527 {
2528         struct hda_spdif_out *spdif;
2529
2530         if (WARN_ON(codec->spdif_out.used <= idx))
2531                 return;
2532         mutex_lock(&codec->spdif_mutex);
2533         spdif = snd_array_elem(&codec->spdif_out, idx);
2534         spdif->nid = (u16)-1;
2535         mutex_unlock(&codec->spdif_mutex);
2536 }
2537 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
2538
2539 /**
2540  * snd_hda_spdif_ctls_assign - Assign the SPDIF controls to the given NID
2541  * @codec: the HDA codec
2542  * @idx: the SPDIF ctl idx
2543  * @nid: widget NID
2544  *
2545  * Assign the widget to the SPDIF control with the given index.
2546  */
2547 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
2548 {
2549         struct hda_spdif_out *spdif;
2550         unsigned short val;
2551
2552         if (WARN_ON(codec->spdif_out.used <= idx))
2553                 return;
2554         mutex_lock(&codec->spdif_mutex);
2555         spdif = snd_array_elem(&codec->spdif_out, idx);
2556         if (spdif->nid != nid) {
2557                 spdif->nid = nid;
2558                 val = spdif->ctls;
2559                 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
2560         }
2561         mutex_unlock(&codec->spdif_mutex);
2562 }
2563 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
2564
2565 /*
2566  * SPDIF sharing with analog output
2567  */
2568 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2569                               struct snd_ctl_elem_value *ucontrol)
2570 {
2571         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2572         ucontrol->value.integer.value[0] = mout->share_spdif;
2573         return 0;
2574 }
2575
2576 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2577                               struct snd_ctl_elem_value *ucontrol)
2578 {
2579         struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2580         mout->share_spdif = !!ucontrol->value.integer.value[0];
2581         return 0;
2582 }
2583
2584 static const struct snd_kcontrol_new spdif_share_sw = {
2585         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2586         .name = "IEC958 Default PCM Playback Switch",
2587         .info = snd_ctl_boolean_mono_info,
2588         .get = spdif_share_sw_get,
2589         .put = spdif_share_sw_put,
2590 };
2591
2592 /**
2593  * snd_hda_create_spdif_share_sw - create Default PCM switch
2594  * @codec: the HDA codec
2595  * @mout: multi-out instance
2596  */
2597 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2598                                   struct hda_multi_out *mout)
2599 {
2600         struct snd_kcontrol *kctl;
2601
2602         if (!mout->dig_out_nid)
2603                 return 0;
2604
2605         kctl = snd_ctl_new1(&spdif_share_sw, mout);
2606         if (!kctl)
2607                 return -ENOMEM;
2608         /* ATTENTION: here mout is passed as private_data, instead of codec */
2609         return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
2610 }
2611 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
2612
2613 /*
2614  * SPDIF input
2615  */
2616
2617 #define snd_hda_spdif_in_switch_info    snd_hda_spdif_out_switch_info
2618
2619 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2620                                        struct snd_ctl_elem_value *ucontrol)
2621 {
2622         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2623
2624         ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2625         return 0;
2626 }
2627
2628 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2629                                        struct snd_ctl_elem_value *ucontrol)
2630 {
2631         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2632         hda_nid_t nid = kcontrol->private_value;
2633         unsigned int val = !!ucontrol->value.integer.value[0];
2634         int change;
2635
2636         mutex_lock(&codec->spdif_mutex);
2637         change = codec->spdif_in_enable != val;
2638         if (change) {
2639                 codec->spdif_in_enable = val;
2640                 snd_hdac_regmap_write(&codec->core, nid,
2641                                       AC_VERB_SET_DIGI_CONVERT_1, val);
2642         }
2643         mutex_unlock(&codec->spdif_mutex);
2644         return change;
2645 }
2646
2647 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2648                                        struct snd_ctl_elem_value *ucontrol)
2649 {
2650         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2651         hda_nid_t nid = kcontrol->private_value;
2652         unsigned int val;
2653         unsigned int sbits;
2654
2655         snd_hdac_regmap_read(&codec->core, nid,
2656                              AC_VERB_GET_DIGI_CONVERT_1, &val);
2657         sbits = convert_to_spdif_status(val);
2658         ucontrol->value.iec958.status[0] = sbits;
2659         ucontrol->value.iec958.status[1] = sbits >> 8;
2660         ucontrol->value.iec958.status[2] = sbits >> 16;
2661         ucontrol->value.iec958.status[3] = sbits >> 24;
2662         return 0;
2663 }
2664
2665 static const struct snd_kcontrol_new dig_in_ctls[] = {
2666         {
2667                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2668                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
2669                 .info = snd_hda_spdif_in_switch_info,
2670                 .get = snd_hda_spdif_in_switch_get,
2671                 .put = snd_hda_spdif_in_switch_put,
2672         },
2673         {
2674                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2675                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2676                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
2677                 .info = snd_hda_spdif_mask_info,
2678                 .get = snd_hda_spdif_in_status_get,
2679         },
2680         { } /* end */
2681 };
2682
2683 /**
2684  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2685  * @codec: the HDA codec
2686  * @nid: audio in widget NID
2687  *
2688  * Creates controls related with the SPDIF input.
2689  * Called from each patch supporting the SPDIF in.
2690  *
2691  * Returns 0 if successful, or a negative error code.
2692  */
2693 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2694 {
2695         int err;
2696         struct snd_kcontrol *kctl;
2697         const struct snd_kcontrol_new *dig_mix;
2698         int idx;
2699
2700         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
2701         if (idx < 0) {
2702                 codec_err(codec, "too many IEC958 inputs\n");
2703                 return -EBUSY;
2704         }
2705         for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2706                 kctl = snd_ctl_new1(dig_mix, codec);
2707                 if (!kctl)
2708                         return -ENOMEM;
2709                 kctl->private_value = nid;
2710                 err = snd_hda_ctl_add(codec, nid, kctl);
2711                 if (err < 0)
2712                         return err;
2713         }
2714         codec->spdif_in_enable =
2715                 snd_hda_codec_read(codec, nid, 0,
2716                                    AC_VERB_GET_DIGI_CONVERT_1, 0) &
2717                 AC_DIG1_ENABLE;
2718         return 0;
2719 }
2720 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
2721
2722 /**
2723  * snd_hda_codec_set_power_to_all - Set the power state to all widgets
2724  * @codec: the HDA codec
2725  * @fg: function group (not used now)
2726  * @power_state: the power state to set (AC_PWRST_*)
2727  *
2728  * Set the given power state to all widgets that have the power control.
2729  * If the codec has power_filter set, it evaluates the power state and
2730  * filter out if it's unchanged as D3.
2731  */
2732 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
2733                                     unsigned int power_state)
2734 {
2735         hda_nid_t nid;
2736
2737         for_each_hda_codec_node(nid, codec) {
2738                 unsigned int wcaps = get_wcaps(codec, nid);
2739                 unsigned int state = power_state;
2740                 if (!(wcaps & AC_WCAP_POWER))
2741                         continue;
2742                 if (codec->power_filter) {
2743                         state = codec->power_filter(codec, nid, power_state);
2744                         if (state != power_state && power_state == AC_PWRST_D3)
2745                                 continue;
2746                 }
2747                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
2748                                     state);
2749         }
2750 }
2751 EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all);
2752
2753 /**
2754  * snd_hda_codec_eapd_power_filter - A power filter callback for EAPD
2755  * @codec: the HDA codec
2756  * @nid: widget NID
2757  * @power_state: power state to evalue
2758  *
2759  * Don't power down the widget if it controls eapd and EAPD_BTLENABLE is set.
2760  * This can be used a codec power_filter callback.
2761  */
2762 unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
2763                                              hda_nid_t nid,
2764                                              unsigned int power_state)
2765 {
2766         if (nid == codec->core.afg || nid == codec->core.mfg)
2767                 return power_state;
2768         if (power_state == AC_PWRST_D3 &&
2769             get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
2770             (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
2771                 int eapd = snd_hda_codec_read(codec, nid, 0,
2772                                               AC_VERB_GET_EAPD_BTLENABLE, 0);
2773                 if (eapd & 0x02)
2774                         return AC_PWRST_D0;
2775         }
2776         return power_state;
2777 }
2778 EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter);
2779
2780 /*
2781  * set power state of the codec, and return the power state
2782  */
2783 static unsigned int hda_set_power_state(struct hda_codec *codec,
2784                                         unsigned int power_state)
2785 {
2786         hda_nid_t fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
2787         int count;
2788         unsigned int state;
2789         int flags = 0;
2790
2791         /* this delay seems necessary to avoid click noise at power-down */
2792         if (power_state == AC_PWRST_D3) {
2793                 if (codec->depop_delay < 0)
2794                         msleep(codec_has_epss(codec) ? 10 : 100);
2795                 else if (codec->depop_delay > 0)
2796                         msleep(codec->depop_delay);
2797                 flags = HDA_RW_NO_RESPONSE_FALLBACK;
2798         }
2799
2800         /* repeat power states setting at most 10 times*/
2801         for (count = 0; count < 10; count++) {
2802                 if (codec->patch_ops.set_power_state)
2803                         codec->patch_ops.set_power_state(codec, fg,
2804                                                          power_state);
2805                 else {
2806                         state = power_state;
2807                         if (codec->power_filter)
2808                                 state = codec->power_filter(codec, fg, state);
2809                         if (state == power_state || power_state != AC_PWRST_D3)
2810                                 snd_hda_codec_read(codec, fg, flags,
2811                                                    AC_VERB_SET_POWER_STATE,
2812                                                    state);
2813                         snd_hda_codec_set_power_to_all(codec, fg, power_state);
2814                 }
2815                 state = snd_hda_sync_power_state(codec, fg, power_state);
2816                 if (!(state & AC_PWRST_ERROR))
2817                         break;
2818         }
2819
2820         return state;
2821 }
2822
2823 /* sync power states of all widgets;
2824  * this is called at the end of codec parsing
2825  */
2826 static void sync_power_up_states(struct hda_codec *codec)
2827 {
2828         hda_nid_t nid;
2829
2830         /* don't care if no filter is used */
2831         if (!codec->power_filter)
2832                 return;
2833
2834         for_each_hda_codec_node(nid, codec) {
2835                 unsigned int wcaps = get_wcaps(codec, nid);
2836                 unsigned int target;
2837                 if (!(wcaps & AC_WCAP_POWER))
2838                         continue;
2839                 target = codec->power_filter(codec, nid, AC_PWRST_D0);
2840                 if (target == AC_PWRST_D0)
2841                         continue;
2842                 if (!snd_hda_check_power_state(codec, nid, target))
2843                         snd_hda_codec_write(codec, nid, 0,
2844                                             AC_VERB_SET_POWER_STATE, target);
2845         }
2846 }
2847
2848 #ifdef CONFIG_SND_HDA_RECONFIG
2849 /* execute additional init verbs */
2850 static void hda_exec_init_verbs(struct hda_codec *codec)
2851 {
2852         if (codec->init_verbs.list)
2853                 snd_hda_sequence_write(codec, codec->init_verbs.list);
2854 }
2855 #else
2856 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2857 #endif
2858
2859 #ifdef CONFIG_PM
2860 /* update the power on/off account with the current jiffies */
2861 static void update_power_acct(struct hda_codec *codec, bool on)
2862 {
2863         unsigned long delta = jiffies - codec->power_jiffies;
2864
2865         if (on)
2866                 codec->power_on_acct += delta;
2867         else
2868                 codec->power_off_acct += delta;
2869         codec->power_jiffies += delta;
2870 }
2871
2872 void snd_hda_update_power_acct(struct hda_codec *codec)
2873 {
2874         update_power_acct(codec, hda_codec_is_power_on(codec));
2875 }
2876
2877 /*
2878  * call suspend and power-down; used both from PM and power-save
2879  * this function returns the power state in the end
2880  */
2881 static unsigned int hda_call_codec_suspend(struct hda_codec *codec)
2882 {
2883         unsigned int state;
2884
2885         snd_hdac_enter_pm(&codec->core);
2886         if (codec->patch_ops.suspend)
2887                 codec->patch_ops.suspend(codec);
2888         if (!codec->no_stream_clean_at_suspend)
2889                 hda_cleanup_all_streams(codec);
2890         state = hda_set_power_state(codec, AC_PWRST_D3);
2891         update_power_acct(codec, true);
2892         snd_hdac_leave_pm(&codec->core);
2893         return state;
2894 }
2895
2896 /*
2897  * kick up codec; used both from PM and power-save
2898  */
2899 static void hda_call_codec_resume(struct hda_codec *codec)
2900 {
2901         snd_hdac_enter_pm(&codec->core);
2902         if (codec->core.regmap)
2903                 regcache_mark_dirty(codec->core.regmap);
2904
2905         codec->power_jiffies = jiffies;
2906
2907         hda_set_power_state(codec, AC_PWRST_D0);
2908         restore_shutup_pins(codec);
2909         hda_exec_init_verbs(codec);
2910         snd_hda_jack_set_dirty_all(codec);
2911         if (codec->patch_ops.resume)
2912                 codec->patch_ops.resume(codec);
2913         else {
2914                 if (codec->patch_ops.init)
2915                         codec->patch_ops.init(codec);
2916                 snd_hda_regmap_sync(codec);
2917         }
2918
2919         if (codec->jackpoll_interval)
2920                 hda_jackpoll_work(&codec->jackpoll_work.work);
2921         else
2922                 snd_hda_jack_report_sync(codec);
2923         codec->core.dev.power.power_state = PMSG_ON;
2924         snd_hdac_leave_pm(&codec->core);
2925 }
2926
2927 static int hda_codec_runtime_suspend(struct device *dev)
2928 {
2929         struct hda_codec *codec = dev_to_hda_codec(dev);
2930         unsigned int state;
2931
2932         /* Nothing to do if card registration fails and the component driver never probes */
2933         if (!codec->card)
2934                 return 0;
2935
2936         cancel_delayed_work_sync(&codec->jackpoll_work);
2937
2938         state = hda_call_codec_suspend(codec);
2939         if (codec->link_down_at_suspend ||
2940             (codec_has_clkstop(codec) && codec_has_epss(codec) &&
2941              (state & AC_PWRST_CLK_STOP_OK)))
2942                 snd_hdac_codec_link_down(&codec->core);
2943         snd_hda_codec_display_power(codec, false);
2944
2945         if (codec->bus->jackpoll_in_suspend &&
2946                 (dev->power.power_state.event != PM_EVENT_SUSPEND))
2947                 schedule_delayed_work(&codec->jackpoll_work,
2948                                         codec->jackpoll_interval);
2949         return 0;
2950 }
2951
2952 static int hda_codec_runtime_resume(struct device *dev)
2953 {
2954         struct hda_codec *codec = dev_to_hda_codec(dev);
2955
2956         /* Nothing to do if card registration fails and the component driver never probes */
2957         if (!codec->card)
2958                 return 0;
2959
2960         snd_hda_codec_display_power(codec, true);
2961         snd_hdac_codec_link_up(&codec->core);
2962         hda_call_codec_resume(codec);
2963         pm_runtime_mark_last_busy(dev);
2964         return 0;
2965 }
2966
2967 #endif /* CONFIG_PM */
2968
2969 #ifdef CONFIG_PM_SLEEP
2970 static int hda_codec_pm_prepare(struct device *dev)
2971 {
2972         struct hda_codec *codec = dev_to_hda_codec(dev);
2973
2974         cancel_delayed_work_sync(&codec->jackpoll_work);
2975         dev->power.power_state = PMSG_SUSPEND;
2976         return pm_runtime_suspended(dev);
2977 }
2978
2979 static void hda_codec_pm_complete(struct device *dev)
2980 {
2981         struct hda_codec *codec = dev_to_hda_codec(dev);
2982
2983         /* If no other pm-functions are called between prepare() and complete() */
2984         if (dev->power.power_state.event == PM_EVENT_SUSPEND)
2985                 dev->power.power_state = PMSG_RESUME;
2986
2987         if (pm_runtime_suspended(dev) && (codec->jackpoll_interval ||
2988             hda_codec_need_resume(codec) || codec->forced_resume))
2989                 pm_request_resume(dev);
2990 }
2991
2992 static int hda_codec_pm_suspend(struct device *dev)
2993 {
2994         dev->power.power_state = PMSG_SUSPEND;
2995         return pm_runtime_force_suspend(dev);
2996 }
2997
2998 static int hda_codec_pm_resume(struct device *dev)
2999 {
3000         dev->power.power_state = PMSG_RESUME;
3001         return pm_runtime_force_resume(dev);
3002 }
3003
3004 static int hda_codec_pm_freeze(struct device *dev)
3005 {
3006         struct hda_codec *codec = dev_to_hda_codec(dev);
3007
3008         cancel_delayed_work_sync(&codec->jackpoll_work);
3009         dev->power.power_state = PMSG_FREEZE;
3010         return pm_runtime_force_suspend(dev);
3011 }
3012
3013 static int hda_codec_pm_thaw(struct device *dev)
3014 {
3015         dev->power.power_state = PMSG_THAW;
3016         return pm_runtime_force_resume(dev);
3017 }
3018
3019 static int hda_codec_pm_restore(struct device *dev)
3020 {
3021         dev->power.power_state = PMSG_RESTORE;
3022         return pm_runtime_force_resume(dev);
3023 }
3024 #endif /* CONFIG_PM_SLEEP */
3025
3026 /* referred in hda_bind.c */
3027 const struct dev_pm_ops hda_codec_driver_pm = {
3028 #ifdef CONFIG_PM_SLEEP
3029         .prepare = hda_codec_pm_prepare,
3030         .complete = hda_codec_pm_complete,
3031         .suspend = hda_codec_pm_suspend,
3032         .resume = hda_codec_pm_resume,
3033         .freeze = hda_codec_pm_freeze,
3034         .thaw = hda_codec_pm_thaw,
3035         .poweroff = hda_codec_pm_suspend,
3036         .restore = hda_codec_pm_restore,
3037 #endif /* CONFIG_PM_SLEEP */
3038         SET_RUNTIME_PM_OPS(hda_codec_runtime_suspend, hda_codec_runtime_resume,
3039                            NULL)
3040 };
3041
3042 /* suspend the codec at shutdown; called from driver's shutdown callback */
3043 void snd_hda_codec_shutdown(struct hda_codec *codec)
3044 {
3045         struct hda_pcm *cpcm;
3046
3047         /* Skip the shutdown if codec is not registered */
3048         if (!codec->core.registered)
3049                 return;
3050
3051         cancel_delayed_work_sync(&codec->jackpoll_work);
3052         list_for_each_entry(cpcm, &codec->pcm_list_head, list)
3053                 snd_pcm_suspend_all(cpcm->pcm);
3054
3055         pm_runtime_force_suspend(hda_codec_dev(codec));
3056         pm_runtime_disable(hda_codec_dev(codec));
3057 }
3058
3059 /*
3060  * add standard channel maps if not specified
3061  */
3062 static int add_std_chmaps(struct hda_codec *codec)
3063 {
3064         struct hda_pcm *pcm;
3065         int str, err;
3066
3067         list_for_each_entry(pcm, &codec->pcm_list_head, list) {
3068                 for (str = 0; str < 2; str++) {
3069                         struct hda_pcm_stream *hinfo = &pcm->stream[str];
3070                         struct snd_pcm_chmap *chmap;
3071                         const struct snd_pcm_chmap_elem *elem;
3072
3073                         if (!pcm->pcm || pcm->own_chmap || !hinfo->substreams)
3074                                 continue;
3075                         elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
3076                         err = snd_pcm_add_chmap_ctls(pcm->pcm, str, elem,
3077                                                      hinfo->channels_max,
3078                                                      0, &chmap);
3079                         if (err < 0)
3080                                 return err;
3081                         chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
3082                 }
3083         }
3084         return 0;
3085 }
3086
3087 /* default channel maps for 2.1 speakers;
3088  * since HD-audio supports only stereo, odd number channels are omitted
3089  */
3090 const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
3091         { .channels = 2,
3092           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
3093         { .channels = 4,
3094           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
3095                    SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
3096         { }
3097 };
3098 EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
3099
3100 int snd_hda_codec_build_controls(struct hda_codec *codec)
3101 {
3102         int err = 0;
3103         hda_exec_init_verbs(codec);
3104         /* continue to initialize... */
3105         if (codec->patch_ops.init)
3106                 err = codec->patch_ops.init(codec);
3107         if (!err && codec->patch_ops.build_controls)
3108                 err = codec->patch_ops.build_controls(codec);
3109         if (err < 0)
3110                 return err;
3111
3112         /* we create chmaps here instead of build_pcms */
3113         err = add_std_chmaps(codec);
3114         if (err < 0)
3115                 return err;
3116
3117         if (codec->jackpoll_interval)
3118                 hda_jackpoll_work(&codec->jackpoll_work.work);
3119         else
3120                 snd_hda_jack_report_sync(codec); /* call at the last init point */
3121         sync_power_up_states(codec);
3122         return 0;
3123 }
3124 EXPORT_SYMBOL_GPL(snd_hda_codec_build_controls);
3125
3126 /*
3127  * PCM stuff
3128  */
3129 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3130                                       struct hda_codec *codec,
3131                                       struct snd_pcm_substream *substream)
3132 {
3133         return 0;
3134 }
3135
3136 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3137                                    struct hda_codec *codec,
3138                                    unsigned int stream_tag,
3139                                    unsigned int format,
3140                                    struct snd_pcm_substream *substream)
3141 {
3142         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3143         return 0;
3144 }
3145
3146 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3147                                    struct hda_codec *codec,
3148                                    struct snd_pcm_substream *substream)
3149 {
3150         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3151         return 0;
3152 }
3153
3154 static int set_pcm_default_values(struct hda_codec *codec,
3155                                   struct hda_pcm_stream *info)
3156 {
3157         int err;
3158
3159         /* query support PCM information from the given NID */
3160         if (info->nid && (!info->rates || !info->formats)) {
3161                 err = snd_hda_query_supported_pcm(codec, info->nid,
3162                                 info->rates ? NULL : &info->rates,
3163                                 info->formats ? NULL : &info->formats,
3164                                 info->maxbps ? NULL : &info->maxbps);
3165                 if (err < 0)
3166                         return err;
3167         }
3168         if (info->ops.open == NULL)
3169                 info->ops.open = hda_pcm_default_open_close;
3170         if (info->ops.close == NULL)
3171                 info->ops.close = hda_pcm_default_open_close;
3172         if (info->ops.prepare == NULL) {
3173                 if (snd_BUG_ON(!info->nid))
3174                         return -EINVAL;
3175                 info->ops.prepare = hda_pcm_default_prepare;
3176         }
3177         if (info->ops.cleanup == NULL) {
3178                 if (snd_BUG_ON(!info->nid))
3179                         return -EINVAL;
3180                 info->ops.cleanup = hda_pcm_default_cleanup;
3181         }
3182         return 0;
3183 }
3184
3185 /*
3186  * codec prepare/cleanup entries
3187  */
3188 /**
3189  * snd_hda_codec_prepare - Prepare a stream
3190  * @codec: the HDA codec
3191  * @hinfo: PCM information
3192  * @stream: stream tag to assign
3193  * @format: format id to assign
3194  * @substream: PCM substream to assign
3195  *
3196  * Calls the prepare callback set by the codec with the given arguments.
3197  * Clean up the inactive streams when successful.
3198  */
3199 int snd_hda_codec_prepare(struct hda_codec *codec,
3200                           struct hda_pcm_stream *hinfo,
3201                           unsigned int stream,
3202                           unsigned int format,
3203                           struct snd_pcm_substream *substream)
3204 {
3205         int ret;
3206         mutex_lock(&codec->bus->prepare_mutex);
3207         if (hinfo->ops.prepare)
3208                 ret = hinfo->ops.prepare(hinfo, codec, stream, format,
3209                                          substream);
3210         else
3211                 ret = -ENODEV;
3212         if (ret >= 0)
3213                 purify_inactive_streams(codec);
3214         mutex_unlock(&codec->bus->prepare_mutex);
3215         return ret;
3216 }
3217 EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
3218
3219 /**
3220  * snd_hda_codec_cleanup - Clean up stream resources
3221  * @codec: the HDA codec
3222  * @hinfo: PCM information
3223  * @substream: PCM substream
3224  *
3225  * Calls the cleanup callback set by the codec with the given arguments.
3226  */
3227 void snd_hda_codec_cleanup(struct hda_codec *codec,
3228                            struct hda_pcm_stream *hinfo,
3229                            struct snd_pcm_substream *substream)
3230 {
3231         mutex_lock(&codec->bus->prepare_mutex);
3232         if (hinfo->ops.cleanup)
3233                 hinfo->ops.cleanup(hinfo, codec, substream);
3234         mutex_unlock(&codec->bus->prepare_mutex);
3235 }
3236 EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
3237
3238 /* global */
3239 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3240         "Audio", "SPDIF", "HDMI", "Modem"
3241 };
3242
3243 /*
3244  * get the empty PCM device number to assign
3245  */
3246 static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type)
3247 {
3248         /* audio device indices; not linear to keep compatibility */
3249         /* assigned to static slots up to dev#10; if more needed, assign
3250          * the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y)
3251          */
3252         static const int audio_idx[HDA_PCM_NTYPES][5] = {
3253                 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3254                 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3255                 [HDA_PCM_TYPE_HDMI]  = { 3, 7, 8, 9, -1 },
3256                 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
3257         };
3258         int i;
3259
3260         if (type >= HDA_PCM_NTYPES) {
3261                 dev_err(bus->card->dev, "Invalid PCM type %d\n", type);
3262                 return -EINVAL;
3263         }
3264
3265         for (i = 0; audio_idx[type][i] >= 0; i++) {
3266 #ifndef CONFIG_SND_DYNAMIC_MINORS
3267                 if (audio_idx[type][i] >= 8)
3268                         break;
3269 #endif
3270                 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3271                         return audio_idx[type][i];
3272         }
3273
3274 #ifdef CONFIG_SND_DYNAMIC_MINORS
3275         /* non-fixed slots starting from 10 */
3276         for (i = 10; i < 32; i++) {
3277                 if (!test_and_set_bit(i, bus->pcm_dev_bits))
3278                         return i;
3279         }
3280 #endif
3281
3282         dev_warn(bus->card->dev, "Too many %s devices\n",
3283                 snd_hda_pcm_type_name[type]);
3284 #ifndef CONFIG_SND_DYNAMIC_MINORS
3285         dev_warn(bus->card->dev,
3286                  "Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n");
3287 #endif
3288         return -EAGAIN;
3289 }
3290
3291 /* call build_pcms ops of the given codec and set up the default parameters */
3292 int snd_hda_codec_parse_pcms(struct hda_codec *codec)
3293 {
3294         struct hda_pcm *cpcm;
3295         int err;
3296
3297         if (!list_empty(&codec->pcm_list_head))
3298                 return 0; /* already parsed */
3299
3300         if (!codec->patch_ops.build_pcms)
3301                 return 0;
3302
3303         err = codec->patch_ops.build_pcms(codec);
3304         if (err < 0) {
3305                 codec_err(codec, "cannot build PCMs for #%d (error %d)\n",
3306                           codec->core.addr, err);
3307                 return err;
3308         }
3309
3310         list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
3311                 int stream;
3312
3313                 for (stream = 0; stream < 2; stream++) {
3314                         struct hda_pcm_stream *info = &cpcm->stream[stream];
3315
3316                         if (!info->substreams)
3317                                 continue;
3318                         err = set_pcm_default_values(codec, info);
3319                         if (err < 0) {
3320                                 codec_warn(codec,
3321                                            "fail to setup default for PCM %s\n",
3322                                            cpcm->name);
3323                                 return err;
3324                         }
3325                 }
3326         }
3327
3328         return 0;
3329 }
3330 EXPORT_SYMBOL_GPL(snd_hda_codec_parse_pcms);
3331
3332 /* assign all PCMs of the given codec */
3333 int snd_hda_codec_build_pcms(struct hda_codec *codec)
3334 {
3335         struct hda_bus *bus = codec->bus;
3336         struct hda_pcm *cpcm;
3337         int dev, err;
3338
3339         err = snd_hda_codec_parse_pcms(codec);
3340         if (err < 0)
3341                 return err;
3342
3343         /* attach a new PCM streams */
3344         list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
3345                 if (cpcm->pcm)
3346                         continue; /* already attached */
3347                 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
3348                         continue; /* no substreams assigned */
3349
3350                 dev = get_empty_pcm_device(bus, cpcm->pcm_type);
3351                 if (dev < 0) {
3352                         cpcm->device = SNDRV_PCM_INVALID_DEVICE;
3353                         continue; /* no fatal error */
3354                 }
3355                 cpcm->device = dev;
3356                 err =  snd_hda_attach_pcm_stream(bus, codec, cpcm);
3357                 if (err < 0) {
3358                         codec_err(codec,
3359                                   "cannot attach PCM stream %d for codec #%d\n",
3360                                   dev, codec->core.addr);
3361                         continue; /* no fatal error */
3362                 }
3363         }
3364
3365         return 0;
3366 }
3367
3368 /**
3369  * snd_hda_add_new_ctls - create controls from the array
3370  * @codec: the HDA codec
3371  * @knew: the array of struct snd_kcontrol_new
3372  *
3373  * This helper function creates and add new controls in the given array.
3374  * The array must be terminated with an empty entry as terminator.
3375  *
3376  * Returns 0 if successful, or a negative error code.
3377  */
3378 int snd_hda_add_new_ctls(struct hda_codec *codec,
3379                          const struct snd_kcontrol_new *knew)
3380 {
3381         int err;
3382
3383         for (; knew->name; knew++) {
3384                 struct snd_kcontrol *kctl;
3385                 int addr = 0, idx = 0;
3386                 if (knew->iface == (__force snd_ctl_elem_iface_t)-1)
3387                         continue; /* skip this codec private value */
3388                 for (;;) {
3389                         kctl = snd_ctl_new1(knew, codec);
3390                         if (!kctl)
3391                                 return -ENOMEM;
3392                         /* Do not use the id.device field for MIXER elements.
3393                          * This field is for real device numbers (like PCM) but codecs
3394                          * are hidden components from the user space view (unrelated
3395                          * to the mixer element identification).
3396                          */
3397                         if (addr > 0 && codec->ctl_dev_id)
3398                                 kctl->id.device = addr;
3399                         if (idx > 0)
3400                                 kctl->id.index = idx;
3401                         err = snd_hda_ctl_add(codec, 0, kctl);
3402                         if (!err)
3403                                 break;
3404                         /* try first with another device index corresponding to
3405                          * the codec addr; if it still fails (or it's the
3406                          * primary codec), then try another control index
3407                          */
3408                         if (!addr && codec->core.addr) {
3409                                 addr = codec->core.addr;
3410                                 if (!codec->ctl_dev_id)
3411                                         idx += 10 * addr;
3412                         } else if (!idx && !knew->index) {
3413                                 idx = find_empty_mixer_ctl_idx(codec,
3414                                                                knew->name, 0);
3415                                 if (idx <= 0)
3416                                         return err;
3417                         } else
3418                                 return err;
3419                 }
3420         }
3421         return 0;
3422 }
3423 EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
3424
3425 #ifdef CONFIG_PM
3426 /**
3427  * snd_hda_codec_set_power_save - Configure codec's runtime PM
3428  * @codec: codec device to configure
3429  * @delay: autosuspend delay
3430  */
3431 void snd_hda_codec_set_power_save(struct hda_codec *codec, int delay)
3432 {
3433         struct device *dev = hda_codec_dev(codec);
3434
3435         if (delay == 0 && codec->auto_runtime_pm)
3436                 delay = 3000;
3437
3438         if (delay > 0) {
3439                 pm_runtime_set_autosuspend_delay(dev, delay);
3440                 pm_runtime_use_autosuspend(dev);
3441                 pm_runtime_allow(dev);
3442                 if (!pm_runtime_suspended(dev))
3443                         pm_runtime_mark_last_busy(dev);
3444         } else {
3445                 pm_runtime_dont_use_autosuspend(dev);
3446                 pm_runtime_forbid(dev);
3447         }
3448 }
3449 EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_save);
3450
3451 /**
3452  * snd_hda_set_power_save - reprogram autosuspend for the given delay
3453  * @bus: HD-audio bus
3454  * @delay: autosuspend delay in msec, 0 = off
3455  *
3456  * Synchronize the runtime PM autosuspend state from the power_save option.
3457  */
3458 void snd_hda_set_power_save(struct hda_bus *bus, int delay)
3459 {
3460         struct hda_codec *c;
3461
3462         list_for_each_codec(c, bus)
3463                 snd_hda_codec_set_power_save(c, delay);
3464 }
3465 EXPORT_SYMBOL_GPL(snd_hda_set_power_save);
3466
3467 /**
3468  * snd_hda_check_amp_list_power - Check the amp list and update the power
3469  * @codec: HD-audio codec
3470  * @check: the object containing an AMP list and the status
3471  * @nid: NID to check / update
3472  *
3473  * Check whether the given NID is in the amp list.  If it's in the list,
3474  * check the current AMP status, and update the power-status according
3475  * to the mute status.
3476  *
3477  * This function is supposed to be set or called from the check_power_status
3478  * patch ops.
3479  */
3480 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3481                                  struct hda_loopback_check *check,
3482                                  hda_nid_t nid)
3483 {
3484         const struct hda_amp_list *p;
3485         int ch, v;
3486
3487         if (!check->amplist)
3488                 return 0;
3489         for (p = check->amplist; p->nid; p++) {
3490                 if (p->nid == nid)
3491                         break;
3492         }
3493         if (!p->nid)
3494                 return 0; /* nothing changed */
3495
3496         for (p = check->amplist; p->nid; p++) {
3497                 for (ch = 0; ch < 2; ch++) {
3498                         v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3499                                                    p->idx);
3500                         if (!(v & HDA_AMP_MUTE) && v > 0) {
3501                                 if (!check->power_on) {
3502                                         check->power_on = 1;
3503                                         snd_hda_power_up_pm(codec);
3504                                 }
3505                                 return 1;
3506                         }
3507                 }
3508         }
3509         if (check->power_on) {
3510                 check->power_on = 0;
3511                 snd_hda_power_down_pm(codec);
3512         }
3513         return 0;
3514 }
3515 EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
3516 #endif
3517
3518 /*
3519  * input MUX helper
3520  */
3521
3522 /**
3523  * snd_hda_input_mux_info - Info callback helper for the input-mux enum
3524  * @imux: imux helper object
3525  * @uinfo: pointer to get/store the data
3526  */
3527 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3528                            struct snd_ctl_elem_info *uinfo)
3529 {
3530         unsigned int index;
3531
3532         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3533         uinfo->count = 1;
3534         uinfo->value.enumerated.items = imux->num_items;
3535         if (!imux->num_items)
3536                 return 0;
3537         index = uinfo->value.enumerated.item;
3538         if (index >= imux->num_items)
3539                 index = imux->num_items - 1;
3540         strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3541         return 0;
3542 }
3543 EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
3544
3545 /**
3546  * snd_hda_input_mux_put - Put callback helper for the input-mux enum
3547  * @codec: the HDA codec
3548  * @imux: imux helper object
3549  * @ucontrol: pointer to get/store the data
3550  * @nid: input mux NID
3551  * @cur_val: pointer to get/store the current imux value
3552  */
3553 int snd_hda_input_mux_put(struct hda_codec *codec,
3554                           const struct hda_input_mux *imux,
3555                           struct snd_ctl_elem_value *ucontrol,
3556                           hda_nid_t nid,
3557                           unsigned int *cur_val)
3558 {
3559         unsigned int idx;
3560
3561         if (!imux->num_items)
3562                 return 0;
3563         idx = ucontrol->value.enumerated.item[0];
3564         if (idx >= imux->num_items)
3565                 idx = imux->num_items - 1;
3566         if (*cur_val == idx)
3567                 return 0;
3568         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3569                                   imux->items[idx].index);
3570         *cur_val = idx;
3571         return 1;
3572 }
3573 EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
3574
3575
3576 /**
3577  * snd_hda_enum_helper_info - Helper for simple enum ctls
3578  * @kcontrol: ctl element
3579  * @uinfo: pointer to get/store the data
3580  * @num_items: number of enum items
3581  * @texts: enum item string array
3582  *
3583  * process kcontrol info callback of a simple string enum array
3584  * when @num_items is 0 or @texts is NULL, assume a boolean enum array
3585  */
3586 int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
3587                              struct snd_ctl_elem_info *uinfo,
3588                              int num_items, const char * const *texts)
3589 {
3590         static const char * const texts_default[] = {
3591                 "Disabled", "Enabled"
3592         };
3593
3594         if (!texts || !num_items) {
3595                 num_items = 2;
3596                 texts = texts_default;
3597         }
3598
3599         return snd_ctl_enum_info(uinfo, 1, num_items, texts);
3600 }
3601 EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info);
3602
3603 /*
3604  * Multi-channel / digital-out PCM helper functions
3605  */
3606
3607 /* setup SPDIF output stream */
3608 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3609                                  unsigned int stream_tag, unsigned int format)
3610 {
3611         struct hda_spdif_out *spdif;
3612         unsigned int curr_fmt;
3613         bool reset;
3614
3615         spdif = snd_hda_spdif_out_of_nid(codec, nid);
3616         /* Add sanity check to pass klockwork check.
3617          * This should never happen.
3618          */
3619         if (WARN_ON(spdif == NULL))
3620                 return;
3621
3622         curr_fmt = snd_hda_codec_read(codec, nid, 0,
3623                                       AC_VERB_GET_STREAM_FORMAT, 0);
3624         reset = codec->spdif_status_reset &&
3625                 (spdif->ctls & AC_DIG1_ENABLE) &&
3626                 curr_fmt != format;
3627
3628         /* turn off SPDIF if needed; otherwise the IEC958 bits won't be
3629            updated */
3630         if (reset)
3631                 set_dig_out_convert(codec, nid,
3632                                     spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
3633                                     -1);
3634         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3635         if (codec->follower_dig_outs) {
3636                 const hda_nid_t *d;
3637                 for (d = codec->follower_dig_outs; *d; d++)
3638                         snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3639                                                    format);
3640         }
3641         /* turn on again (if needed) */
3642         if (reset)
3643                 set_dig_out_convert(codec, nid,
3644                                     spdif->ctls & 0xff, -1);
3645 }
3646
3647 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3648 {
3649         snd_hda_codec_cleanup_stream(codec, nid);
3650         if (codec->follower_dig_outs) {
3651                 const hda_nid_t *d;
3652                 for (d = codec->follower_dig_outs; *d; d++)
3653                         snd_hda_codec_cleanup_stream(codec, *d);
3654         }
3655 }
3656
3657 /**
3658  * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
3659  * @codec: the HDA codec
3660  * @mout: hda_multi_out object
3661  */
3662 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3663                                struct hda_multi_out *mout)
3664 {
3665         mutex_lock(&codec->spdif_mutex);
3666         if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3667                 /* already opened as analog dup; reset it once */
3668                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3669         mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3670         mutex_unlock(&codec->spdif_mutex);
3671         return 0;
3672 }
3673 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
3674
3675 /**
3676  * snd_hda_multi_out_dig_prepare - prepare the digital out stream
3677  * @codec: the HDA codec
3678  * @mout: hda_multi_out object
3679  * @stream_tag: stream tag to assign
3680  * @format: format id to assign
3681  * @substream: PCM substream to assign
3682  */
3683 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3684                                   struct hda_multi_out *mout,
3685                                   unsigned int stream_tag,
3686                                   unsigned int format,
3687                                   struct snd_pcm_substream *substream)
3688 {
3689         mutex_lock(&codec->spdif_mutex);
3690         setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3691         mutex_unlock(&codec->spdif_mutex);
3692         return 0;
3693 }
3694 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
3695
3696 /**
3697  * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
3698  * @codec: the HDA codec
3699  * @mout: hda_multi_out object
3700  */
3701 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3702                                   struct hda_multi_out *mout)
3703 {
3704         mutex_lock(&codec->spdif_mutex);
3705         cleanup_dig_out_stream(codec, mout->dig_out_nid);
3706         mutex_unlock(&codec->spdif_mutex);
3707         return 0;
3708 }
3709 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
3710
3711 /**
3712  * snd_hda_multi_out_dig_close - release the digital out stream
3713  * @codec: the HDA codec
3714  * @mout: hda_multi_out object
3715  */
3716 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3717                                 struct hda_multi_out *mout)
3718 {
3719         mutex_lock(&codec->spdif_mutex);
3720         mout->dig_out_used = 0;
3721         mutex_unlock(&codec->spdif_mutex);
3722         return 0;
3723 }
3724 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
3725
3726 /**
3727  * snd_hda_multi_out_analog_open - open analog outputs
3728  * @codec: the HDA codec
3729  * @mout: hda_multi_out object
3730  * @substream: PCM substream to assign
3731  * @hinfo: PCM information to assign
3732  *
3733  * Open analog outputs and set up the hw-constraints.
3734  * If the digital outputs can be opened as follower, open the digital
3735  * outputs, too.
3736  */
3737 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3738                                   struct hda_multi_out *mout,
3739                                   struct snd_pcm_substream *substream,
3740                                   struct hda_pcm_stream *hinfo)
3741 {
3742         struct snd_pcm_runtime *runtime = substream->runtime;
3743         runtime->hw.channels_max = mout->max_channels;
3744         if (mout->dig_out_nid) {
3745                 if (!mout->analog_rates) {
3746                         mout->analog_rates = hinfo->rates;
3747                         mout->analog_formats = hinfo->formats;
3748                         mout->analog_maxbps = hinfo->maxbps;
3749                 } else {
3750                         runtime->hw.rates = mout->analog_rates;
3751                         runtime->hw.formats = mout->analog_formats;
3752                         hinfo->maxbps = mout->analog_maxbps;
3753                 }
3754                 if (!mout->spdif_rates) {
3755                         snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3756                                                     &mout->spdif_rates,
3757                                                     &mout->spdif_formats,
3758                                                     &mout->spdif_maxbps);
3759                 }
3760                 mutex_lock(&codec->spdif_mutex);
3761                 if (mout->share_spdif) {
3762                         if ((runtime->hw.rates & mout->spdif_rates) &&
3763                             (runtime->hw.formats & mout->spdif_formats)) {
3764                                 runtime->hw.rates &= mout->spdif_rates;
3765                                 runtime->hw.formats &= mout->spdif_formats;
3766                                 if (mout->spdif_maxbps < hinfo->maxbps)
3767                                         hinfo->maxbps = mout->spdif_maxbps;
3768                         } else {
3769                                 mout->share_spdif = 0;
3770                                 /* FIXME: need notify? */
3771                         }
3772                 }
3773                 mutex_unlock(&codec->spdif_mutex);
3774         }
3775         return snd_pcm_hw_constraint_step(substream->runtime, 0,
3776                                           SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3777 }
3778 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
3779
3780 /**
3781  * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
3782  * @codec: the HDA codec
3783  * @mout: hda_multi_out object
3784  * @stream_tag: stream tag to assign
3785  * @format: format id to assign
3786  * @substream: PCM substream to assign
3787  *
3788  * Set up the i/o for analog out.
3789  * When the digital out is available, copy the front out to digital out, too.
3790  */
3791 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3792                                      struct hda_multi_out *mout,
3793                                      unsigned int stream_tag,
3794                                      unsigned int format,
3795                                      struct snd_pcm_substream *substream)
3796 {
3797         const hda_nid_t *nids = mout->dac_nids;
3798         int chs = substream->runtime->channels;
3799         struct hda_spdif_out *spdif;
3800         int i;
3801
3802         mutex_lock(&codec->spdif_mutex);
3803         spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
3804         if (mout->dig_out_nid && mout->share_spdif &&
3805             mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3806                 if (chs == 2 && spdif != NULL &&
3807                     snd_hda_is_supported_format(codec, mout->dig_out_nid,
3808                                                 format) &&
3809                     !(spdif->status & IEC958_AES0_NONAUDIO)) {
3810                         mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3811                         setup_dig_out_stream(codec, mout->dig_out_nid,
3812                                              stream_tag, format);
3813                 } else {
3814                         mout->dig_out_used = 0;
3815                         cleanup_dig_out_stream(codec, mout->dig_out_nid);
3816                 }
3817         }
3818         mutex_unlock(&codec->spdif_mutex);
3819
3820         /* front */
3821         snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3822                                    0, format);
3823         if (!mout->no_share_stream &&
3824             mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3825                 /* headphone out will just decode front left/right (stereo) */
3826                 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3827                                            0, format);
3828         /* extra outputs copied from front */
3829         for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
3830                 if (!mout->no_share_stream && mout->hp_out_nid[i])
3831                         snd_hda_codec_setup_stream(codec,
3832                                                    mout->hp_out_nid[i],
3833                                                    stream_tag, 0, format);
3834
3835         /* surrounds */
3836         for (i = 1; i < mout->num_dacs; i++) {
3837                 if (chs >= (i + 1) * 2) /* independent out */
3838                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3839                                                    i * 2, format);
3840                 else if (!mout->no_share_stream) /* copy front */
3841                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3842                                                    0, format);
3843         }
3844
3845         /* extra surrounds */
3846         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) {
3847                 int ch = 0;
3848                 if (!mout->extra_out_nid[i])
3849                         break;
3850                 if (chs >= (i + 1) * 2)
3851                         ch = i * 2;
3852                 else if (!mout->no_share_stream)
3853                         break;
3854                 snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i],
3855                                            stream_tag, ch, format);
3856         }
3857
3858         return 0;
3859 }
3860 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
3861
3862 /**
3863  * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
3864  * @codec: the HDA codec
3865  * @mout: hda_multi_out object
3866  */
3867 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3868                                      struct hda_multi_out *mout)
3869 {
3870         const hda_nid_t *nids = mout->dac_nids;
3871         int i;
3872
3873         for (i = 0; i < mout->num_dacs; i++)
3874                 snd_hda_codec_cleanup_stream(codec, nids[i]);
3875         if (mout->hp_nid)
3876                 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3877         for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
3878                 if (mout->hp_out_nid[i])
3879                         snd_hda_codec_cleanup_stream(codec,
3880                                                      mout->hp_out_nid[i]);
3881         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3882                 if (mout->extra_out_nid[i])
3883                         snd_hda_codec_cleanup_stream(codec,
3884                                                      mout->extra_out_nid[i]);
3885         mutex_lock(&codec->spdif_mutex);
3886         if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3887                 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3888                 mout->dig_out_used = 0;
3889         }
3890         mutex_unlock(&codec->spdif_mutex);
3891         return 0;
3892 }
3893 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
3894
3895 /**
3896  * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
3897  * @codec: the HDA codec
3898  * @pin: referred pin NID
3899  *
3900  * Guess the suitable VREF pin bits to be set as the pin-control value.
3901  * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
3902  */
3903 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
3904 {
3905         unsigned int pincap;
3906         unsigned int oldval;
3907         oldval = snd_hda_codec_read(codec, pin, 0,
3908                                     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3909         pincap = snd_hda_query_pin_caps(codec, pin);
3910         pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
3911         /* Exception: if the default pin setup is vref50, we give it priority */
3912         if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
3913                 return AC_PINCTL_VREF_80;
3914         else if (pincap & AC_PINCAP_VREF_50)
3915                 return AC_PINCTL_VREF_50;
3916         else if (pincap & AC_PINCAP_VREF_100)
3917                 return AC_PINCTL_VREF_100;
3918         else if (pincap & AC_PINCAP_VREF_GRD)
3919                 return AC_PINCTL_VREF_GRD;
3920         return AC_PINCTL_VREF_HIZ;
3921 }
3922 EXPORT_SYMBOL_GPL(snd_hda_get_default_vref);
3923
3924 /**
3925  * snd_hda_correct_pin_ctl - correct the pin ctl value for matching with the pin cap
3926  * @codec: the HDA codec
3927  * @pin: referred pin NID
3928  * @val: pin ctl value to audit
3929  */
3930 unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
3931                                      hda_nid_t pin, unsigned int val)
3932 {
3933         static const unsigned int cap_lists[][2] = {
3934                 { AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
3935                 { AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
3936                 { AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
3937                 { AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
3938         };
3939         unsigned int cap;
3940
3941         if (!val)
3942                 return 0;
3943         cap = snd_hda_query_pin_caps(codec, pin);
3944         if (!cap)
3945                 return val; /* don't know what to do... */
3946
3947         if (val & AC_PINCTL_OUT_EN) {
3948                 if (!(cap & AC_PINCAP_OUT))
3949                         val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3950                 else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
3951                         val &= ~AC_PINCTL_HP_EN;
3952         }
3953
3954         if (val & AC_PINCTL_IN_EN) {
3955                 if (!(cap & AC_PINCAP_IN))
3956                         val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
3957                 else {
3958                         unsigned int vcap, vref;
3959                         int i;
3960                         vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
3961                         vref = val & AC_PINCTL_VREFEN;
3962                         for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
3963                                 if (vref == cap_lists[i][0] &&
3964                                     !(vcap & cap_lists[i][1])) {
3965                                         if (i == ARRAY_SIZE(cap_lists) - 1)
3966                                                 vref = AC_PINCTL_VREF_HIZ;
3967                                         else
3968                                                 vref = cap_lists[i + 1][0];
3969                                 }
3970                         }
3971                         val &= ~AC_PINCTL_VREFEN;
3972                         val |= vref;
3973                 }
3974         }
3975
3976         return val;
3977 }
3978 EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl);
3979
3980 /**
3981  * _snd_hda_set_pin_ctl - Helper to set pin ctl value
3982  * @codec: the HDA codec
3983  * @pin: referred pin NID
3984  * @val: pin control value to set
3985  * @cached: access over codec pinctl cache or direct write
3986  *
3987  * This function is a helper to set a pin ctl value more safely.
3988  * It corrects the pin ctl value via snd_hda_correct_pin_ctl(), stores the
3989  * value in pin target array via snd_hda_codec_set_pin_target(), then
3990  * actually writes the value via either snd_hda_codec_write_cache() or
3991  * snd_hda_codec_write() depending on @cached flag.
3992  */
3993 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
3994                          unsigned int val, bool cached)
3995 {
3996         val = snd_hda_correct_pin_ctl(codec, pin, val);
3997         snd_hda_codec_set_pin_target(codec, pin, val);
3998         if (cached)
3999                 return snd_hda_codec_write_cache(codec, pin, 0,
4000                                 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4001         else
4002                 return snd_hda_codec_write(codec, pin, 0,
4003                                            AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4004 }
4005 EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl);
4006
4007 /**
4008  * snd_hda_add_imux_item - Add an item to input_mux
4009  * @codec: the HDA codec
4010  * @imux: imux helper object
4011  * @label: the name of imux item to assign
4012  * @index: index number of imux item to assign
4013  * @type_idx: pointer to store the resultant label index
4014  *
4015  * When the same label is used already in the existing items, the number
4016  * suffix is appended to the label.  This label index number is stored
4017  * to type_idx when non-NULL pointer is given.
4018  */
4019 int snd_hda_add_imux_item(struct hda_codec *codec,
4020                           struct hda_input_mux *imux, const char *label,
4021                           int index, int *type_idx)
4022 {
4023         int i, label_idx = 0;
4024         if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
4025                 codec_err(codec, "hda_codec: Too many imux items!\n");
4026                 return -EINVAL;
4027         }
4028         for (i = 0; i < imux->num_items; i++) {
4029                 if (!strncmp(label, imux->items[i].label, strlen(label)))
4030                         label_idx++;
4031         }
4032         if (type_idx)
4033                 *type_idx = label_idx;
4034         if (label_idx > 0)
4035                 snprintf(imux->items[imux->num_items].label,
4036                          sizeof(imux->items[imux->num_items].label),
4037                          "%s %d", label, label_idx);
4038         else
4039                 strscpy(imux->items[imux->num_items].label, label,
4040                         sizeof(imux->items[imux->num_items].label));
4041         imux->items[imux->num_items].index = index;
4042         imux->num_items++;
4043         return 0;
4044 }
4045 EXPORT_SYMBOL_GPL(snd_hda_add_imux_item);
4046
4047 /**
4048  * snd_hda_bus_reset_codecs - Reset the bus
4049  * @bus: HD-audio bus
4050  */
4051 void snd_hda_bus_reset_codecs(struct hda_bus *bus)
4052 {
4053         struct hda_codec *codec;
4054
4055         list_for_each_codec(codec, bus) {
4056                 /* FIXME: maybe a better way needed for forced reset */
4057                 if (current_work() != &codec->jackpoll_work.work)
4058                         cancel_delayed_work_sync(&codec->jackpoll_work);
4059 #ifdef CONFIG_PM
4060                 if (hda_codec_is_power_on(codec)) {
4061                         hda_call_codec_suspend(codec);
4062                         hda_call_codec_resume(codec);
4063                 }
4064 #endif
4065         }
4066 }
4067
4068 /**
4069  * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4070  * @pcm: PCM caps bits
4071  * @buf: the string buffer to write
4072  * @buflen: the max buffer length
4073  *
4074  * used by hda_proc.c and hda_eld.c
4075  */
4076 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4077 {
4078         static const unsigned int bits[] = { 8, 16, 20, 24, 32 };
4079         int i, j;
4080
4081         for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4082                 if (pcm & (AC_SUPPCM_BITS_8 << i))
4083                         j += scnprintf(buf + j, buflen - j,  " %d", bits[i]);
4084
4085         buf[j] = '\0'; /* necessary when j == 0 */
4086 }
4087 EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
4088
4089 MODULE_DESCRIPTION("HDA codec core");
4090 MODULE_LICENSE("GPL");