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