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