hda_codec.c 108.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * Universal Interface for Intel High Definition Audio Codec
 *
 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
 *
 *
 *  This driver is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This driver is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <linux/init.h>
#include <linux/delay.h>
#include <linux/slab.h>
25
#include <linux/mutex.h>
26
#include <linux/module.h>
27 28
#include <linux/pm.h>
#include <linux/pm_runtime.h>
L
Linus Torvalds 已提交
29
#include <sound/core.h>
30
#include <sound/hda_codec.h>
L
Linus Torvalds 已提交
31
#include <sound/asoundef.h>
32
#include <sound/tlv.h>
L
Linus Torvalds 已提交
33
#include <sound/initval.h>
34
#include <sound/jack.h>
L
Linus Torvalds 已提交
35
#include "hda_local.h"
36
#include "hda_beep.h"
37
#include "hda_jack.h"
38
#include <sound/hda_hwdep.h>
39
#include <sound/hda_component.h>
L
Linus Torvalds 已提交
40

41 42
#define codec_in_pm(codec)		snd_hdac_is_in_pm(&codec->core)
#define hda_codec_is_power_on(codec)	snd_hdac_is_power_on(&codec->core)
43 44 45 46 47
#define codec_has_epss(codec) \
	((codec)->core.power_caps & AC_PWRST_EPSS)
#define codec_has_clkstop(codec) \
	((codec)->core.power_caps & AC_PWRST_CLKSTOP)

48
/*
49
 * Send and receive a verb - passed to exec_verb override for hdac_device
50
 */
51 52
static int codec_exec_verb(struct hdac_device *dev, unsigned int cmd,
			   unsigned int flags, unsigned int *res)
53
{
54
	struct hda_codec *codec = container_of(dev, struct hda_codec, core);
55
	struct hda_bus *bus = codec->bus;
56
	int err;
57

58 59 60
	if (cmd == ~0)
		return -1;

61
 again:
62
	snd_hda_power_up_pm(codec);
63
	mutex_lock(&bus->core.cmd_mutex);
64 65
	if (flags & HDA_RW_NO_RESPONSE_FALLBACK)
		bus->no_response_fallback = 1;
66 67
	err = snd_hdac_bus_exec_verb_unlocked(&bus->core, codec->core.addr,
					      cmd, res);
68
	bus->no_response_fallback = 0;
69
	mutex_unlock(&bus->core.cmd_mutex);
70
	snd_hda_power_down_pm(codec);
71
	if (!codec_in_pm(codec) && res && err == -EAGAIN) {
72
		if (bus->response_reset) {
73 74
			codec_dbg(codec,
				  "resetting BUS due to fatal communication error\n");
75
			snd_hda_bus_reset(bus);
76 77 78 79
		}
		goto again;
	}
	/* clear reset-flag when the communication gets recovered */
80
	if (!err || codec_in_pm(codec))
81
		bus->response_reset = 0;
82 83 84
	return err;
}

L
Linus Torvalds 已提交
85 86 87 88 89 90 91 92 93 94 95 96 97
/**
 * snd_hda_sequence_write - sequence writes
 * @codec: the HDA codec
 * @seq: VERB array to send
 *
 * Send the commands sequentially from the given array.
 * The array must be terminated with NID=0.
 */
void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
{
	for (; seq->nid; seq++)
		snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
}
98
EXPORT_SYMBOL_GPL(snd_hda_sequence_write);
L
Linus Torvalds 已提交
99

100 101 102 103 104 105 106 107
/* connection list element */
struct hda_conn_list {
	struct list_head list;
	int len;
	hda_nid_t nid;
	hda_nid_t conns[0];
};

108
/* look up the cached results */
109 110
static struct hda_conn_list *
lookup_conn_list(struct hda_codec *codec, hda_nid_t nid)
111
{
112 113 114
	struct hda_conn_list *p;
	list_for_each_entry(p, &codec->conn_list, list) {
		if (p->nid == nid)
115 116 117 118
			return p;
	}
	return NULL;
}
119

120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
static int add_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
			 const hda_nid_t *list)
{
	struct hda_conn_list *p;

	p = kmalloc(sizeof(*p) + len * sizeof(hda_nid_t), GFP_KERNEL);
	if (!p)
		return -ENOMEM;
	p->len = len;
	p->nid = nid;
	memcpy(p->conns, list, len * sizeof(hda_nid_t));
	list_add(&p->list, &codec->conn_list);
	return 0;
}

static void remove_conn_list(struct hda_codec *codec)
{
	while (!list_empty(&codec->conn_list)) {
		struct hda_conn_list *p;
		p = list_first_entry(&codec->conn_list, typeof(*p), list);
		list_del(&p->list);
		kfree(p);
	}
}

145 146 147
/* read the connection and add to the cache */
static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
{
148 149
	hda_nid_t list[32];
	hda_nid_t *result = list;
150 151 152
	int len;

	len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
153 154
	if (len == -ENOSPC) {
		len = snd_hda_get_num_raw_conns(codec, nid);
155
		result = kmalloc_array(len, sizeof(hda_nid_t), GFP_KERNEL);
156 157 158 159 160 161 162 163 164
		if (!result)
			return -ENOMEM;
		len = snd_hda_get_raw_connections(codec, nid, result, len);
	}
	if (len >= 0)
		len = snd_hda_override_conn_list(codec, nid, len, result);
	if (result != list)
		kfree(result);
	return len;
165 166
}

167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
/**
 * snd_hda_get_conn_list - get connection list
 * @codec: the HDA codec
 * @nid: NID to parse
 * @listp: the pointer to store NID list
 *
 * Parses the connection list of the given widget and stores the pointer
 * to the list of NIDs.
 *
 * Returns the number of connections, or a negative error code.
 *
 * Note that the returned pointer isn't protected against the list
 * modification.  If snd_hda_override_conn_list() might be called
 * concurrently, protect with a mutex appropriately.
 */
int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
			  const hda_nid_t **listp)
{
	bool added = false;

	for (;;) {
		int err;
		const struct hda_conn_list *p;

		/* if the connection-list is already cached, read it */
		p = lookup_conn_list(codec, nid);
		if (p) {
			if (listp)
				*listp = p->conns;
			return p->len;
		}
		if (snd_BUG_ON(added))
			return -EINVAL;

		err = read_and_add_raw_conns(codec, nid);
		if (err < 0)
			return err;
		added = true;
	}
}
207
EXPORT_SYMBOL_GPL(snd_hda_get_conn_list);
208

L
Linus Torvalds 已提交
209
/**
210
 * snd_hda_get_connections - copy connection list
L
Linus Torvalds 已提交
211 212
 * @codec: the HDA codec
 * @nid: NID to parse
213 214
 * @conn_list: connection list array; when NULL, checks only the size
 * @max_conns: max. number of connections to store
L
Linus Torvalds 已提交
215 216 217 218 219 220
 *
 * Parses the connection list of the given widget and stores the list
 * of NIDs.
 *
 * Returns the number of connections, or a negative error code.
 */
221 222
int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
			    hda_nid_t *conn_list, int max_conns)
223
{
224 225
	const hda_nid_t *list;
	int len = snd_hda_get_conn_list(codec, nid, &list);
226

227 228
	if (len > 0 && conn_list) {
		if (len > max_conns) {
229
			codec_err(codec, "Too many connections %d for NID 0x%x\n",
230 231 232
				   len, nid);
			return -EINVAL;
		}
233
		memcpy(conn_list, list, len * sizeof(hda_nid_t));
234 235
	}

236
	return len;
237
}
238
EXPORT_SYMBOL_GPL(snd_hda_get_connections);
239

240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
/**
 * snd_hda_override_conn_list - add/modify the connection-list to cache
 * @codec: the HDA codec
 * @nid: NID to parse
 * @len: number of connection list entries
 * @list: the list of connection entries
 *
 * Add or modify the given connection-list to the cache.  If the corresponding
 * cache already exists, invalidate it and append a new one.
 *
 * Returns zero or a negative error code.
 */
int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
			       const hda_nid_t *list)
{
255
	struct hda_conn_list *p;
256

257 258 259 260 261
	p = lookup_conn_list(codec, nid);
	if (p) {
		list_del(&p->list);
		kfree(p);
	}
262

263
	return add_conn_list(codec, nid, len, list);
264
}
265
EXPORT_SYMBOL_GPL(snd_hda_override_conn_list);
266

267 268 269 270 271 272 273 274 275 276 277 278 279
/**
 * snd_hda_get_conn_index - get the connection index of the given NID
 * @codec: the HDA codec
 * @mux: NID containing the list
 * @nid: NID to select
 * @recursive: 1 when searching NID recursively, otherwise 0
 *
 * Parses the connection list of the widget @mux and checks whether the
 * widget @nid is present.  If it is, return the connection index.
 * Otherwise it returns -1.
 */
int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
			   hda_nid_t nid, int recursive)
280
{
281
	const hda_nid_t *conn;
282 283
	int i, nums;

284
	nums = snd_hda_get_conn_list(codec, mux, &conn);
285 286 287 288 289
	for (i = 0; i < nums; i++)
		if (conn[i] == nid)
			return i;
	if (!recursive)
		return -1;
290
	if (recursive > 10) {
291
		codec_dbg(codec, "too deep connection for 0x%x\n", nid);
292
		return -1;
293
	}
294
	recursive++;
295 296 297 298
	for (i = 0; i < nums; i++) {
		unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
		if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
			continue;
299 300
		if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
			return i;
301
	}
302
	return -1;
303
}
304
EXPORT_SYMBOL_GPL(snd_hda_get_conn_index);
L
Linus Torvalds 已提交
305

L
Libin Yang 已提交
306 307 308 309 310 311 312 313 314
/**
 * snd_hda_get_num_devices - get DEVLIST_LEN parameter of the given widget
 *  @codec: the HDA codec
 *  @nid: NID of the pin to parse
 *
 * Get the device entry number on the given widget. This is a feature of
 * DP MST audio. Each pin can have several device entries in it.
 */
unsigned int snd_hda_get_num_devices(struct hda_codec *codec, hda_nid_t nid)
315 316 317 318 319 320 321 322
{
	unsigned int wcaps = get_wcaps(codec, nid);
	unsigned int parm;

	if (!codec->dp_mst || !(wcaps & AC_WCAP_DIGITAL) ||
	    get_wcaps_type(wcaps) != AC_WID_PIN)
		return 0;

323
	parm = snd_hdac_read_parm_uncached(&codec->core, nid, AC_PAR_DEVLIST_LEN);
324
	if (parm == -1)
325 326 327
		parm = 0;
	return parm & AC_DEV_LIST_LEN_MASK;
}
L
Libin Yang 已提交
328
EXPORT_SYMBOL_GPL(snd_hda_get_num_devices);
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345

/**
 * snd_hda_get_devices - copy device list without cache
 * @codec: the HDA codec
 * @nid: NID of the pin to parse
 * @dev_list: device list array
 * @max_devices: max. number of devices to store
 *
 * Copy the device list. This info is dynamic and so not cached.
 * Currently called only from hda_proc.c, so not exported.
 */
int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
			u8 *dev_list, int max_devices)
{
	unsigned int parm;
	int i, dev_len, devices;

L
Libin Yang 已提交
346
	parm = snd_hda_get_num_devices(codec, nid);
347 348 349 350 351 352 353 354
	if (!parm)	/* not multi-stream capable */
		return 0;

	dev_len = parm + 1;
	dev_len = dev_len < max_devices ? dev_len : max_devices;

	devices = 0;
	while (devices < dev_len) {
355 356 357
		if (snd_hdac_read(&codec->core, nid,
				  AC_VERB_GET_DEVICE_LIST, devices, &parm))
			break; /* error */
358 359 360 361 362 363 364 365 366 367 368 369

		for (i = 0; i < 8; i++) {
			dev_list[devices] = (u8)parm;
			parm >>= 4;
			devices++;
			if (devices >= dev_len)
				break;
		}
	}
	return devices;
}

L
Libin Yang 已提交
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426
/**
 * snd_hda_get_dev_select - get device entry select on the pin
 * @codec: the HDA codec
 * @nid: NID of the pin to get device entry select
 *
 * Get the devcie entry select on the pin. Return the device entry
 * id selected on the pin. Return 0 means the first device entry
 * is selected or MST is not supported.
 */
int snd_hda_get_dev_select(struct hda_codec *codec, hda_nid_t nid)
{
	/* not support dp_mst will always return 0, using first dev_entry */
	if (!codec->dp_mst)
		return 0;

	return snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DEVICE_SEL, 0);
}
EXPORT_SYMBOL_GPL(snd_hda_get_dev_select);

/**
 * snd_hda_set_dev_select - set device entry select on the pin
 * @codec: the HDA codec
 * @nid: NID of the pin to set device entry select
 * @dev_id: device entry id to be set
 *
 * Set the device entry select on the pin nid.
 */
int snd_hda_set_dev_select(struct hda_codec *codec, hda_nid_t nid, int dev_id)
{
	int ret, num_devices;

	/* not support dp_mst will always return 0, using first dev_entry */
	if (!codec->dp_mst)
		return 0;

	/* AC_PAR_DEVLIST_LEN is 0 based. */
	num_devices = snd_hda_get_num_devices(codec, nid) + 1;
	/* If Device List Length is 0 (num_device = 1),
	 * the pin is not multi stream capable.
	 * Do nothing in this case.
	 */
	if (num_devices == 1)
		return 0;

	/* Behavior of setting index being equal to or greater than
	 * Device List Length is not predictable
	 */
	if (num_devices <= dev_id)
		return -EINVAL;

	ret = snd_hda_codec_write(codec, nid, 0,
			AC_VERB_SET_DEVICE_SEL, dev_id);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_hda_set_dev_select);

427 428 429 430 431 432 433 434
/*
 * read widget caps for each widget and store in cache
 */
static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
{
	int i;
	hda_nid_t nid;

435
	codec->wcaps = kmalloc_array(codec->core.num_nodes, 4, GFP_KERNEL);
T
Takashi Iwai 已提交
436
	if (!codec->wcaps)
437
		return -ENOMEM;
438 439
	nid = codec->core.start_nid;
	for (i = 0; i < codec->core.num_nodes; i++, nid++)
440 441
		codec->wcaps[i] = snd_hdac_read_parm_uncached(&codec->core,
					nid, AC_PAR_AUDIO_WIDGET_CAP);
442 443 444
	return 0;
}

445 446 447
/* read all pin default configurations and save codec->init_pins */
static int read_pin_defaults(struct hda_codec *codec)
{
448
	hda_nid_t nid;
449

450
	for_each_hda_codec_node(nid, codec) {
451 452
		struct hda_pincfg *pin;
		unsigned int wcaps = get_wcaps(codec, nid);
453
		unsigned int wid_type = get_wcaps_type(wcaps);
454 455 456 457 458 459 460 461
		if (wid_type != AC_WID_PIN)
			continue;
		pin = snd_array_new(&codec->init_pins);
		if (!pin)
			return -ENOMEM;
		pin->nid = nid;
		pin->cfg = snd_hda_codec_read(codec, nid, 0,
					      AC_VERB_GET_CONFIG_DEFAULT, 0);
462 463 464 465
		/*
		 * all device entries are the same widget control so far
		 * fixme: if any codec is different, need fix here
		 */
466 467 468
		pin->ctrl = snd_hda_codec_read(codec, nid, 0,
					       AC_VERB_GET_PIN_WIDGET_CONTROL,
					       0);
469 470 471 472 473 474 475 476 477
	}
	return 0;
}

/* look up the given pin config list and return the item matching with NID */
static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
					 struct snd_array *array,
					 hda_nid_t nid)
{
478
	struct hda_pincfg *pin;
479
	int i;
480 481

	snd_array_for_each(array, i, pin) {
482 483 484 485 486 487 488 489 490 491 492 493 494 495
		if (pin->nid == nid)
			return pin;
	}
	return NULL;
}

/* set the current pin config value for the given NID.
 * the value is cached, and read via snd_hda_codec_get_pincfg()
 */
int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
		       hda_nid_t nid, unsigned int cfg)
{
	struct hda_pincfg *pin;

496 497 498 499 500
	/* the check below may be invalid when pins are added by a fixup
	 * dynamically (e.g. via snd_hda_codec_update_widgets()), so disabled
	 * for now
	 */
	/*
501 502
	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
		return -EINVAL;
503
	*/
504

505 506 507 508 509 510 511 512 513 514 515
	pin = look_up_pincfg(codec, list, nid);
	if (!pin) {
		pin = snd_array_new(list);
		if (!pin)
			return -ENOMEM;
		pin->nid = nid;
	}
	pin->cfg = cfg;
	return 0;
}

516 517 518 519 520 521 522 523 524 525
/**
 * snd_hda_codec_set_pincfg - Override a pin default configuration
 * @codec: the HDA codec
 * @nid: NID to set the pin config
 * @cfg: the pin default config value
 *
 * Override a pin default configuration value in the cache.
 * This value can be read by snd_hda_codec_get_pincfg() in a higher
 * priority than the real hardware value.
 */
526 527 528
int snd_hda_codec_set_pincfg(struct hda_codec *codec,
			     hda_nid_t nid, unsigned int cfg)
{
529
	return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
530
}
531
EXPORT_SYMBOL_GPL(snd_hda_codec_set_pincfg);
532

533 534 535 536 537 538 539 540 541
/**
 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
 * @codec: the HDA codec
 * @nid: NID to get the pin config
 *
 * Get the current pin config value of the given pin NID.
 * If the pincfg value is cached or overridden via sysfs or driver,
 * returns the cached value.
 */
542 543 544 545
unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
{
	struct hda_pincfg *pin;

546
#ifdef CONFIG_SND_HDA_RECONFIG
547 548 549 550 551 552 553 554 555 556
	{
		unsigned int cfg = 0;
		mutex_lock(&codec->user_mutex);
		pin = look_up_pincfg(codec, &codec->user_pins, nid);
		if (pin)
			cfg = pin->cfg;
		mutex_unlock(&codec->user_mutex);
		if (cfg)
			return cfg;
	}
557
#endif
558 559 560
	pin = look_up_pincfg(codec, &codec->driver_pins, nid);
	if (pin)
		return pin->cfg;
561 562 563 564 565
	pin = look_up_pincfg(codec, &codec->init_pins, nid);
	if (pin)
		return pin->cfg;
	return 0;
}
566
EXPORT_SYMBOL_GPL(snd_hda_codec_get_pincfg);
567

T
Takashi Iwai 已提交
568 569 570 571 572 573 574 575 576 577
/**
 * snd_hda_codec_set_pin_target - remember the current pinctl target value
 * @codec: the HDA codec
 * @nid: pin NID
 * @val: assigned pinctl value
 *
 * This function stores the given value to a pinctl target value in the
 * pincfg table.  This isn't always as same as the actually written value
 * but can be referred at any time via snd_hda_codec_get_pin_target().
 */
578 579 580 581 582 583 584 585 586 587 588
int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
				 unsigned int val)
{
	struct hda_pincfg *pin;

	pin = look_up_pincfg(codec, &codec->init_pins, nid);
	if (!pin)
		return -EINVAL;
	pin->target = val;
	return 0;
}
589
EXPORT_SYMBOL_GPL(snd_hda_codec_set_pin_target);
590

T
Takashi Iwai 已提交
591 592 593 594 595
/**
 * snd_hda_codec_get_pin_target - return the current pinctl target value
 * @codec: the HDA codec
 * @nid: pin NID
 */
596 597 598 599 600 601 602 603 604
int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
{
	struct hda_pincfg *pin;

	pin = look_up_pincfg(codec, &codec->init_pins, nid);
	if (!pin)
		return 0;
	return pin->target;
}
605
EXPORT_SYMBOL_GPL(snd_hda_codec_get_pin_target);
606

607 608 609 610 611 612 613 614 615
/**
 * snd_hda_shutup_pins - Shut up all pins
 * @codec: the HDA codec
 *
 * Clear all pin controls to shup up before suspend for avoiding click noise.
 * The controls aren't cached so that they can be resumed properly.
 */
void snd_hda_shutup_pins(struct hda_codec *codec)
{
616
	const struct hda_pincfg *pin;
617
	int i;
618

619 620 621 622 623
	/* don't shut up pins when unloading the driver; otherwise it breaks
	 * the default pin setup at the next load of the driver
	 */
	if (codec->bus->shutdown)
		return;
624
	snd_array_for_each(&codec->init_pins, i, pin) {
625 626 627 628
		/* use read here for syncing after issuing each verb */
		snd_hda_codec_read(codec, pin->nid, 0,
				   AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
	}
629
	codec->pins_shutup = 1;
630
}
631
EXPORT_SYMBOL_GPL(snd_hda_shutup_pins);
632

633
#ifdef CONFIG_PM
634 635 636
/* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
static void restore_shutup_pins(struct hda_codec *codec)
{
637
	const struct hda_pincfg *pin;
638
	int i;
639

640 641 642 643
	if (!codec->pins_shutup)
		return;
	if (codec->bus->shutdown)
		return;
644
	snd_array_for_each(&codec->init_pins, i, pin) {
645 646 647 648 649 650
		snd_hda_codec_write(codec, pin->nid, 0,
				    AC_VERB_SET_PIN_WIDGET_CONTROL,
				    pin->ctrl);
	}
	codec->pins_shutup = 0;
}
651
#endif
652

653 654 655 656 657 658 659
static void hda_jackpoll_work(struct work_struct *work)
{
	struct hda_codec *codec =
		container_of(work, struct hda_codec, jackpoll_work.work);

	snd_hda_jack_set_dirty_all(codec);
	snd_hda_jack_poll_all(codec);
660 661 662 663

	if (!codec->jackpoll_interval)
		return;

664 665
	schedule_delayed_work(&codec->jackpoll_work,
			      codec->jackpoll_interval);
666 667
}

668 669
/* release all pincfg lists */
static void free_init_pincfgs(struct hda_codec *codec)
670
{
671
	snd_array_free(&codec->driver_pins);
672
#ifdef CONFIG_SND_HDA_RECONFIG
673
	snd_array_free(&codec->user_pins);
674 675 676 677
#endif
	snd_array_free(&codec->init_pins);
}

678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
/*
 * audio-converter setup caches
 */
struct hda_cvt_setup {
	hda_nid_t nid;
	u8 stream_tag;
	u8 channel_id;
	u16 format_id;
	unsigned char active;	/* cvt is currently used */
	unsigned char dirty;	/* setups should be cleared */
};

/* get or create a cache entry for the given audio converter NID */
static struct hda_cvt_setup *
get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
{
	struct hda_cvt_setup *p;
	int i;

697
	snd_array_for_each(&codec->cvt_setups, i, p) {
698 699 700 701 702 703 704 705 706
		if (p->nid == nid)
			return p;
	}
	p = snd_array_new(&codec->cvt_setups);
	if (p)
		p->nid = nid;
	return p;
}

707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
/*
 * PCM device
 */
static void release_pcm(struct kref *kref)
{
	struct hda_pcm *pcm = container_of(kref, struct hda_pcm, kref);

	if (pcm->pcm)
		snd_device_free(pcm->codec->card, pcm->pcm);
	clear_bit(pcm->device, pcm->codec->bus->pcm_dev_bits);
	kfree(pcm->name);
	kfree(pcm);
}

void snd_hda_codec_pcm_put(struct hda_pcm *pcm)
{
	kref_put(&pcm->kref, release_pcm);
}
EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_put);

struct hda_pcm *snd_hda_codec_pcm_new(struct hda_codec *codec,
				      const char *fmt, ...)
{
	struct hda_pcm *pcm;
	va_list args;

	pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
	if (!pcm)
		return NULL;

	pcm->codec = codec;
	kref_init(&pcm->kref);
739
	va_start(args, fmt);
740
	pcm->name = kvasprintf(GFP_KERNEL, fmt, args);
741
	va_end(args);
742 743 744 745 746 747 748 749 750 751
	if (!pcm->name) {
		kfree(pcm);
		return NULL;
	}

	list_add_tail(&pcm->list, &codec->pcm_list_head);
	return pcm;
}
EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_new);

752 753 754
/*
 * codec destructor
 */
755 756 757 758 759 760
static void codec_release_pcms(struct hda_codec *codec)
{
	struct hda_pcm *pcm, *n;

	list_for_each_entry_safe(pcm, n, &codec->pcm_list_head, list) {
		list_del_init(&pcm->list);
761 762
		if (pcm->pcm)
			snd_device_disconnect(codec->card, pcm->pcm);
763 764 765 766
		snd_hda_codec_pcm_put(pcm);
	}
}

767 768
void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec)
{
769 770 771 772 773 774 775
	if (codec->registered) {
		/* pm_runtime_put() is called in snd_hdac_device_exit() */
		pm_runtime_get_noresume(hda_codec_dev(codec));
		pm_runtime_disable(hda_codec_dev(codec));
		codec->registered = 0;
	}

776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796
	cancel_delayed_work_sync(&codec->jackpoll_work);
	if (!codec->in_freeing)
		snd_hda_ctls_clear(codec);
	codec_release_pcms(codec);
	snd_hda_detach_beep_device(codec);
	memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
	snd_hda_jack_tbl_clear(codec);
	codec->proc_widget_hook = NULL;
	codec->spec = NULL;

	/* free only driver_pins so that init_pins + user_pins are restored */
	snd_array_free(&codec->driver_pins);
	snd_array_free(&codec->cvt_setups);
	snd_array_free(&codec->spdif_out);
	snd_array_free(&codec->verbs);
	codec->preset = NULL;
	codec->slave_dig_outs = NULL;
	codec->spdif_status_reset = 0;
	snd_array_free(&codec->mixers);
	snd_array_free(&codec->nids);
	remove_conn_list(codec);
T
Takashi Iwai 已提交
797
	snd_hdac_regmap_exit(&codec->core);
798 799
}

800
static unsigned int hda_set_power_state(struct hda_codec *codec,
801 802
				unsigned int power_state);

803 804 805 806 807 808 809
/* enable/disable display power per codec */
static void codec_display_power(struct hda_codec *codec, bool enable)
{
	if (codec->display_power_control)
		snd_hdac_display_power(&codec->bus->core, codec->addr, enable);
}

810 811
/* also called from hda_bind.c */
void snd_hda_codec_register(struct hda_codec *codec)
812
{
813 814 815
	if (codec->registered)
		return;
	if (device_is_registered(hda_codec_dev(codec))) {
816
		codec_display_power(codec, true);
817
		pm_runtime_enable(hda_codec_dev(codec));
818 819 820 821 822 823 824 825 826
		/* it was powered up in snd_hda_codec_new(), now all done */
		snd_hda_power_down(codec);
		codec->registered = 1;
	}
}

static int snd_hda_codec_dev_register(struct snd_device *device)
{
	snd_hda_codec_register(device->device_data);
827
	return 0;
828 829
}

830 831
static int snd_hda_codec_dev_free(struct snd_device *device)
{
832 833 834
	struct hda_codec *codec = device->device_data;

	codec->in_freeing = 1;
835 836 837 838 839 840 841
	/*
	 * snd_hda_codec_device_new() is used by legacy HDA and ASoC driver.
	 * We can't unregister ASoC device since it will be unregistered in
	 * snd_hdac_ext_bus_device_remove().
	 */
	if (codec->core.type == HDA_DEV_LEGACY)
		snd_hdac_device_unregister(&codec->core);
842
	codec_display_power(codec, false);
843 844 845 846 847 848 849 850

	/*
	 * In the case of ASoC HD-audio bus, the device refcount is released in
	 * snd_hdac_ext_bus_device_remove() explicitly.
	 */
	if (codec->core.type == HDA_DEV_LEGACY)
		put_device(hda_codec_dev(codec));

851 852 853
	return 0;
}

854 855
static void snd_hda_codec_dev_release(struct device *dev)
{
856 857 858
	struct hda_codec *codec = dev_to_hda_codec(dev);

	free_init_pincfgs(codec);
859
	snd_hdac_device_exit(&codec->core);
860 861 862 863
	snd_hda_sysfs_clear(codec);
	kfree(codec->modelname);
	kfree(codec->wcaps);
	kfree(codec);
864 865
}

866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898
#define DEV_NAME_LEN 31

static int snd_hda_codec_device_init(struct hda_bus *bus, struct snd_card *card,
			unsigned int codec_addr, struct hda_codec **codecp)
{
	char name[DEV_NAME_LEN];
	struct hda_codec *codec;
	int err;

	dev_dbg(card->dev, "%s: entry\n", __func__);

	if (snd_BUG_ON(!bus))
		return -EINVAL;
	if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
		return -EINVAL;

	codec = kzalloc(sizeof(*codec), GFP_KERNEL);
	if (!codec)
		return -ENOMEM;

	sprintf(name, "hdaudioC%dD%d", card->number, codec_addr);
	err = snd_hdac_device_init(&codec->core, &bus->core, name, codec_addr);
	if (err < 0) {
		kfree(codec);
		return err;
	}

	codec->core.type = HDA_DEV_LEGACY;
	*codecp = codec;

	return err;
}

L
Linus Torvalds 已提交
899 900 901 902 903 904 905 906
/**
 * snd_hda_codec_new - create a HDA codec
 * @bus: the bus to assign
 * @codec_addr: the codec address
 * @codecp: the pointer to store the generated codec
 *
 * Returns 0 if successful, or a negative error code.
 */
907 908
int snd_hda_codec_new(struct hda_bus *bus, struct snd_card *card,
		      unsigned int codec_addr, struct hda_codec **codecp)
L
Linus Torvalds 已提交
909
{
910 911 912 913 914 915 916 917 918 919 920 921 922
	int ret;

	ret = snd_hda_codec_device_init(bus, card, codec_addr, codecp);
	if (ret < 0)
		return ret;

	return snd_hda_codec_device_new(bus, card, codec_addr, *codecp);
}
EXPORT_SYMBOL_GPL(snd_hda_codec_new);

int snd_hda_codec_device_new(struct hda_bus *bus, struct snd_card *card,
			unsigned int codec_addr, struct hda_codec *codec)
{
923
	char component[31];
924
	hda_nid_t fg;
L
Linus Torvalds 已提交
925
	int err;
926
	static struct snd_device_ops dev_ops = {
927
		.dev_register = snd_hda_codec_dev_register,
928 929
		.dev_free = snd_hda_codec_dev_free,
	};
L
Linus Torvalds 已提交
930

931 932
	dev_dbg(card->dev, "%s: entry\n", __func__);

933 934 935 936
	if (snd_BUG_ON(!bus))
		return -EINVAL;
	if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
		return -EINVAL;
L
Linus Torvalds 已提交
937

938
	codec->core.dev.release = snd_hda_codec_dev_release;
939
	codec->core.exec_verb = codec_exec_verb;
940

L
Linus Torvalds 已提交
941
	codec->bus = bus;
942
	codec->card = card;
L
Linus Torvalds 已提交
943
	codec->addr = codec_addr;
944
	mutex_init(&codec->spdif_mutex);
945
	mutex_init(&codec->control_mutex);
946 947
	snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
	snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
948
	snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
949
	snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
950
	snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
951
	snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
952
	snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
953
	snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
954
	INIT_LIST_HEAD(&codec->conn_list);
955
	INIT_LIST_HEAD(&codec->pcm_list_head);
956

957
	INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
958
	codec->depop_delay = -1;
959
	codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
L
Linus Torvalds 已提交
960

961
#ifdef CONFIG_PM
962
	codec->power_jiffies = jiffies;
963 964
#endif

965 966
	snd_hda_sysfs_init(codec);

967 968 969
	if (codec->bus->modelname) {
		codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
		if (!codec->modelname) {
H
Heloise NH 已提交
970
			err = -ENOMEM;
971
			goto error;
972 973 974
		}
	}

975
	fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
976
	err = read_widget_caps(codec, fg);
977
	if (err < 0)
978 979 980 981
		goto error;
	err = read_pin_defaults(codec);
	if (err < 0)
		goto error;
982

983
	/* power-up all before initialization */
984
	hda_set_power_state(codec, AC_PWRST_D0);
985
	codec->core.dev.power.power_state = PMSG_ON;
986

987 988 989 990
	snd_hda_codec_proc_new(codec);

	snd_hda_create_hwdep(codec);

991 992
	sprintf(component, "HDA:%08x,%08x,%08x", codec->core.vendor_id,
		codec->core.subsystem_id, codec->core.revision_id);
993
	snd_component_add(card, component);
994

995
	err = snd_device_new(card, SNDRV_DEV_CODEC, codec, &dev_ops);
996 997 998
	if (err < 0)
		goto error;

999
	return 0;
1000 1001

 error:
1002
	put_device(hda_codec_dev(codec));
1003
	return err;
1004
}
1005
EXPORT_SYMBOL_GPL(snd_hda_codec_device_new);
1006

T
Takashi Iwai 已提交
1007 1008 1009 1010 1011 1012 1013
/**
 * snd_hda_codec_update_widgets - Refresh widget caps and pin defaults
 * @codec: the HDA codec
 *
 * Forcibly refresh the all widget caps and the init pin configurations of
 * the given codec.
 */
1014 1015 1016 1017 1018
int snd_hda_codec_update_widgets(struct hda_codec *codec)
{
	hda_nid_t fg;
	int err;

1019
	err = snd_hdac_refresh_widgets(&codec->core, true);
1020 1021 1022
	if (err < 0)
		return err;

1023 1024 1025 1026
	/* Assume the function group node does not change,
	 * only the widget nodes may change.
	 */
	kfree(codec->wcaps);
1027
	fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
1028
	err = read_widget_caps(codec, fg);
1029
	if (err < 0)
1030 1031 1032 1033 1034 1035 1036
		return err;

	snd_array_free(&codec->init_pins);
	err = read_pin_defaults(codec);

	return err;
}
1037
EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets);
1038

1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
/* update the stream-id if changed */
static void update_pcm_stream_id(struct hda_codec *codec,
				 struct hda_cvt_setup *p, hda_nid_t nid,
				 u32 stream_tag, int channel_id)
{
	unsigned int oldval, newval;

	if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
		oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
		newval = (stream_tag << 4) | channel_id;
		if (oldval != newval)
			snd_hda_codec_write(codec, nid, 0,
					    AC_VERB_SET_CHANNEL_STREAMID,
					    newval);
		p->stream_tag = stream_tag;
		p->channel_id = channel_id;
	}
}

/* update the format-id if changed */
static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
			      hda_nid_t nid, int format)
{
	unsigned int oldval;

	if (p->format_id != format) {
		oldval = snd_hda_codec_read(codec, nid, 0,
					    AC_VERB_GET_STREAM_FORMAT, 0);
		if (oldval != format) {
			msleep(1);
			snd_hda_codec_write(codec, nid, 0,
					    AC_VERB_SET_STREAM_FORMAT,
					    format);
		}
		p->format_id = format;
	}
}

L
Linus Torvalds 已提交
1077 1078 1079 1080 1081 1082 1083 1084
/**
 * snd_hda_codec_setup_stream - set up the codec for streaming
 * @codec: the CODEC to set up
 * @nid: the NID to set up
 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
 * @channel_id: channel id to pass, zero based.
 * @format: stream format.
 */
T
Takashi Iwai 已提交
1085 1086
void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
				u32 stream_tag,
L
Linus Torvalds 已提交
1087 1088
				int channel_id, int format)
{
1089
	struct hda_codec *c;
1090
	struct hda_cvt_setup *p;
1091
	int type;
1092 1093
	int i;

T
Takashi Iwai 已提交
1094
	if (!nid)
1095 1096
		return;

1097 1098 1099
	codec_dbg(codec,
		  "hda_codec_setup_stream: NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
		  nid, stream_tag, channel_id, format);
1100
	p = get_hda_cvt_setup(codec, nid);
1101
	if (!p)
1102
		return;
1103

1104 1105
	if (codec->patch_ops.stream_pm)
		codec->patch_ops.stream_pm(codec, nid, true);
1106 1107 1108 1109 1110 1111
	if (codec->pcm_format_first)
		update_pcm_format(codec, p, nid, format);
	update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
	if (!codec->pcm_format_first)
		update_pcm_format(codec, p, nid, format);

1112 1113 1114 1115
	p->active = 1;
	p->dirty = 0;

	/* make other inactive cvts with the same stream-tag dirty */
1116
	type = get_wcaps_type(get_wcaps(codec, nid));
1117
	list_for_each_codec(c, codec->bus) {
1118
		snd_array_for_each(&c->cvt_setups, i, p) {
1119
			if (!p->active && p->stream_tag == stream_tag &&
1120
			    get_wcaps_type(get_wcaps(c, p->nid)) == type)
1121 1122
				p->dirty = 1;
		}
1123
	}
L
Linus Torvalds 已提交
1124
}
1125
EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream);
L
Linus Torvalds 已提交
1126

1127 1128 1129
static void really_cleanup_stream(struct hda_codec *codec,
				  struct hda_cvt_setup *q);

1130
/**
1131
 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1132 1133
 * @codec: the CODEC to clean up
 * @nid: the NID to clean up
1134
 * @do_now: really clean up the stream instead of clearing the active flag
1135
 */
1136 1137
void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
				    int do_now)
1138
{
1139 1140
	struct hda_cvt_setup *p;

1141 1142 1143
	if (!nid)
		return;

1144 1145 1146
	if (codec->no_sticky_stream)
		do_now = 1;

1147
	codec_dbg(codec, "hda_codec_cleanup_stream: NID=0x%x\n", nid);
1148
	p = get_hda_cvt_setup(codec, nid);
1149
	if (p) {
1150 1151 1152 1153 1154 1155 1156 1157 1158
		/* here we just clear the active flag when do_now isn't set;
		 * actual clean-ups will be done later in
		 * purify_inactive_streams() called from snd_hda_codec_prpapre()
		 */
		if (do_now)
			really_cleanup_stream(codec, p);
		else
			p->active = 0;
	}
1159
}
1160
EXPORT_SYMBOL_GPL(__snd_hda_codec_cleanup_stream);
1161 1162 1163 1164 1165

static void really_cleanup_stream(struct hda_codec *codec,
				  struct hda_cvt_setup *q)
{
	hda_nid_t nid = q->nid;
1166 1167 1168 1169 1170
	if (q->stream_tag || q->channel_id)
		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
	if (q->format_id)
		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
);
1171 1172
	memset(q, 0, sizeof(*q));
	q->nid = nid;
1173 1174
	if (codec->patch_ops.stream_pm)
		codec->patch_ops.stream_pm(codec, nid, false);
1175 1176 1177 1178 1179
}

/* clean up the all conflicting obsolete streams */
static void purify_inactive_streams(struct hda_codec *codec)
{
1180
	struct hda_codec *c;
1181
	struct hda_cvt_setup *p;
1182 1183
	int i;

1184
	list_for_each_codec(c, codec->bus) {
1185
		snd_array_for_each(&c->cvt_setups, i, p) {
1186 1187 1188
			if (p->dirty)
				really_cleanup_stream(c, p);
		}
1189 1190 1191
	}
}

1192
#ifdef CONFIG_PM
1193 1194 1195
/* clean up all streams; called from suspend */
static void hda_cleanup_all_streams(struct hda_codec *codec)
{
1196
	struct hda_cvt_setup *p;
1197 1198
	int i;

1199
	snd_array_for_each(&codec->cvt_setups, i, p) {
1200 1201 1202
		if (p->stream_tag)
			really_cleanup_stream(codec, p);
	}
1203
}
1204
#endif
1205

L
Linus Torvalds 已提交
1206 1207 1208 1209
/*
 * amp access functions
 */

1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
/**
 * query_amp_caps - query AMP capabilities
 * @codec: the HD-auio codec
 * @nid: the NID to query
 * @direction: either #HDA_INPUT or #HDA_OUTPUT
 *
 * Query AMP capabilities for the given widget and direction.
 * Returns the obtained capability bits.
 *
 * When cap bits have been already read, this doesn't read again but
 * returns the cached value.
L
Linus Torvalds 已提交
1221
 */
1222
u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
L
Linus Torvalds 已提交
1223
{
1224 1225 1226 1227 1228
	if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
		nid = codec->core.afg;
	return snd_hda_param_read(codec, nid,
				  direction == HDA_OUTPUT ?
				  AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
L
Linus Torvalds 已提交
1229
}
1230
EXPORT_SYMBOL_GPL(query_amp_caps);
L
Linus Torvalds 已提交
1231

1232 1233 1234 1235 1236
/**
 * snd_hda_check_amp_caps - query AMP capabilities
 * @codec: the HD-audio codec
 * @nid: the NID to query
 * @dir: either #HDA_INPUT or #HDA_OUTPUT
1237
 * @bits: bit mask to check the result
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
 *
 * Check whether the widget has the given amp capability for the direction.
 */
bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
			   int dir, unsigned int bits)
{
	if (!nid)
		return false;
	if (get_wcaps(codec, nid) & (1 << (dir + 1)))
		if (query_amp_caps(codec, nid, dir) & bits)
			return true;
	return false;
}
EXPORT_SYMBOL_GPL(snd_hda_check_amp_caps);

1253 1254 1255 1256
/**
 * snd_hda_override_amp_caps - Override the AMP capabilities
 * @codec: the CODEC to clean up
 * @nid: the NID to clean up
1257
 * @dir: either #HDA_INPUT or #HDA_OUTPUT
1258 1259 1260 1261 1262 1263 1264 1265
 * @caps: the capability bits to set
 *
 * Override the cached AMP caps bits value by the given one.
 * This function is useful if the driver needs to adjust the AMP ranges,
 * e.g. limit to 0dB, etc.
 *
 * Returns zero if successful or a negative error code.
 */
1266 1267 1268
int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
			      unsigned int caps)
{
1269
	unsigned int parm;
1270

1271 1272 1273 1274
	snd_hda_override_wcaps(codec, nid,
			       get_wcaps(codec, nid) | AC_WCAP_AMP_OVRD);
	parm = dir == HDA_OUTPUT ? AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP;
	return snd_hdac_override_parm(&codec->core, nid, parm, caps);
1275
}
1276
EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
1277

1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302
/**
 * snd_hda_codec_amp_update - update the AMP mono value
 * @codec: HD-audio codec
 * @nid: NID to read the AMP value
 * @ch: channel to update (0 or 1)
 * @dir: #HDA_INPUT or #HDA_OUTPUT
 * @idx: the index value (only for input direction)
 * @mask: bit mask to set
 * @val: the bits value to set
 *
 * Update the AMP values for the given channel, direction and index.
 */
int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid,
			     int ch, int dir, int idx, int mask, int val)
{
	unsigned int cmd = snd_hdac_regmap_encode_amp(nid, ch, dir, idx);

	/* enable fake mute if no h/w mute but min=mute */
	if ((query_amp_caps(codec, nid, dir) &
	     (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) == AC_AMPCAP_MIN_MUTE)
		cmd |= AC_AMP_FAKE_MUTE;
	return snd_hdac_regmap_update_raw(&codec->core, cmd, mask, val);
}
EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update);

1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
/**
 * snd_hda_codec_amp_stereo - update the AMP stereo values
 * @codec: HD-audio codec
 * @nid: NID to read the AMP value
 * @direction: #HDA_INPUT or #HDA_OUTPUT
 * @idx: the index value (only for input direction)
 * @mask: bit mask to set
 * @val: the bits value to set
 *
 * Update the AMP values like snd_hda_codec_amp_update(), but for a
 * stereo widget with the same mask and value.
1314 1315 1316 1317 1318
 */
int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
			     int direction, int idx, int mask, int val)
{
	int ch, ret = 0;
1319 1320 1321

	if (snd_BUG_ON(mask & ~0xff))
		mask &= 0xff;
1322 1323 1324 1325 1326
	for (ch = 0; ch < 2; ch++)
		ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
						idx, mask, val);
	return ret;
}
1327
EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
1328

T
Takashi Iwai 已提交
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
/**
 * snd_hda_codec_amp_init - initialize the AMP value
 * @codec: the HDA codec
 * @nid: NID to read the AMP value
 * @ch: channel (left=0 or right=1)
 * @dir: #HDA_INPUT or #HDA_OUTPUT
 * @idx: the index value (only for input direction)
 * @mask: bit mask to set
 * @val: the bits value to set
 *
 * Works like snd_hda_codec_amp_update() but it writes the value only at
1340 1341 1342 1343 1344 1345
 * the first access.  If the amp was already initialized / updated beforehand,
 * this does nothing.
 */
int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
			   int dir, int idx, int mask, int val)
{
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355
	int orig;

	if (!codec->core.regmap)
		return -EINVAL;
	regcache_cache_only(codec->core.regmap, true);
	orig = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
	regcache_cache_only(codec->core.regmap, false);
	if (orig >= 0)
		return 0;
	return snd_hda_codec_amp_update(codec, nid, ch, dir, idx, mask, val);
1356
}
1357
EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init);
1358

T
Takashi Iwai 已提交
1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
/**
 * snd_hda_codec_amp_init_stereo - initialize the stereo AMP value
 * @codec: the HDA codec
 * @nid: NID to read the AMP value
 * @dir: #HDA_INPUT or #HDA_OUTPUT
 * @idx: the index value (only for input direction)
 * @mask: bit mask to set
 * @val: the bits value to set
 *
 * Call snd_hda_codec_amp_init() for both stereo channels.
 */
1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
				  int dir, int idx, int mask, int val)
{
	int ch, ret = 0;

	if (snd_BUG_ON(mask & ~0xff))
		mask &= 0xff;
	for (ch = 0; ch < 2; ch++)
		ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
					      idx, mask, val);
	return ret;
}
1382
EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo);
1383

1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394
static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
			     unsigned int ofs)
{
	u32 caps = query_amp_caps(codec, nid, dir);
	/* get num steps */
	caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
	if (ofs < caps)
		caps -= ofs;
	return caps;
}

1395 1396
/**
 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1397 1398
 * @kcontrol: referred ctl element
 * @uinfo: pointer to get/store the data
1399 1400 1401 1402
 *
 * The control element is supposed to have the private_value field
 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
 */
T
Takashi Iwai 已提交
1403 1404
int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_info *uinfo)
L
Linus Torvalds 已提交
1405 1406 1407 1408 1409
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	u16 nid = get_amp_nid(kcontrol);
	u8 chs = get_amp_channels(kcontrol);
	int dir = get_amp_direction(kcontrol);
1410
	unsigned int ofs = get_amp_offset(kcontrol);
L
Linus Torvalds 已提交
1411

1412 1413 1414 1415 1416
	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	uinfo->count = chs == 3 ? 2 : 1;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
	if (!uinfo->value.integer.max) {
1417 1418 1419
		codec_warn(codec,
			   "num_steps = 0 for NID=0x%x (ctl = %s)\n",
			   nid, kcontrol->id.name);
L
Linus Torvalds 已提交
1420 1421 1422 1423
		return -EINVAL;
	}
	return 0;
}
1424
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
L
Linus Torvalds 已提交
1425

1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445

static inline unsigned int
read_amp_value(struct hda_codec *codec, hda_nid_t nid,
	       int ch, int dir, int idx, unsigned int ofs)
{
	unsigned int val;
	val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
	val &= HDA_AMP_VOLMASK;
	if (val >= ofs)
		val -= ofs;
	else
		val = 0;
	return val;
}

static inline int
update_amp_value(struct hda_codec *codec, hda_nid_t nid,
		 int ch, int dir, int idx, unsigned int ofs,
		 unsigned int val)
{
1446 1447
	unsigned int maxval;

1448 1449
	if (val > 0)
		val += ofs;
1450 1451
	/* ofs = 0: raw max value */
	maxval = get_amp_max_value(codec, nid, dir, 0);
1452 1453
	if (val > maxval)
		val = maxval;
1454 1455
	return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
					HDA_AMP_VOLMASK, val);
1456 1457
}

1458 1459
/**
 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1460 1461
 * @kcontrol: ctl element
 * @ucontrol: pointer to get/store the data
1462 1463 1464 1465
 *
 * The control element is supposed to have the private_value field
 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
 */
T
Takashi Iwai 已提交
1466 1467
int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
1468 1469 1470 1471 1472 1473
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = get_amp_nid(kcontrol);
	int chs = get_amp_channels(kcontrol);
	int dir = get_amp_direction(kcontrol);
	int idx = get_amp_index(kcontrol);
1474
	unsigned int ofs = get_amp_offset(kcontrol);
L
Linus Torvalds 已提交
1475 1476 1477
	long *valp = ucontrol->value.integer.value;

	if (chs & 1)
1478
		*valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
L
Linus Torvalds 已提交
1479
	if (chs & 2)
1480
		*valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
L
Linus Torvalds 已提交
1481 1482
	return 0;
}
1483
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
L
Linus Torvalds 已提交
1484

1485 1486
/**
 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1487 1488
 * @kcontrol: ctl element
 * @ucontrol: pointer to get/store the data
1489 1490 1491 1492
 *
 * The control element is supposed to have the private_value field
 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
 */
T
Takashi Iwai 已提交
1493 1494
int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
1495 1496 1497 1498 1499 1500
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = get_amp_nid(kcontrol);
	int chs = get_amp_channels(kcontrol);
	int dir = get_amp_direction(kcontrol);
	int idx = get_amp_index(kcontrol);
1501
	unsigned int ofs = get_amp_offset(kcontrol);
L
Linus Torvalds 已提交
1502 1503 1504
	long *valp = ucontrol->value.integer.value;
	int change = 0;

1505
	if (chs & 1) {
1506
		change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1507 1508
		valp++;
	}
1509
	if (chs & 2)
1510
		change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
L
Linus Torvalds 已提交
1511 1512
	return change;
}
1513
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
L
Linus Torvalds 已提交
1514

1515 1516
/* inquiry the amp caps and convert to TLV */
static void get_ctl_amp_tlv(struct snd_kcontrol *kcontrol, unsigned int *tlv)
1517 1518 1519 1520
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = get_amp_nid(kcontrol);
	int dir = get_amp_direction(kcontrol);
1521
	unsigned int ofs = get_amp_offset(kcontrol);
1522
	bool min_mute = get_amp_min_mute(kcontrol);
1523 1524 1525
	u32 caps, val1, val2;

	caps = query_amp_caps(codec, nid, dir);
T
Takashi Iwai 已提交
1526 1527
	val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
	val2 = (val2 + 1) * 25;
1528
	val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1529
	val1 += ofs;
1530
	val1 = ((int)val1) * ((int)val2);
1531
	if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
1532
		val2 |= TLV_DB_SCALE_MUTE;
1533 1534 1535 1536
	tlv[SNDRV_CTL_TLVO_TYPE] = SNDRV_CTL_TLVT_DB_SCALE;
	tlv[SNDRV_CTL_TLVO_LEN] = 2 * sizeof(unsigned int);
	tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN] = val1;
	tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] = val2;
1537 1538 1539
}

/**
T
Takashi Iwai 已提交
1540
 * snd_hda_mixer_amp_tlv - TLV callback for a standard AMP mixer volume
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557
 * @kcontrol: ctl element
 * @op_flag: operation flag
 * @size: byte size of input TLV
 * @_tlv: TLV data
 *
 * The control element is supposed to have the private_value field
 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
 */
int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
			  unsigned int size, unsigned int __user *_tlv)
{
	unsigned int tlv[4];

	if (size < 4 * sizeof(unsigned int))
		return -ENOMEM;
	get_ctl_amp_tlv(kcontrol, tlv);
	if (copy_to_user(_tlv, tlv, sizeof(tlv)))
1558 1559 1560
		return -EFAULT;
	return 0;
}
1561
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
1562

1563 1564 1565 1566 1567 1568 1569 1570 1571 1572
/**
 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
 * @codec: HD-audio codec
 * @nid: NID of a reference widget
 * @dir: #HDA_INPUT or #HDA_OUTPUT
 * @tlv: TLV data to be stored, at least 4 elements
 *
 * Set (static) TLV data for a virtual master volume using the AMP caps
 * obtained from the reference NID.
 * The volume range is recalculated as if the max volume is 0dB.
1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583
 */
void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
			     unsigned int *tlv)
{
	u32 caps;
	int nums, step;

	caps = query_amp_caps(codec, nid, dir);
	nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
	step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
	step = (step + 1) * 25;
1584 1585 1586 1587
	tlv[SNDRV_CTL_TLVO_TYPE] = SNDRV_CTL_TLVT_DB_SCALE;
	tlv[SNDRV_CTL_TLVO_LEN] = 2 * sizeof(unsigned int);
	tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN] = -nums * step;
	tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] = step;
1588
}
1589
EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
1590 1591

/* find a mixer control element with the given name */
1592
static struct snd_kcontrol *
1593
find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
1594 1595 1596 1597
{
	struct snd_ctl_elem_id id;
	memset(&id, 0, sizeof(id));
	id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1598
	id.device = dev;
1599
	id.index = idx;
T
Takashi Iwai 已提交
1600 1601
	if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
		return NULL;
1602
	strcpy(id.name, name);
1603
	return snd_ctl_find_id(codec->card, &id);
1604 1605
}

1606 1607 1608 1609 1610 1611 1612
/**
 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
 * @codec: HD-audio codec
 * @name: ctl id name string
 *
 * Get the control element with the given id string and IFACE_MIXER.
 */
1613 1614 1615
struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
					    const char *name)
{
1616
	return find_mixer_ctl(codec, name, 0, 0);
1617
}
1618
EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
1619

1620
static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
1621
				    int start_idx)
1622
{
1623 1624 1625 1626
	int i, idx;
	/* 16 ctlrs should be large enough */
	for (i = 0, idx = start_idx; i < 16; i++, idx++) {
		if (!find_mixer_ctl(codec, name, 0, idx))
1627 1628 1629 1630 1631
			return idx;
	}
	return -EBUSY;
}

1632
/**
1633
 * snd_hda_ctl_add - Add a control element and assign to the codec
1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647
 * @codec: HD-audio codec
 * @nid: corresponding NID (optional)
 * @kctl: the control element to assign
 *
 * Add the given control element to an array inside the codec instance.
 * All control elements belonging to a codec are supposed to be added
 * by this function so that a proper clean-up works at the free or
 * reconfiguration time.
 *
 * If non-zero @nid is passed, the NID is assigned to the control element.
 * The assignment is shown in the codec proc file.
 *
 * snd_hda_ctl_add() checks the control subdev id field whether
 * #HDA_SUBDEV_NID_FLAG bit is set.  If set (and @nid is zero), the lower
1648 1649
 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
 * specifies if kctl->private_value is a HDA amplifier value.
1650
 */
1651 1652
int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
		    struct snd_kcontrol *kctl)
T
Takashi Iwai 已提交
1653 1654
{
	int err;
1655
	unsigned short flags = 0;
1656
	struct hda_nid_item *item;
T
Takashi Iwai 已提交
1657

1658
	if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
1659
		flags |= HDA_NID_ITEM_AMP;
1660 1661 1662
		if (nid == 0)
			nid = get_amp_nid_(kctl->private_value);
	}
1663 1664
	if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
		nid = kctl->id.subdevice & 0xffff;
1665
	if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
1666
		kctl->id.subdevice = 0;
1667
	err = snd_ctl_add(codec->card, kctl);
T
Takashi Iwai 已提交
1668 1669
	if (err < 0)
		return err;
1670 1671
	item = snd_array_new(&codec->mixers);
	if (!item)
T
Takashi Iwai 已提交
1672
		return -ENOMEM;
1673 1674
	item->kctl = kctl;
	item->nid = nid;
1675
	item->flags = flags;
T
Takashi Iwai 已提交
1676 1677
	return 0;
}
1678
EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
T
Takashi Iwai 已提交
1679

1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
/**
 * snd_hda_add_nid - Assign a NID to a control element
 * @codec: HD-audio codec
 * @nid: corresponding NID (optional)
 * @kctl: the control element to assign
 * @index: index to kctl
 *
 * Add the given control element to an array inside the codec instance.
 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
 * NID:KCTL mapping - for example "Capture Source" selector.
 */
int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
		    unsigned int index, hda_nid_t nid)
{
	struct hda_nid_item *item;

	if (nid > 0) {
		item = snd_array_new(&codec->nids);
		if (!item)
			return -ENOMEM;
		item->kctl = kctl;
		item->index = index;
		item->nid = nid;
		return 0;
	}
1705 1706
	codec_err(codec, "no NID for mapping control %s:%d:%d\n",
		  kctl->id.name, kctl->id.index, index);
1707 1708
	return -EINVAL;
}
1709
EXPORT_SYMBOL_GPL(snd_hda_add_nid);
1710

1711 1712 1713 1714
/**
 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
 * @codec: HD-audio codec
 */
T
Takashi Iwai 已提交
1715 1716 1717
void snd_hda_ctls_clear(struct hda_codec *codec)
{
	int i;
1718
	struct hda_nid_item *items = codec->mixers.list;
T
Takashi Iwai 已提交
1719
	for (i = 0; i < codec->mixers.used; i++)
1720
		snd_ctl_remove(codec->card, items[i].kctl);
T
Takashi Iwai 已提交
1721
	snd_array_free(&codec->mixers);
1722
	snd_array_free(&codec->nids);
T
Takashi Iwai 已提交
1723 1724
}

T
Takashi Iwai 已提交
1725 1726 1727 1728
/**
 * snd_hda_lock_devices - pseudo device locking
 * @bus: the BUS
 *
1729 1730
 * toggle card->shutdown to allow/disallow the device access (as a hack)
 */
1731
int snd_hda_lock_devices(struct hda_bus *bus)
1732
{
1733 1734 1735
	struct snd_card *card = bus->card;
	struct hda_codec *codec;

1736
	spin_lock(&card->files_lock);
1737 1738
	if (card->shutdown)
		goto err_unlock;
1739
	card->shutdown = 1;
1740 1741 1742
	if (!list_empty(&card->ctl_files))
		goto err_clear;

1743
	list_for_each_codec(codec, bus) {
1744 1745
		struct hda_pcm *cpcm;
		list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
1746 1747 1748 1749 1750 1751 1752
			if (!cpcm->pcm)
				continue;
			if (cpcm->pcm->streams[0].substream_opened ||
			    cpcm->pcm->streams[1].substream_opened)
				goto err_clear;
		}
	}
1753 1754
	spin_unlock(&card->files_lock);
	return 0;
1755 1756 1757 1758 1759 1760

 err_clear:
	card->shutdown = 0;
 err_unlock:
	spin_unlock(&card->files_lock);
	return -EINVAL;
1761
}
1762
EXPORT_SYMBOL_GPL(snd_hda_lock_devices);
1763

T
Takashi Iwai 已提交
1764 1765 1766 1767
/**
 * snd_hda_unlock_devices - pseudo device unlocking
 * @bus: the BUS
 */
1768
void snd_hda_unlock_devices(struct hda_bus *bus)
1769
{
1770 1771
	struct snd_card *card = bus->card;

1772 1773 1774 1775
	spin_lock(&card->files_lock);
	card->shutdown = 0;
	spin_unlock(&card->files_lock);
}
1776
EXPORT_SYMBOL_GPL(snd_hda_unlock_devices);
1777

1778 1779 1780 1781 1782 1783 1784 1785 1786 1787
/**
 * snd_hda_codec_reset - Clear all objects assigned to the codec
 * @codec: HD-audio codec
 *
 * This frees the all PCM and control elements assigned to the codec, and
 * clears the caches and restores the pin default configurations.
 *
 * When a device is being used, it returns -EBSY.  If successfully freed,
 * returns zero.
 */
1788 1789
int snd_hda_codec_reset(struct hda_codec *codec)
{
1790
	struct hda_bus *bus = codec->bus;
1791

1792
	if (snd_hda_lock_devices(bus) < 0)
1793 1794 1795
		return -EBUSY;

	/* OK, let it free */
T
Takashi Iwai 已提交
1796
	snd_hdac_device_unregister(&codec->core);
1797

1798
	/* allow device access again */
1799
	snd_hda_unlock_devices(bus);
1800
	return 0;
1801 1802
}

1803
typedef int (*map_slave_func_t)(struct hda_codec *, void *, struct snd_kcontrol *);
1804 1805 1806

/* apply the function to all matching slave ctls in the mixer list */
static int map_slaves(struct hda_codec *codec, const char * const *slaves,
1807
		      const char *suffix, map_slave_func_t func, void *data) 
1808 1809 1810 1811 1812 1813 1814 1815
{
	struct hda_nid_item *items;
	const char * const *s;
	int i, err;

	items = codec->mixers.list;
	for (i = 0; i < codec->mixers.used; i++) {
		struct snd_kcontrol *sctl = items[i].kctl;
1816
		if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
1817 1818
			continue;
		for (s = slaves; *s; s++) {
1819 1820 1821 1822 1823 1824 1825 1826
			char tmpname[sizeof(sctl->id.name)];
			const char *name = *s;
			if (suffix) {
				snprintf(tmpname, sizeof(tmpname), "%s %s",
					 name, suffix);
				name = tmpname;
			}
			if (!strcmp(sctl->id.name, name)) {
1827
				err = func(codec, data, sctl);
1828 1829 1830 1831 1832 1833 1834 1835 1836
				if (err)
					return err;
				break;
			}
		}
	}
	return 0;
}

1837 1838
static int check_slave_present(struct hda_codec *codec,
			       void *data, struct snd_kcontrol *sctl)
1839 1840 1841 1842
{
	return 1;
}

1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856
/* call kctl->put with the given value(s) */
static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
{
	struct snd_ctl_elem_value *ucontrol;
	ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
	if (!ucontrol)
		return -ENOMEM;
	ucontrol->value.integer.value[0] = val;
	ucontrol->value.integer.value[1] = val;
	kctl->put(kctl, ucontrol);
	kfree(ucontrol);
	return 0;
}

1857 1858 1859 1860 1861 1862
struct slave_init_arg {
	struct hda_codec *codec;
	int step;
};

/* initialize the slave volume with 0dB via snd_ctl_apply_vmaster_slaves() */
1863 1864 1865
static int init_slave_0dB(struct snd_kcontrol *slave,
			  struct snd_kcontrol *kctl,
			  void *_arg)
1866
{
1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884
	struct slave_init_arg *arg = _arg;
	int _tlv[4];
	const int *tlv = NULL;
	int step;
	int val;

	if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
		if (kctl->tlv.c != snd_hda_mixer_amp_tlv) {
			codec_err(arg->codec,
				  "Unexpected TLV callback for slave %s:%d\n",
				  kctl->id.name, kctl->id.index);
			return 0; /* ignore */
		}
		get_ctl_amp_tlv(kctl, _tlv);
		tlv = _tlv;
	} else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
		tlv = kctl->tlv.p;

1885
	if (!tlv || tlv[SNDRV_CTL_TLVO_TYPE] != SNDRV_CTL_TLVT_DB_SCALE)
1886 1887
		return 0;

1888
	step = tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP];
1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899
	step &= ~TLV_DB_SCALE_MUTE;
	if (!step)
		return 0;
	if (arg->step && arg->step != step) {
		codec_err(arg->codec,
			  "Mismatching dB step for vmaster slave (%d!=%d)\n",
			  arg->step, step);
		return 0;
	}

	arg->step = step;
1900
	val = -tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN] / step;
1901
	if (val > 0) {
1902
		put_kctl_with_value(slave, val);
1903 1904 1905
		return val;
	}

1906 1907 1908
	return 0;
}

1909
/* unmute the slave via snd_ctl_apply_vmaster_slaves() */
1910 1911 1912
static int init_slave_unmute(struct snd_kcontrol *slave,
			     struct snd_kcontrol *kctl,
			     void *_arg)
1913 1914 1915 1916
{
	return put_kctl_with_value(slave, 1);
}

1917 1918 1919 1920 1921 1922
static int add_slave(struct hda_codec *codec,
		     void *data, struct snd_kcontrol *slave)
{
	return snd_ctl_add_slave(data, slave);
}

1923
/**
T
Takashi Iwai 已提交
1924
 * __snd_hda_add_vmaster - create a virtual master control and add slaves
1925 1926 1927 1928
 * @codec: HD-audio codec
 * @name: vmaster control name
 * @tlv: TLV data (optional)
 * @slaves: slave control names (optional)
1929
 * @suffix: suffix string to each slave name (optional)
1930
 * @init_slave_vol: initialize slaves to unmute/0dB
1931
 * @ctl_ret: store the vmaster kcontrol in return
1932 1933 1934 1935 1936 1937 1938 1939 1940 1941
 *
 * Create a virtual master control with the given name.  The TLV data
 * must be either NULL or a valid data.
 *
 * @slaves is a NULL-terminated array of strings, each of which is a
 * slave control name.  All controls with these names are assigned to
 * the new virtual master control.
 *
 * This function returns zero if successful or a negative error code.
 */
1942
int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1943
			unsigned int *tlv, const char * const *slaves,
1944 1945
			  const char *suffix, bool init_slave_vol,
			  struct snd_kcontrol **ctl_ret)
1946 1947 1948 1949
{
	struct snd_kcontrol *kctl;
	int err;

1950 1951 1952
	if (ctl_ret)
		*ctl_ret = NULL;

1953
	err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
1954
	if (err != 1) {
1955
		codec_dbg(codec, "No slave found for %s\n", name);
1956 1957
		return 0;
	}
1958 1959 1960
	kctl = snd_ctl_make_virtual_master(name, tlv);
	if (!kctl)
		return -ENOMEM;
1961
	err = snd_hda_ctl_add(codec, 0, kctl);
1962 1963
	if (err < 0)
		return err;
1964

1965
	err = map_slaves(codec, slaves, suffix, add_slave, kctl);
1966 1967
	if (err < 0)
		return err;
1968 1969 1970

	/* init with master mute & zero volume */
	put_kctl_with_value(kctl, 0);
1971
	if (init_slave_vol) {
1972 1973 1974 1975 1976 1977 1978
		struct slave_init_arg arg = {
			.codec = codec,
			.step = 0,
		};
		snd_ctl_apply_vmaster_slaves(kctl,
					     tlv ? init_slave_0dB : init_slave_unmute,
					     &arg);
1979
	}
1980

1981 1982
	if (ctl_ret)
		*ctl_ret = kctl;
1983 1984
	return 0;
}
1985
EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster);
1986

1987 1988 1989 1990 1991 1992 1993
/*
 * mute-LED control using vmaster
 */
static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_info *uinfo)
{
	static const char * const texts[] = {
1994
		"On", "Off", "Follow Master"
1995 1996
	};

T
Takashi Iwai 已提交
1997
	return snd_ctl_enum_info(uinfo, 1, 3, texts);
1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022
}

static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol)
{
	struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
	ucontrol->value.enumerated.item[0] = hook->mute_mode;
	return 0;
}

static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol)
{
	struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
	unsigned int old_mode = hook->mute_mode;

	hook->mute_mode = ucontrol->value.enumerated.item[0];
	if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
		hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
	if (old_mode == hook->mute_mode)
		return 0;
	snd_hda_sync_vmaster_hook(hook);
	return 1;
}

2023
static const struct snd_kcontrol_new vmaster_mute_mode = {
2024 2025 2026 2027 2028 2029 2030
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Mute-LED Mode",
	.info = vmaster_mute_mode_info,
	.get = vmaster_mute_mode_get,
	.put = vmaster_mute_mode_put,
};

2031 2032 2033 2034 2035 2036 2037 2038 2039 2040
/* meta hook to call each driver's vmaster hook */
static void vmaster_hook(void *private_data, int enabled)
{
	struct hda_vmaster_mute_hook *hook = private_data;

	if (hook->mute_mode != HDA_VMUTE_FOLLOW_MASTER)
		enabled = hook->mute_mode;
	hook->hook(hook->codec, enabled);
}

T
Takashi Iwai 已提交
2041 2042 2043 2044 2045 2046 2047 2048 2049
/**
 * snd_hda_add_vmaster_hook - Add a vmaster hook for mute-LED
 * @codec: the HDA codec
 * @hook: the vmaster hook object
 * @expose_enum_ctl: flag to create an enum ctl
 *
 * Add a mute-LED hook with the given vmaster switch kctl.
 * When @expose_enum_ctl is set, "Mute-LED Mode" control is automatically
 * created and associated with the given hook.
2050 2051
 */
int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2052 2053
			     struct hda_vmaster_mute_hook *hook,
			     bool expose_enum_ctl)
2054 2055 2056 2057 2058 2059 2060
{
	struct snd_kcontrol *kctl;

	if (!hook->hook || !hook->sw_kctl)
		return 0;
	hook->codec = codec;
	hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2061
	snd_ctl_add_vmaster_hook(hook->sw_kctl, vmaster_hook, hook);
2062 2063
	if (!expose_enum_ctl)
		return 0;
2064 2065 2066 2067 2068
	kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
	if (!kctl)
		return -ENOMEM;
	return snd_hda_ctl_add(codec, 0, kctl);
}
2069
EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook);
2070

T
Takashi Iwai 已提交
2071 2072 2073 2074 2075 2076
/**
 * snd_hda_sync_vmaster_hook - Sync vmaster hook
 * @hook: the vmaster hook
 *
 * Call the hook with the current value for synchronization.
 * Should be called in init callback.
2077 2078 2079 2080 2081
 */
void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
{
	if (!hook->hook || !hook->codec)
		return;
2082 2083 2084 2085 2086
	/* don't call vmaster hook in the destructor since it might have
	 * been already destroyed
	 */
	if (hook->codec->bus->shutdown)
		return;
2087
	snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2088
}
2089
EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook);
2090 2091


2092 2093
/**
 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2094 2095
 * @kcontrol: referred ctl element
 * @uinfo: pointer to get/store the data
2096 2097 2098 2099
 *
 * The control element is supposed to have the private_value field
 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
 */
T
Takashi Iwai 已提交
2100 2101
int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_info *uinfo)
L
Linus Torvalds 已提交
2102 2103 2104 2105 2106 2107 2108 2109 2110
{
	int chs = get_amp_channels(kcontrol);

	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
	uinfo->count = chs == 3 ? 2 : 1;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = 1;
	return 0;
}
2111
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
L
Linus Torvalds 已提交
2112

2113 2114
/**
 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2115 2116
 * @kcontrol: ctl element
 * @ucontrol: pointer to get/store the data
2117 2118 2119 2120
 *
 * The control element is supposed to have the private_value field
 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
 */
T
Takashi Iwai 已提交
2121 2122
int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
2123 2124 2125 2126 2127 2128 2129 2130 2131
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = get_amp_nid(kcontrol);
	int chs = get_amp_channels(kcontrol);
	int dir = get_amp_direction(kcontrol);
	int idx = get_amp_index(kcontrol);
	long *valp = ucontrol->value.integer.value;

	if (chs & 1)
T
Takashi Iwai 已提交
2132
		*valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2133
			   HDA_AMP_MUTE) ? 0 : 1;
L
Linus Torvalds 已提交
2134
	if (chs & 2)
T
Takashi Iwai 已提交
2135
		*valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2136
			 HDA_AMP_MUTE) ? 0 : 1;
L
Linus Torvalds 已提交
2137 2138
	return 0;
}
2139
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
L
Linus Torvalds 已提交
2140

2141 2142
/**
 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2143 2144
 * @kcontrol: ctl element
 * @ucontrol: pointer to get/store the data
2145 2146 2147 2148
 *
 * The control element is supposed to have the private_value field
 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
 */
T
Takashi Iwai 已提交
2149 2150
int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
2151 2152 2153 2154 2155 2156 2157 2158 2159
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = get_amp_nid(kcontrol);
	int chs = get_amp_channels(kcontrol);
	int dir = get_amp_direction(kcontrol);
	int idx = get_amp_index(kcontrol);
	long *valp = ucontrol->value.integer.value;
	int change = 0;

2160
	if (chs & 1) {
2161 2162 2163
		change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
						  HDA_AMP_MUTE,
						  *valp ? 0 : HDA_AMP_MUTE);
2164 2165
		valp++;
	}
2166
	if (chs & 2)
2167 2168 2169
		change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
						   HDA_AMP_MUTE,
						   *valp ? 0 : HDA_AMP_MUTE);
2170
	hda_call_check_power_status(codec, nid);
L
Linus Torvalds 已提交
2171 2172
	return change;
}
2173
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
L
Linus Torvalds 已提交
2174 2175 2176 2177 2178

/*
 * SPDIF out controls
 */

T
Takashi Iwai 已提交
2179 2180
static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
				   struct snd_ctl_elem_info *uinfo)
L
Linus Torvalds 已提交
2181 2182 2183 2184 2185 2186
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
	uinfo->count = 1;
	return 0;
}

T
Takashi Iwai 已提交
2187 2188
static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
				   struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
2189 2190 2191 2192 2193 2194 2195 2196 2197 2198
{
	ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
					   IEC958_AES0_NONAUDIO |
					   IEC958_AES0_CON_EMPHASIS_5015 |
					   IEC958_AES0_CON_NOT_COPYRIGHT;
	ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
					   IEC958_AES1_CON_ORIGINAL;
	return 0;
}

T
Takashi Iwai 已提交
2199 2200
static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
				   struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
2201 2202 2203 2204 2205 2206 2207
{
	ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
					   IEC958_AES0_NONAUDIO |
					   IEC958_AES0_PRO_EMPHASIS_5015;
	return 0;
}

T
Takashi Iwai 已提交
2208 2209
static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
				     struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
2210 2211
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2212
	int idx = kcontrol->private_value;
2213
	struct hda_spdif_out *spdif;
L
Linus Torvalds 已提交
2214

2215 2216
	if (WARN_ON(codec->spdif_out.used <= idx))
		return -EINVAL;
2217 2218
	mutex_lock(&codec->spdif_mutex);
	spdif = snd_array_elem(&codec->spdif_out, idx);
2219 2220 2221 2222
	ucontrol->value.iec958.status[0] = spdif->status & 0xff;
	ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
	ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
	ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2223
	mutex_unlock(&codec->spdif_mutex);
L
Linus Torvalds 已提交
2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235

	return 0;
}

/* convert from SPDIF status bits to HDA SPDIF bits
 * bit 0 (DigEn) is always set zero (to be filled later)
 */
static unsigned short convert_from_spdif_status(unsigned int sbits)
{
	unsigned short val = 0;

	if (sbits & IEC958_AES0_PROFESSIONAL)
T
Takashi Iwai 已提交
2236
		val |= AC_DIG1_PROFESSIONAL;
L
Linus Torvalds 已提交
2237
	if (sbits & IEC958_AES0_NONAUDIO)
T
Takashi Iwai 已提交
2238
		val |= AC_DIG1_NONAUDIO;
L
Linus Torvalds 已提交
2239
	if (sbits & IEC958_AES0_PROFESSIONAL) {
T
Takashi Iwai 已提交
2240 2241 2242
		if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
		    IEC958_AES0_PRO_EMPHASIS_5015)
			val |= AC_DIG1_EMPHASIS;
L
Linus Torvalds 已提交
2243
	} else {
T
Takashi Iwai 已提交
2244 2245 2246 2247 2248
		if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
		    IEC958_AES0_CON_EMPHASIS_5015)
			val |= AC_DIG1_EMPHASIS;
		if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
			val |= AC_DIG1_COPYRIGHT;
L
Linus Torvalds 已提交
2249
		if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
T
Takashi Iwai 已提交
2250
			val |= AC_DIG1_LEVEL;
L
Linus Torvalds 已提交
2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261
		val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
	}
	return val;
}

/* convert to SPDIF status bits from HDA SPDIF bits
 */
static unsigned int convert_to_spdif_status(unsigned short val)
{
	unsigned int sbits = 0;

T
Takashi Iwai 已提交
2262
	if (val & AC_DIG1_NONAUDIO)
L
Linus Torvalds 已提交
2263
		sbits |= IEC958_AES0_NONAUDIO;
T
Takashi Iwai 已提交
2264
	if (val & AC_DIG1_PROFESSIONAL)
L
Linus Torvalds 已提交
2265 2266
		sbits |= IEC958_AES0_PROFESSIONAL;
	if (sbits & IEC958_AES0_PROFESSIONAL) {
2267
		if (val & AC_DIG1_EMPHASIS)
L
Linus Torvalds 已提交
2268 2269
			sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
	} else {
T
Takashi Iwai 已提交
2270
		if (val & AC_DIG1_EMPHASIS)
L
Linus Torvalds 已提交
2271
			sbits |= IEC958_AES0_CON_EMPHASIS_5015;
T
Takashi Iwai 已提交
2272
		if (!(val & AC_DIG1_COPYRIGHT))
L
Linus Torvalds 已提交
2273
			sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
T
Takashi Iwai 已提交
2274
		if (val & AC_DIG1_LEVEL)
L
Linus Torvalds 已提交
2275 2276 2277 2278 2279 2280
			sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
		sbits |= val & (0x7f << 8);
	}
	return sbits;
}

2281 2282
/* set digital convert verbs both for the given NID and its slaves */
static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2283
			int mask, int val)
2284
{
2285
	const hda_nid_t *d;
2286

2287 2288
	snd_hdac_regmap_update(&codec->core, nid, AC_VERB_SET_DIGI_CONVERT_1,
			       mask, val);
2289 2290 2291 2292
	d = codec->slave_dig_outs;
	if (!d)
		return;
	for (; *d; d++)
2293
		snd_hdac_regmap_update(&codec->core, *d,
2294
				       AC_VERB_SET_DIGI_CONVERT_1, mask, val);
2295 2296 2297 2298 2299
}

static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
				       int dig1, int dig2)
{
2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311
	unsigned int mask = 0;
	unsigned int val = 0;

	if (dig1 != -1) {
		mask |= 0xff;
		val = dig1;
	}
	if (dig2 != -1) {
		mask |= 0xff00;
		val |= dig2 << 8;
	}
	set_dig_out(codec, nid, mask, val);
2312 2313
}

T
Takashi Iwai 已提交
2314 2315
static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
				     struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
2316 2317
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2318
	int idx = kcontrol->private_value;
2319 2320
	struct hda_spdif_out *spdif;
	hda_nid_t nid;
L
Linus Torvalds 已提交
2321 2322 2323
	unsigned short val;
	int change;

2324 2325
	if (WARN_ON(codec->spdif_out.used <= idx))
		return -EINVAL;
2326
	mutex_lock(&codec->spdif_mutex);
2327 2328
	spdif = snd_array_elem(&codec->spdif_out, idx);
	nid = spdif->nid;
2329
	spdif->status = ucontrol->value.iec958.status[0] |
L
Linus Torvalds 已提交
2330 2331 2332
		((unsigned int)ucontrol->value.iec958.status[1] << 8) |
		((unsigned int)ucontrol->value.iec958.status[2] << 16) |
		((unsigned int)ucontrol->value.iec958.status[3] << 24);
2333 2334 2335 2336
	val = convert_from_spdif_status(spdif->status);
	val |= spdif->ctls & 1;
	change = spdif->ctls != val;
	spdif->ctls = val;
2337
	if (change && nid != (u16)-1)
2338
		set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2339
	mutex_unlock(&codec->spdif_mutex);
L
Linus Torvalds 已提交
2340 2341 2342
	return change;
}

2343
#define snd_hda_spdif_out_switch_info	snd_ctl_boolean_mono_info
L
Linus Torvalds 已提交
2344

T
Takashi Iwai 已提交
2345 2346
static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
					struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
2347 2348
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2349
	int idx = kcontrol->private_value;
2350
	struct hda_spdif_out *spdif;
L
Linus Torvalds 已提交
2351

2352 2353
	if (WARN_ON(codec->spdif_out.used <= idx))
		return -EINVAL;
2354 2355
	mutex_lock(&codec->spdif_mutex);
	spdif = snd_array_elem(&codec->spdif_out, idx);
2356
	ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
2357
	mutex_unlock(&codec->spdif_mutex);
L
Linus Torvalds 已提交
2358 2359 2360
	return 0;
}

2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371
static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
				  int dig1, int dig2)
{
	set_dig_out_convert(codec, nid, dig1, dig2);
	/* unmute amp switch (if any) */
	if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
	    (dig1 & AC_DIG1_ENABLE))
		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
					    HDA_AMP_MUTE, 0);
}

T
Takashi Iwai 已提交
2372 2373
static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
					struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
2374 2375
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2376
	int idx = kcontrol->private_value;
2377 2378
	struct hda_spdif_out *spdif;
	hda_nid_t nid;
L
Linus Torvalds 已提交
2379 2380 2381
	unsigned short val;
	int change;

2382 2383
	if (WARN_ON(codec->spdif_out.used <= idx))
		return -EINVAL;
2384
	mutex_lock(&codec->spdif_mutex);
2385 2386
	spdif = snd_array_elem(&codec->spdif_out, idx);
	nid = spdif->nid;
2387
	val = spdif->ctls & ~AC_DIG1_ENABLE;
L
Linus Torvalds 已提交
2388
	if (ucontrol->value.integer.value[0])
T
Takashi Iwai 已提交
2389
		val |= AC_DIG1_ENABLE;
2390
	change = spdif->ctls != val;
2391 2392 2393
	spdif->ctls = val;
	if (change && nid != (u16)-1)
		set_spdif_ctls(codec, nid, val & 0xff, -1);
2394
	mutex_unlock(&codec->spdif_mutex);
L
Linus Torvalds 已提交
2395 2396 2397
	return change;
}

2398
static struct snd_kcontrol_new dig_mixes[] = {
L
Linus Torvalds 已提交
2399 2400 2401
	{
		.access = SNDRV_CTL_ELEM_ACCESS_READ,
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2402
		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
L
Linus Torvalds 已提交
2403 2404 2405 2406 2407 2408
		.info = snd_hda_spdif_mask_info,
		.get = snd_hda_spdif_cmask_get,
	},
	{
		.access = SNDRV_CTL_ELEM_ACCESS_READ,
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2409
		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
L
Linus Torvalds 已提交
2410 2411 2412 2413 2414
		.info = snd_hda_spdif_mask_info,
		.get = snd_hda_spdif_pmask_get,
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2415
		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
L
Linus Torvalds 已提交
2416 2417 2418 2419 2420 2421
		.info = snd_hda_spdif_mask_info,
		.get = snd_hda_spdif_default_get,
		.put = snd_hda_spdif_default_put,
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2422
		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
L
Linus Torvalds 已提交
2423 2424 2425 2426 2427 2428 2429 2430
		.info = snd_hda_spdif_out_switch_info,
		.get = snd_hda_spdif_out_switch_get,
		.put = snd_hda_spdif_out_switch_put,
	},
	{ } /* end */
};

/**
2431
 * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
L
Linus Torvalds 已提交
2432
 * @codec: the HDA codec
2433 2434 2435 2436 2437
 * @associated_nid: NID that new ctls associated with
 * @cvt_nid: converter NID
 * @type: HDA_PCM_TYPE_*
 * Creates controls related with the digital output.
 * Called from each patch supporting the digital out.
L
Linus Torvalds 已提交
2438 2439 2440
 *
 * Returns 0 if successful, or a negative error code.
 */
2441 2442 2443 2444
int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
				hda_nid_t associated_nid,
				hda_nid_t cvt_nid,
				int type)
L
Linus Torvalds 已提交
2445 2446
{
	int err;
2447 2448
	struct snd_kcontrol *kctl;
	struct snd_kcontrol_new *dig_mix;
2449
	int idx = 0;
2450
	int val = 0;
2451
	const int spdif_index = 16;
2452
	struct hda_spdif_out *spdif;
2453
	struct hda_bus *bus = codec->bus;
L
Linus Torvalds 已提交
2454

2455
	if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
2456
	    type == HDA_PCM_TYPE_SPDIF) {
2457 2458
		idx = spdif_index;
	} else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
2459
		   type == HDA_PCM_TYPE_HDMI) {
2460 2461 2462 2463 2464 2465
		/* suppose a single SPDIF device */
		for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
			kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
			if (!kctl)
				break;
			kctl->id.index = spdif_index;
2466
		}
2467
		bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
2468
	}
2469 2470
	if (!bus->primary_dig_out_type)
		bus->primary_dig_out_type = type;
2471

2472
	idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
2473
	if (idx < 0) {
2474
		codec_err(codec, "too many IEC958 outputs\n");
2475 2476
		return -EBUSY;
	}
2477
	spdif = snd_array_new(&codec->spdif_out);
2478 2479
	if (!spdif)
		return -ENOMEM;
L
Linus Torvalds 已提交
2480 2481
	for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
		kctl = snd_ctl_new1(dig_mix, codec);
2482 2483
		if (!kctl)
			return -ENOMEM;
2484
		kctl->id.index = idx;
2485
		kctl->private_value = codec->spdif_out.used - 1;
2486
		err = snd_hda_ctl_add(codec, associated_nid, kctl);
T
Takashi Iwai 已提交
2487
		if (err < 0)
L
Linus Torvalds 已提交
2488 2489
			return err;
	}
2490
	spdif->nid = cvt_nid;
2491 2492 2493
	snd_hdac_regmap_read(&codec->core, cvt_nid,
			     AC_VERB_GET_DIGI_CONVERT_1, &val);
	spdif->ctls = val;
2494
	spdif->status = convert_to_spdif_status(spdif->ctls);
L
Linus Torvalds 已提交
2495 2496
	return 0;
}
2497
EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls);
L
Linus Torvalds 已提交
2498

T
Takashi Iwai 已提交
2499 2500 2501 2502 2503
/**
 * snd_hda_spdif_out_of_nid - get the hda_spdif_out entry from the given NID
 * @codec: the HDA codec
 * @nid: widget NID
 *
2504 2505
 * call within spdif_mutex lock
 */
2506 2507 2508
struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
					       hda_nid_t nid)
{
2509
	struct hda_spdif_out *spdif;
2510
	int i;
2511 2512

	snd_array_for_each(&codec->spdif_out, i, spdif) {
2513 2514 2515 2516 2517
		if (spdif->nid == nid)
			return spdif;
	}
	return NULL;
}
2518
EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_nid);
2519

T
Takashi Iwai 已提交
2520 2521 2522 2523 2524 2525 2526
/**
 * snd_hda_spdif_ctls_unassign - Unassign the given SPDIF ctl
 * @codec: the HDA codec
 * @idx: the SPDIF ctl index
 *
 * Unassign the widget from the given SPDIF control.
 */
2527 2528
void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
{
2529
	struct hda_spdif_out *spdif;
2530

2531 2532
	if (WARN_ON(codec->spdif_out.used <= idx))
		return;
2533
	mutex_lock(&codec->spdif_mutex);
2534
	spdif = snd_array_elem(&codec->spdif_out, idx);
2535 2536 2537
	spdif->nid = (u16)-1;
	mutex_unlock(&codec->spdif_mutex);
}
2538
EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
2539

T
Takashi Iwai 已提交
2540 2541 2542 2543 2544 2545 2546 2547
/**
 * snd_hda_spdif_ctls_assign - Assign the SPDIF controls to the given NID
 * @codec: the HDA codec
 * @idx: the SPDIF ctl idx
 * @nid: widget NID
 *
 * Assign the widget to the SPDIF control with the given index.
 */
2548 2549
void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
{
2550
	struct hda_spdif_out *spdif;
2551 2552
	unsigned short val;

2553 2554
	if (WARN_ON(codec->spdif_out.used <= idx))
		return;
2555
	mutex_lock(&codec->spdif_mutex);
2556
	spdif = snd_array_elem(&codec->spdif_out, idx);
2557 2558 2559 2560 2561 2562 2563
	if (spdif->nid != nid) {
		spdif->nid = nid;
		val = spdif->ctls;
		set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
	}
	mutex_unlock(&codec->spdif_mutex);
}
2564
EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
2565

2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584
/*
 * SPDIF sharing with analog output
 */
static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
			      struct snd_ctl_elem_value *ucontrol)
{
	struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
	ucontrol->value.integer.value[0] = mout->share_spdif;
	return 0;
}

static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
			      struct snd_ctl_elem_value *ucontrol)
{
	struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
	mout->share_spdif = !!ucontrol->value.integer.value[0];
	return 0;
}

2585
static const struct snd_kcontrol_new spdif_share_sw = {
2586 2587 2588 2589 2590 2591 2592
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "IEC958 Default PCM Playback Switch",
	.info = snd_ctl_boolean_mono_info,
	.get = spdif_share_sw_get,
	.put = spdif_share_sw_put,
};

2593 2594 2595 2596 2597
/**
 * snd_hda_create_spdif_share_sw - create Default PCM switch
 * @codec: the HDA codec
 * @mout: multi-out instance
 */
2598 2599 2600
int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
				  struct hda_multi_out *mout)
{
2601 2602
	struct snd_kcontrol *kctl;

2603 2604
	if (!mout->dig_out_nid)
		return 0;
2605 2606 2607 2608

	kctl = snd_ctl_new1(&spdif_share_sw, mout);
	if (!kctl)
		return -ENOMEM;
2609
	/* ATTENTION: here mout is passed as private_data, instead of codec */
2610
	return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
2611
}
2612
EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
2613

L
Linus Torvalds 已提交
2614 2615 2616 2617 2618 2619
/*
 * SPDIF input
 */

#define snd_hda_spdif_in_switch_info	snd_hda_spdif_out_switch_info

T
Takashi Iwai 已提交
2620 2621
static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
				       struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
2622 2623 2624 2625 2626 2627 2628
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

	ucontrol->value.integer.value[0] = codec->spdif_in_enable;
	return 0;
}

T
Takashi Iwai 已提交
2629 2630
static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
				       struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
2631 2632 2633 2634 2635 2636
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = kcontrol->private_value;
	unsigned int val = !!ucontrol->value.integer.value[0];
	int change;

2637
	mutex_lock(&codec->spdif_mutex);
L
Linus Torvalds 已提交
2638
	change = codec->spdif_in_enable != val;
2639
	if (change) {
L
Linus Torvalds 已提交
2640
		codec->spdif_in_enable = val;
2641 2642
		snd_hdac_regmap_write(&codec->core, nid,
				      AC_VERB_SET_DIGI_CONVERT_1, val);
L
Linus Torvalds 已提交
2643
	}
2644
	mutex_unlock(&codec->spdif_mutex);
L
Linus Torvalds 已提交
2645 2646 2647
	return change;
}

T
Takashi Iwai 已提交
2648 2649
static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
				       struct snd_ctl_elem_value *ucontrol)
L
Linus Torvalds 已提交
2650 2651 2652
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = kcontrol->private_value;
2653
	unsigned int val;
L
Linus Torvalds 已提交
2654 2655
	unsigned int sbits;

2656 2657
	snd_hdac_regmap_read(&codec->core, nid,
			     AC_VERB_GET_DIGI_CONVERT_1, &val);
L
Linus Torvalds 已提交
2658 2659 2660 2661 2662 2663 2664 2665
	sbits = convert_to_spdif_status(val);
	ucontrol->value.iec958.status[0] = sbits;
	ucontrol->value.iec958.status[1] = sbits >> 8;
	ucontrol->value.iec958.status[2] = sbits >> 16;
	ucontrol->value.iec958.status[3] = sbits >> 24;
	return 0;
}

2666
static struct snd_kcontrol_new dig_in_ctls[] = {
L
Linus Torvalds 已提交
2667 2668
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2669
		.name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
L
Linus Torvalds 已提交
2670 2671 2672 2673 2674 2675 2676
		.info = snd_hda_spdif_in_switch_info,
		.get = snd_hda_spdif_in_switch_get,
		.put = snd_hda_spdif_in_switch_put,
	},
	{
		.access = SNDRV_CTL_ELEM_ACCESS_READ,
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2677
		.name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
L
Linus Torvalds 已提交
2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693
		.info = snd_hda_spdif_mask_info,
		.get = snd_hda_spdif_in_status_get,
	},
	{ } /* end */
};

/**
 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
 * @codec: the HDA codec
 * @nid: audio in widget NID
 *
 * Creates controls related with the SPDIF input.
 * Called from each patch supporting the SPDIF in.
 *
 * Returns 0 if successful, or a negative error code.
 */
2694
int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
L
Linus Torvalds 已提交
2695 2696
{
	int err;
2697 2698
	struct snd_kcontrol *kctl;
	struct snd_kcontrol_new *dig_mix;
2699
	int idx;
L
Linus Torvalds 已提交
2700

2701
	idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
2702
	if (idx < 0) {
2703
		codec_err(codec, "too many IEC958 inputs\n");
2704 2705
		return -EBUSY;
	}
L
Linus Torvalds 已提交
2706 2707
	for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
		kctl = snd_ctl_new1(dig_mix, codec);
2708 2709
		if (!kctl)
			return -ENOMEM;
L
Linus Torvalds 已提交
2710
		kctl->private_value = nid;
2711
		err = snd_hda_ctl_add(codec, nid, kctl);
T
Takashi Iwai 已提交
2712
		if (err < 0)
L
Linus Torvalds 已提交
2713 2714
			return err;
	}
T
Takashi Iwai 已提交
2715
	codec->spdif_in_enable =
2716 2717
		snd_hda_codec_read(codec, nid, 0,
				   AC_VERB_GET_DIGI_CONVERT_1, 0) &
T
Takashi Iwai 已提交
2718
		AC_DIG1_ENABLE;
L
Linus Torvalds 已提交
2719 2720
	return 0;
}
2721
EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
L
Linus Torvalds 已提交
2722

T
Takashi Iwai 已提交
2723 2724 2725 2726 2727 2728 2729 2730 2731 2732
/**
 * snd_hda_codec_set_power_to_all - Set the power state to all widgets
 * @codec: the HDA codec
 * @fg: function group (not used now)
 * @power_state: the power state to set (AC_PWRST_*)
 *
 * Set the given power state to all widgets that have the power control.
 * If the codec has power_filter set, it evaluates the power state and
 * filter out if it's unchanged as D3.
 */
2733
void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
2734
				    unsigned int power_state)
2735
{
2736
	hda_nid_t nid;
2737

2738
	for_each_hda_codec_node(nid, codec) {
2739
		unsigned int wcaps = get_wcaps(codec, nid);
2740
		unsigned int state = power_state;
2741 2742
		if (!(wcaps & AC_WCAP_POWER))
			continue;
2743 2744 2745
		if (codec->power_filter) {
			state = codec->power_filter(codec, nid, power_state);
			if (state != power_state && power_state == AC_PWRST_D3)
2746
				continue;
2747
		}
2748
		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
2749
				    state);
2750
	}
2751
}
2752
EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all);
2753

T
Takashi Iwai 已提交
2754 2755 2756 2757 2758 2759 2760 2761 2762
/**
 * snd_hda_codec_eapd_power_filter - A power filter callback for EAPD
 * @codec: the HDA codec
 * @nid: widget NID
 * @power_state: power state to evalue
 *
 * Don't power down the widget if it controls eapd and EAPD_BTLENABLE is set.
 * This can be used a codec power_filter callback.
 */
2763 2764 2765
unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
					     hda_nid_t nid,
					     unsigned int power_state)
2766
{
2767
	if (nid == codec->core.afg || nid == codec->core.mfg)
2768
		return power_state;
2769 2770 2771 2772 2773 2774 2775 2776 2777 2778
	if (power_state == AC_PWRST_D3 &&
	    get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
	    (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
		int eapd = snd_hda_codec_read(codec, nid, 0,
					      AC_VERB_GET_EAPD_BTLENABLE, 0);
		if (eapd & 0x02)
			return AC_PWRST_D0;
	}
	return power_state;
}
2779
EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter);
2780

2781
/*
2782
 * set power state of the codec, and return the power state
2783
 */
2784
static unsigned int hda_set_power_state(struct hda_codec *codec,
2785
					unsigned int power_state)
2786
{
2787
	hda_nid_t fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
2788 2789
	int count;
	unsigned int state;
2790
	int flags = 0;
2791

2792
	/* this delay seems necessary to avoid click noise at power-down */
2793
	if (power_state == AC_PWRST_D3) {
2794
		if (codec->depop_delay < 0)
2795
			msleep(codec_has_epss(codec) ? 10 : 100);
2796 2797
		else if (codec->depop_delay > 0)
			msleep(codec->depop_delay);
2798
		flags = HDA_RW_NO_RESPONSE_FALLBACK;
2799
	}
2800 2801 2802

	/* repeat power states setting at most 10 times*/
	for (count = 0; count < 10; count++) {
2803 2804 2805 2806
		if (codec->patch_ops.set_power_state)
			codec->patch_ops.set_power_state(codec, fg,
							 power_state);
		else {
2807 2808 2809 2810 2811 2812 2813
			state = power_state;
			if (codec->power_filter)
				state = codec->power_filter(codec, fg, state);
			if (state == power_state || power_state != AC_PWRST_D3)
				snd_hda_codec_read(codec, fg, flags,
						   AC_VERB_SET_POWER_STATE,
						   state);
2814
			snd_hda_codec_set_power_to_all(codec, fg, power_state);
2815
		}
2816
		state = snd_hda_sync_power_state(codec, fg, power_state);
2817 2818 2819
		if (!(state & AC_PWRST_ERROR))
			break;
	}
2820

2821
	return state;
2822
}
2823

2824 2825 2826 2827 2828
/* sync power states of all widgets;
 * this is called at the end of codec parsing
 */
static void sync_power_up_states(struct hda_codec *codec)
{
2829
	hda_nid_t nid;
2830

2831 2832
	/* don't care if no filter is used */
	if (!codec->power_filter)
2833 2834
		return;

2835
	for_each_hda_codec_node(nid, codec) {
2836
		unsigned int wcaps = get_wcaps(codec, nid);
2837
		unsigned int target;
2838 2839 2840 2841 2842
		if (!(wcaps & AC_WCAP_POWER))
			continue;
		target = codec->power_filter(codec, nid, AC_PWRST_D0);
		if (target == AC_PWRST_D0)
			continue;
2843
		if (!snd_hda_check_power_state(codec, nid, target))
2844 2845 2846 2847 2848
			snd_hda_codec_write(codec, nid, 0,
					    AC_VERB_SET_POWER_STATE, target);
	}
}

2849
#ifdef CONFIG_SND_HDA_RECONFIG
T
Takashi Iwai 已提交
2850 2851 2852 2853 2854 2855 2856 2857 2858 2859
/* execute additional init verbs */
static void hda_exec_init_verbs(struct hda_codec *codec)
{
	if (codec->init_verbs.list)
		snd_hda_sequence_write(codec, codec->init_verbs.list);
}
#else
static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
#endif

2860
#ifdef CONFIG_PM
2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877
/* update the power on/off account with the current jiffies */
static void update_power_acct(struct hda_codec *codec, bool on)
{
	unsigned long delta = jiffies - codec->power_jiffies;

	if (on)
		codec->power_on_acct += delta;
	else
		codec->power_off_acct += delta;
	codec->power_jiffies += delta;
}

void snd_hda_update_power_acct(struct hda_codec *codec)
{
	update_power_acct(codec, hda_codec_is_power_on(codec));
}

2878 2879
/*
 * call suspend and power-down; used both from PM and power-save
2880
 * this function returns the power state in the end
2881
 */
2882
static unsigned int hda_call_codec_suspend(struct hda_codec *codec)
2883
{
2884 2885
	unsigned int state;

2886
	snd_hdac_enter_pm(&codec->core);
2887
	if (codec->patch_ops.suspend)
2888
		codec->patch_ops.suspend(codec);
2889
	hda_cleanup_all_streams(codec);
2890
	state = hda_set_power_state(codec, AC_PWRST_D3);
2891
	update_power_acct(codec, true);
2892
	snd_hdac_leave_pm(&codec->core);
2893
	return state;
2894 2895
}

2896 2897 2898 2899 2900
/*
 * kick up codec; used both from PM and power-save
 */
static void hda_call_codec_resume(struct hda_codec *codec)
{
2901
	snd_hdac_enter_pm(&codec->core);
2902 2903 2904
	if (codec->core.regmap)
		regcache_mark_dirty(codec->core.regmap);

2905 2906
	codec->power_jiffies = jiffies;

2907
	hda_set_power_state(codec, AC_PWRST_D0);
2908
	restore_shutup_pins(codec);
T
Takashi Iwai 已提交
2909
	hda_exec_init_verbs(codec);
2910
	snd_hda_jack_set_dirty_all(codec);
2911 2912 2913
	if (codec->patch_ops.resume)
		codec->patch_ops.resume(codec);
	else {
2914 2915
		if (codec->patch_ops.init)
			codec->patch_ops.init(codec);
2916 2917
		if (codec->core.regmap)
			regcache_sync(codec->core.regmap);
2918
	}
2919 2920 2921

	if (codec->jackpoll_interval)
		hda_jackpoll_work(&codec->jackpoll_work.work);
2922
	else
2923
		snd_hda_jack_report_sync(codec);
2924
	codec->core.dev.power.power_state = PMSG_ON;
2925
	snd_hdac_leave_pm(&codec->core);
2926
}
2927

2928
static int hda_codec_runtime_suspend(struct device *dev)
2929 2930
{
	struct hda_codec *codec = dev_to_hda_codec(dev);
2931
	unsigned int state;
2932 2933

	cancel_delayed_work_sync(&codec->jackpoll_work);
2934
	state = hda_call_codec_suspend(codec);
2935 2936 2937
	if (codec->link_down_at_suspend ||
	    (codec_has_clkstop(codec) && codec_has_epss(codec) &&
	     (state & AC_PWRST_CLK_STOP_OK)))
2938
		snd_hdac_codec_link_down(&codec->core);
2939
	codec_display_power(codec, false);
2940 2941 2942
	return 0;
}

2943
static int hda_codec_runtime_resume(struct device *dev)
2944
{
2945 2946
	struct hda_codec *codec = dev_to_hda_codec(dev);

2947
	codec_display_power(codec, true);
2948
	snd_hdac_codec_link_up(&codec->core);
2949
	hda_call_codec_resume(codec);
2950
	pm_runtime_mark_last_busy(dev);
2951 2952
	return 0;
}
2953
#endif /* CONFIG_PM */
2954

2955
#ifdef CONFIG_PM_SLEEP
2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969
static int hda_codec_force_resume(struct device *dev)
{
	int ret;

	/* The get/put pair below enforces the runtime resume even if the
	 * device hasn't been used at suspend time.  This trick is needed to
	 * update the jack state change during the sleep.
	 */
	pm_runtime_get_noresume(dev);
	ret = pm_runtime_force_resume(dev);
	pm_runtime_put(dev);
	return ret;
}

2970 2971 2972 2973 2974 2975 2976 2977 2978
static int hda_codec_pm_suspend(struct device *dev)
{
	dev->power.power_state = PMSG_SUSPEND;
	return pm_runtime_force_suspend(dev);
}

static int hda_codec_pm_resume(struct device *dev)
{
	dev->power.power_state = PMSG_RESUME;
2979
	return hda_codec_force_resume(dev);
2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990
}

static int hda_codec_pm_freeze(struct device *dev)
{
	dev->power.power_state = PMSG_FREEZE;
	return pm_runtime_force_suspend(dev);
}

static int hda_codec_pm_thaw(struct device *dev)
{
	dev->power.power_state = PMSG_THAW;
2991
	return hda_codec_force_resume(dev);
2992 2993 2994 2995 2996
}

static int hda_codec_pm_restore(struct device *dev)
{
	dev->power.power_state = PMSG_RESTORE;
2997
	return hda_codec_force_resume(dev);
2998 2999 3000
}
#endif /* CONFIG_PM_SLEEP */

3001 3002
/* referred in hda_bind.c */
const struct dev_pm_ops hda_codec_driver_pm = {
3003 3004 3005 3006 3007 3008 3009 3010
#ifdef CONFIG_PM_SLEEP
	.suspend = hda_codec_pm_suspend,
	.resume = hda_codec_pm_resume,
	.freeze = hda_codec_pm_freeze,
	.thaw = hda_codec_pm_thaw,
	.poweroff = hda_codec_pm_suspend,
	.restore = hda_codec_pm_restore,
#endif /* CONFIG_PM_SLEEP */
3011 3012
	SET_RUNTIME_PM_OPS(hda_codec_runtime_suspend, hda_codec_runtime_resume,
			   NULL)
3013
};
3014

3015 3016 3017 3018 3019
/*
 * add standard channel maps if not specified
 */
static int add_std_chmaps(struct hda_codec *codec)
{
3020 3021
	struct hda_pcm *pcm;
	int str, err;
3022

3023
	list_for_each_entry(pcm, &codec->pcm_list_head, list) {
3024
		for (str = 0; str < 2; str++) {
3025
			struct hda_pcm_stream *hinfo = &pcm->stream[str];
3026
			struct snd_pcm_chmap *chmap;
3027
			const struct snd_pcm_chmap_elem *elem;
3028

3029
			if (!pcm->pcm || pcm->own_chmap || !hinfo->substreams)
3030
				continue;
3031
			elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
3032
			err = snd_pcm_add_chmap_ctls(pcm->pcm, str, elem,
3033 3034 3035 3036 3037 3038 3039 3040 3041 3042
						     hinfo->channels_max,
						     0, &chmap);
			if (err < 0)
				return err;
			chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
		}
	}
	return 0;
}

3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055
/* default channel maps for 2.1 speakers;
 * since HD-audio supports only stereo, odd number channels are omitted
 */
const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
	{ .channels = 2,
	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
	{ .channels = 4,
	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
		   SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
	{ }
};
EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);

3056 3057 3058
int snd_hda_codec_build_controls(struct hda_codec *codec)
{
	int err = 0;
T
Takashi Iwai 已提交
3059
	hda_exec_init_verbs(codec);
3060 3061 3062 3063 3064 3065 3066
	/* continue to initialize... */
	if (codec->patch_ops.init)
		err = codec->patch_ops.init(codec);
	if (!err && codec->patch_ops.build_controls)
		err = codec->patch_ops.build_controls(codec);
	if (err < 0)
		return err;
3067 3068 3069 3070 3071 3072

	/* we create chmaps here instead of build_pcms */
	err = add_std_chmaps(codec);
	if (err < 0)
		return err;

3073 3074 3075 3076
	if (codec->jackpoll_interval)
		hda_jackpoll_work(&codec->jackpoll_work.work);
	else
		snd_hda_jack_report_sync(codec); /* call at the last init point */
3077
	sync_power_up_states(codec);
L
Linus Torvalds 已提交
3078 3079
	return 0;
}
3080
EXPORT_SYMBOL_GPL(snd_hda_codec_build_controls);
L
Linus Torvalds 已提交
3081 3082 3083 3084 3085 3086

/*
 * PCM stuff
 */
static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
				      struct hda_codec *codec,
3087
				      struct snd_pcm_substream *substream)
L
Linus Torvalds 已提交
3088 3089 3090 3091 3092 3093 3094 3095
{
	return 0;
}

static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
				   struct hda_codec *codec,
				   unsigned int stream_tag,
				   unsigned int format,
3096
				   struct snd_pcm_substream *substream)
L
Linus Torvalds 已提交
3097 3098 3099 3100 3101 3102 3103
{
	snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
	return 0;
}

static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
				   struct hda_codec *codec,
3104
				   struct snd_pcm_substream *substream)
L
Linus Torvalds 已提交
3105
{
3106
	snd_hda_codec_cleanup_stream(codec, hinfo->nid);
L
Linus Torvalds 已提交
3107 3108 3109
	return 0;
}

3110 3111
static int set_pcm_default_values(struct hda_codec *codec,
				  struct hda_pcm_stream *info)
L
Linus Torvalds 已提交
3112
{
3113 3114
	int err;

T
Takashi Iwai 已提交
3115 3116
	/* query support PCM information from the given NID */
	if (info->nid && (!info->rates || !info->formats)) {
3117
		err = snd_hda_query_supported_pcm(codec, info->nid,
T
Takashi Iwai 已提交
3118 3119 3120
				info->rates ? NULL : &info->rates,
				info->formats ? NULL : &info->formats,
				info->maxbps ? NULL : &info->maxbps);
3121 3122
		if (err < 0)
			return err;
L
Linus Torvalds 已提交
3123 3124 3125 3126 3127 3128
	}
	if (info->ops.open == NULL)
		info->ops.open = hda_pcm_default_open_close;
	if (info->ops.close == NULL)
		info->ops.close = hda_pcm_default_open_close;
	if (info->ops.prepare == NULL) {
3129 3130
		if (snd_BUG_ON(!info->nid))
			return -EINVAL;
L
Linus Torvalds 已提交
3131 3132 3133
		info->ops.prepare = hda_pcm_default_prepare;
	}
	if (info->ops.cleanup == NULL) {
3134 3135
		if (snd_BUG_ON(!info->nid))
			return -EINVAL;
L
Linus Torvalds 已提交
3136 3137 3138 3139 3140
		info->ops.cleanup = hda_pcm_default_cleanup;
	}
	return 0;
}

3141 3142 3143
/*
 * codec prepare/cleanup entries
 */
T
Takashi Iwai 已提交
3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154
/**
 * snd_hda_codec_prepare - Prepare a stream
 * @codec: the HDA codec
 * @hinfo: PCM information
 * @stream: stream tag to assign
 * @format: format id to assign
 * @substream: PCM substream to assign
 *
 * Calls the prepare callback set by the codec with the given arguments.
 * Clean up the inactive streams when successful.
 */
3155 3156 3157 3158 3159 3160 3161
int snd_hda_codec_prepare(struct hda_codec *codec,
			  struct hda_pcm_stream *hinfo,
			  unsigned int stream,
			  unsigned int format,
			  struct snd_pcm_substream *substream)
{
	int ret;
3162
	mutex_lock(&codec->bus->prepare_mutex);
3163 3164 3165 3166 3167
	if (hinfo->ops.prepare)
		ret = hinfo->ops.prepare(hinfo, codec, stream, format,
					 substream);
	else
		ret = -ENODEV;
3168 3169
	if (ret >= 0)
		purify_inactive_streams(codec);
3170
	mutex_unlock(&codec->bus->prepare_mutex);
3171 3172
	return ret;
}
3173
EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
3174

T
Takashi Iwai 已提交
3175 3176 3177 3178 3179 3180 3181 3182
/**
 * snd_hda_codec_cleanup - Prepare a stream
 * @codec: the HDA codec
 * @hinfo: PCM information
 * @substream: PCM substream
 *
 * Calls the cleanup callback set by the codec with the given arguments.
 */
3183 3184 3185 3186
void snd_hda_codec_cleanup(struct hda_codec *codec,
			   struct hda_pcm_stream *hinfo,
			   struct snd_pcm_substream *substream)
{
3187
	mutex_lock(&codec->bus->prepare_mutex);
3188 3189
	if (hinfo->ops.cleanup)
		hinfo->ops.cleanup(hinfo, codec, substream);
3190
	mutex_unlock(&codec->bus->prepare_mutex);
3191
}
3192
EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
3193

3194
/* global */
3195 3196 3197 3198
const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
	"Audio", "SPDIF", "HDMI", "Modem"
};

T
Takashi Iwai 已提交
3199 3200 3201
/*
 * get the empty PCM device number to assign
 */
3202
static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type)
T
Takashi Iwai 已提交
3203
{
3204
	/* audio device indices; not linear to keep compatibility */
3205 3206 3207
	/* assigned to static slots up to dev#10; if more needed, assign
	 * the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y)
	 */
3208 3209 3210
	static int audio_idx[HDA_PCM_NTYPES][5] = {
		[HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
		[HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3211
		[HDA_PCM_TYPE_HDMI]  = { 3, 7, 8, 9, -1 },
3212
		[HDA_PCM_TYPE_MODEM] = { 6, -1 },
T
Takashi Iwai 已提交
3213
	};
3214 3215 3216
	int i;

	if (type >= HDA_PCM_NTYPES) {
3217
		dev_err(bus->card->dev, "Invalid PCM type %d\n", type);
T
Takashi Iwai 已提交
3218 3219
		return -EINVAL;
	}
3220

3221 3222 3223 3224 3225
	for (i = 0; audio_idx[type][i] >= 0; i++) {
#ifndef CONFIG_SND_DYNAMIC_MINORS
		if (audio_idx[type][i] >= 8)
			break;
#endif
3226 3227
		if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
			return audio_idx[type][i];
3228
	}
3229

3230
#ifdef CONFIG_SND_DYNAMIC_MINORS
3231 3232 3233 3234 3235
	/* non-fixed slots starting from 10 */
	for (i = 10; i < 32; i++) {
		if (!test_and_set_bit(i, bus->pcm_dev_bits))
			return i;
	}
3236
#endif
3237

3238
	dev_warn(bus->card->dev, "Too many %s devices\n",
3239
		snd_hda_pcm_type_name[type]);
3240
#ifndef CONFIG_SND_DYNAMIC_MINORS
3241 3242
	dev_warn(bus->card->dev,
		 "Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n");
3243
#endif
3244
	return -EAGAIN;
T
Takashi Iwai 已提交
3245 3246
}

3247 3248
/* call build_pcms ops of the given codec and set up the default parameters */
int snd_hda_codec_parse_pcms(struct hda_codec *codec)
3249
{
3250
	struct hda_pcm *cpcm;
3251
	int err;
3252

3253
	if (!list_empty(&codec->pcm_list_head))
3254 3255 3256 3257 3258 3259 3260 3261
		return 0; /* already parsed */

	if (!codec->patch_ops.build_pcms)
		return 0;

	err = codec->patch_ops.build_pcms(codec);
	if (err < 0) {
		codec_err(codec, "cannot build PCMs for #%d (error %d)\n",
3262
			  codec->core.addr, err);
3263 3264 3265
		return err;
	}

3266
	list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
3267 3268 3269 3270 3271 3272 3273
		int stream;

		for (stream = 0; stream < 2; stream++) {
			struct hda_pcm_stream *info = &cpcm->stream[stream];

			if (!info->substreams)
				continue;
3274
			err = set_pcm_default_values(codec, info);
3275 3276 3277 3278
			if (err < 0) {
				codec_warn(codec,
					   "fail to setup default for PCM %s\n",
					   cpcm->name);
3279
				return err;
3280
			}
3281 3282
		}
	}
3283 3284

	return 0;
3285
}
3286
EXPORT_SYMBOL_GPL(snd_hda_codec_parse_pcms);
3287

T
Takashi Iwai 已提交
3288 3289 3290
/* assign all PCMs of the given codec */
int snd_hda_codec_build_pcms(struct hda_codec *codec)
{
3291
	struct hda_bus *bus = codec->bus;
3292
	struct hda_pcm *cpcm;
3293
	int dev, err;
T
Takashi Iwai 已提交
3294

3295
	err = snd_hda_codec_parse_pcms(codec);
3296
	if (err < 0)
3297 3298 3299
		return err;

	/* attach a new PCM streams */
3300
	list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
3301 3302
		if (cpcm->pcm)
			continue; /* already attached */
T
Takashi Iwai 已提交
3303
		if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
3304
			continue; /* no substreams assigned */
T
Takashi Iwai 已提交
3305

3306
		dev = get_empty_pcm_device(bus, cpcm->pcm_type);
3307 3308
		if (dev < 0) {
			cpcm->device = SNDRV_PCM_INVALID_DEVICE;
3309
			continue; /* no fatal error */
3310
		}
3311
		cpcm->device = dev;
3312
		err =  snd_hda_attach_pcm_stream(bus, codec, cpcm);
3313 3314 3315
		if (err < 0) {
			codec_err(codec,
				  "cannot attach PCM stream %d for codec #%d\n",
3316
				  dev, codec->core.addr);
3317
			continue; /* no fatal error */
T
Takashi Iwai 已提交
3318 3319
		}
	}
3320

T
Takashi Iwai 已提交
3321 3322 3323
	return 0;
}

L
Linus Torvalds 已提交
3324 3325 3326
/**
 * snd_hda_add_new_ctls - create controls from the array
 * @codec: the HDA codec
3327
 * @knew: the array of struct snd_kcontrol_new
L
Linus Torvalds 已提交
3328 3329 3330 3331 3332 3333
 *
 * This helper function creates and add new controls in the given array.
 * The array must be terminated with an empty entry as terminator.
 *
 * Returns 0 if successful, or a negative error code.
 */
3334 3335
int snd_hda_add_new_ctls(struct hda_codec *codec,
			 const struct snd_kcontrol_new *knew)
L
Linus Torvalds 已提交
3336
{
3337
	int err;
L
Linus Torvalds 已提交
3338 3339

	for (; knew->name; knew++) {
3340
		struct snd_kcontrol *kctl;
3341
		int addr = 0, idx = 0;
3342 3343
		if (knew->iface == (__force snd_ctl_elem_iface_t)-1)
			continue; /* skip this codec private value */
3344
		for (;;) {
3345
			kctl = snd_ctl_new1(knew, codec);
T
Takashi Iwai 已提交
3346
			if (!kctl)
3347
				return -ENOMEM;
3348 3349 3350 3351
			if (addr > 0)
				kctl->id.device = addr;
			if (idx > 0)
				kctl->id.index = idx;
3352
			err = snd_hda_ctl_add(codec, 0, kctl);
3353 3354 3355 3356 3357 3358
			if (!err)
				break;
			/* try first with another device index corresponding to
			 * the codec addr; if it still fails (or it's the
			 * primary codec), then try another control index
			 */
3359 3360
			if (!addr && codec->core.addr)
				addr = codec->core.addr;
3361 3362
			else if (!idx && !knew->index) {
				idx = find_empty_mixer_ctl_idx(codec,
3363
							       knew->name, 0);
3364 3365 3366
				if (idx <= 0)
					return err;
			} else
3367 3368
				return err;
		}
L
Linus Torvalds 已提交
3369 3370 3371
	}
	return 0;
}
3372
EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
L
Linus Torvalds 已提交
3373

3374
#ifdef CONFIG_PM
3375
static void codec_set_power_save(struct hda_codec *codec, int delay)
3376
{
3377 3378
	struct device *dev = hda_codec_dev(codec);

3379 3380 3381
	if (delay == 0 && codec->auto_runtime_pm)
		delay = 3000;

3382 3383 3384 3385 3386 3387 3388 3389 3390 3391
	if (delay > 0) {
		pm_runtime_set_autosuspend_delay(dev, delay);
		pm_runtime_use_autosuspend(dev);
		pm_runtime_allow(dev);
		if (!pm_runtime_suspended(dev))
			pm_runtime_mark_last_busy(dev);
	} else {
		pm_runtime_dont_use_autosuspend(dev);
		pm_runtime_forbid(dev);
	}
3392
}
3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404

/**
 * snd_hda_set_power_save - reprogram autosuspend for the given delay
 * @bus: HD-audio bus
 * @delay: autosuspend delay in msec, 0 = off
 *
 * Synchronize the runtime PM autosuspend state from the power_save option.
 */
void snd_hda_set_power_save(struct hda_bus *bus, int delay)
{
	struct hda_codec *c;

3405
	list_for_each_codec(c, bus)
3406 3407 3408
		codec_set_power_save(c, delay);
}
EXPORT_SYMBOL_GPL(snd_hda_set_power_save);
3409

3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421
/**
 * snd_hda_check_amp_list_power - Check the amp list and update the power
 * @codec: HD-audio codec
 * @check: the object containing an AMP list and the status
 * @nid: NID to check / update
 *
 * Check whether the given NID is in the amp list.  If it's in the list,
 * check the current AMP status, and update the the power-status according
 * to the mute status.
 *
 * This function is supposed to be set or called from the check_power_status
 * patch ops.
3422
 */
3423 3424 3425 3426
int snd_hda_check_amp_list_power(struct hda_codec *codec,
				 struct hda_loopback_check *check,
				 hda_nid_t nid)
{
3427
	const struct hda_amp_list *p;
3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445
	int ch, v;

	if (!check->amplist)
		return 0;
	for (p = check->amplist; p->nid; p++) {
		if (p->nid == nid)
			break;
	}
	if (!p->nid)
		return 0; /* nothing changed */

	for (p = check->amplist; p->nid; p++) {
		for (ch = 0; ch < 2; ch++) {
			v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
						   p->idx);
			if (!(v & HDA_AMP_MUTE) && v > 0) {
				if (!check->power_on) {
					check->power_on = 1;
3446
					snd_hda_power_up_pm(codec);
3447 3448 3449 3450 3451 3452 3453
				}
				return 1;
			}
		}
	}
	if (check->power_on) {
		check->power_on = 0;
3454
		snd_hda_power_down_pm(codec);
3455 3456 3457
	}
	return 0;
}
3458
EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
3459
#endif
L
Linus Torvalds 已提交
3460 3461 3462 3463

/*
 * input MUX helper
 */
3464 3465 3466

/**
 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
3467 3468
 * @imux: imux helper object
 * @uinfo: pointer to get/store the data
3469
 */
T
Takashi Iwai 已提交
3470 3471
int snd_hda_input_mux_info(const struct hda_input_mux *imux,
			   struct snd_ctl_elem_info *uinfo)
L
Linus Torvalds 已提交
3472 3473 3474 3475 3476 3477
{
	unsigned int index;

	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	uinfo->count = 1;
	uinfo->value.enumerated.items = imux->num_items;
3478 3479
	if (!imux->num_items)
		return 0;
L
Linus Torvalds 已提交
3480 3481 3482 3483 3484 3485
	index = uinfo->value.enumerated.item;
	if (index >= imux->num_items)
		index = imux->num_items - 1;
	strcpy(uinfo->value.enumerated.name, imux->items[index].label);
	return 0;
}
3486
EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
L
Linus Torvalds 已提交
3487

3488 3489
/**
 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
3490 3491 3492 3493 3494
 * @codec: the HDA codec
 * @imux: imux helper object
 * @ucontrol: pointer to get/store the data
 * @nid: input mux NID
 * @cur_val: pointer to get/store the current imux value
3495
 */
T
Takashi Iwai 已提交
3496 3497 3498 3499
int snd_hda_input_mux_put(struct hda_codec *codec,
			  const struct hda_input_mux *imux,
			  struct snd_ctl_elem_value *ucontrol,
			  hda_nid_t nid,
L
Linus Torvalds 已提交
3500 3501 3502 3503
			  unsigned int *cur_val)
{
	unsigned int idx;

3504 3505
	if (!imux->num_items)
		return 0;
L
Linus Torvalds 已提交
3506 3507 3508
	idx = ucontrol->value.enumerated.item[0];
	if (idx >= imux->num_items)
		idx = imux->num_items - 1;
3509
	if (*cur_val == idx)
L
Linus Torvalds 已提交
3510
		return 0;
3511 3512
	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
				  imux->items[idx].index);
L
Linus Torvalds 已提交
3513 3514 3515
	*cur_val = idx;
	return 1;
}
3516
EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
L
Linus Torvalds 已提交
3517 3518


3519 3520 3521 3522 3523 3524 3525
/**
 * snd_hda_enum_helper_info - Helper for simple enum ctls
 * @kcontrol: ctl element
 * @uinfo: pointer to get/store the data
 * @num_items: number of enum items
 * @texts: enum item string array
 *
3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541
 * process kcontrol info callback of a simple string enum array
 * when @num_items is 0 or @texts is NULL, assume a boolean enum array
 */
int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
			     struct snd_ctl_elem_info *uinfo,
			     int num_items, const char * const *texts)
{
	static const char * const texts_default[] = {
		"Disabled", "Enabled"
	};

	if (!texts || !num_items) {
		num_items = 2;
		texts = texts_default;
	}

T
Takashi Iwai 已提交
3542
	return snd_ctl_enum_info(uinfo, 1, num_items, texts);
3543
}
3544
EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info);
3545

L
Linus Torvalds 已提交
3546 3547 3548 3549
/*
 * Multi-channel / digital-out PCM helper functions
 */

3550 3551 3552 3553
/* setup SPDIF output stream */
static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
				 unsigned int stream_tag, unsigned int format)
{
3554 3555 3556 3557 3558
	struct hda_spdif_out *spdif;
	unsigned int curr_fmt;
	bool reset;

	spdif = snd_hda_spdif_out_of_nid(codec, nid);
3559 3560 3561 3562 3563 3564
	/* Add sanity check to pass klockwork check.
	 * This should never happen.
	 */
	if (WARN_ON(spdif == NULL))
		return;

3565 3566 3567 3568 3569 3570 3571 3572 3573
	curr_fmt = snd_hda_codec_read(codec, nid, 0,
				      AC_VERB_GET_STREAM_FORMAT, 0);
	reset = codec->spdif_status_reset &&
		(spdif->ctls & AC_DIG1_ENABLE) &&
		curr_fmt != format;

	/* turn off SPDIF if needed; otherwise the IEC958 bits won't be
	   updated */
	if (reset)
3574
		set_dig_out_convert(codec, nid,
3575
				    spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
3576
				    -1);
3577
	snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3578
	if (codec->slave_dig_outs) {
3579
		const hda_nid_t *d;
3580 3581 3582 3583
		for (d = codec->slave_dig_outs; *d; d++)
			snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
						   format);
	}
3584
	/* turn on again (if needed) */
3585
	if (reset)
3586
		set_dig_out_convert(codec, nid,
3587
				    spdif->ctls & 0xff, -1);
3588
}
3589

3590 3591 3592 3593
static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
{
	snd_hda_codec_cleanup_stream(codec, nid);
	if (codec->slave_dig_outs) {
3594
		const hda_nid_t *d;
3595 3596
		for (d = codec->slave_dig_outs; *d; d++)
			snd_hda_codec_cleanup_stream(codec, *d);
3597
	}
3598 3599
}

3600 3601
/**
 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
3602 3603
 * @codec: the HDA codec
 * @mout: hda_multi_out object
L
Linus Torvalds 已提交
3604
 */
T
Takashi Iwai 已提交
3605 3606
int snd_hda_multi_out_dig_open(struct hda_codec *codec,
			       struct hda_multi_out *mout)
L
Linus Torvalds 已提交
3607
{
3608
	mutex_lock(&codec->spdif_mutex);
3609 3610
	if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
		/* already opened as analog dup; reset it once */
3611
		cleanup_dig_out_stream(codec, mout->dig_out_nid);
L
Linus Torvalds 已提交
3612
	mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3613
	mutex_unlock(&codec->spdif_mutex);
L
Linus Torvalds 已提交
3614 3615
	return 0;
}
3616
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
L
Linus Torvalds 已提交
3617

3618 3619
/**
 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
3620 3621 3622 3623 3624
 * @codec: the HDA codec
 * @mout: hda_multi_out object
 * @stream_tag: stream tag to assign
 * @format: format id to assign
 * @substream: PCM substream to assign
3625
 */
3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636
int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
				  struct hda_multi_out *mout,
				  unsigned int stream_tag,
				  unsigned int format,
				  struct snd_pcm_substream *substream)
{
	mutex_lock(&codec->spdif_mutex);
	setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
	mutex_unlock(&codec->spdif_mutex);
	return 0;
}
3637
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
3638

3639 3640
/**
 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
3641 3642
 * @codec: the HDA codec
 * @mout: hda_multi_out object
3643
 */
3644 3645 3646 3647 3648 3649 3650 3651
int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
				  struct hda_multi_out *mout)
{
	mutex_lock(&codec->spdif_mutex);
	cleanup_dig_out_stream(codec, mout->dig_out_nid);
	mutex_unlock(&codec->spdif_mutex);
	return 0;
}
3652
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
3653

3654 3655
/**
 * snd_hda_multi_out_dig_close - release the digital out stream
3656 3657
 * @codec: the HDA codec
 * @mout: hda_multi_out object
L
Linus Torvalds 已提交
3658
 */
T
Takashi Iwai 已提交
3659 3660
int snd_hda_multi_out_dig_close(struct hda_codec *codec,
				struct hda_multi_out *mout)
L
Linus Torvalds 已提交
3661
{
3662
	mutex_lock(&codec->spdif_mutex);
L
Linus Torvalds 已提交
3663
	mout->dig_out_used = 0;
3664
	mutex_unlock(&codec->spdif_mutex);
L
Linus Torvalds 已提交
3665 3666
	return 0;
}
3667
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
L
Linus Torvalds 已提交
3668

3669 3670
/**
 * snd_hda_multi_out_analog_open - open analog outputs
3671 3672 3673 3674
 * @codec: the HDA codec
 * @mout: hda_multi_out object
 * @substream: PCM substream to assign
 * @hinfo: PCM information to assign
3675 3676 3677 3678
 *
 * Open analog outputs and set up the hw-constraints.
 * If the digital outputs can be opened as slave, open the digital
 * outputs, too.
L
Linus Torvalds 已提交
3679
 */
T
Takashi Iwai 已提交
3680 3681
int snd_hda_multi_out_analog_open(struct hda_codec *codec,
				  struct hda_multi_out *mout,
3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704
				  struct snd_pcm_substream *substream,
				  struct hda_pcm_stream *hinfo)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	runtime->hw.channels_max = mout->max_channels;
	if (mout->dig_out_nid) {
		if (!mout->analog_rates) {
			mout->analog_rates = hinfo->rates;
			mout->analog_formats = hinfo->formats;
			mout->analog_maxbps = hinfo->maxbps;
		} else {
			runtime->hw.rates = mout->analog_rates;
			runtime->hw.formats = mout->analog_formats;
			hinfo->maxbps = mout->analog_maxbps;
		}
		if (!mout->spdif_rates) {
			snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
						    &mout->spdif_rates,
						    &mout->spdif_formats,
						    &mout->spdif_maxbps);
		}
		mutex_lock(&codec->spdif_mutex);
		if (mout->share_spdif) {
3705 3706 3707 3708 3709 3710 3711 3712 3713 3714
			if ((runtime->hw.rates & mout->spdif_rates) &&
			    (runtime->hw.formats & mout->spdif_formats)) {
				runtime->hw.rates &= mout->spdif_rates;
				runtime->hw.formats &= mout->spdif_formats;
				if (mout->spdif_maxbps < hinfo->maxbps)
					hinfo->maxbps = mout->spdif_maxbps;
			} else {
				mout->share_spdif = 0;
				/* FIXME: need notify? */
			}
3715
		}
3716
		mutex_unlock(&codec->spdif_mutex);
3717
	}
L
Linus Torvalds 已提交
3718 3719 3720
	return snd_pcm_hw_constraint_step(substream->runtime, 0,
					  SNDRV_PCM_HW_PARAM_CHANNELS, 2);
}
3721
EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
L
Linus Torvalds 已提交
3722

3723 3724
/**
 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
3725 3726 3727 3728 3729
 * @codec: the HDA codec
 * @mout: hda_multi_out object
 * @stream_tag: stream tag to assign
 * @format: format id to assign
 * @substream: PCM substream to assign
3730 3731 3732
 *
 * Set up the i/o for analog out.
 * When the digital out is available, copy the front out to digital out, too.
L
Linus Torvalds 已提交
3733
 */
T
Takashi Iwai 已提交
3734 3735
int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
				     struct hda_multi_out *mout,
L
Linus Torvalds 已提交
3736 3737
				     unsigned int stream_tag,
				     unsigned int format,
3738
				     struct snd_pcm_substream *substream)
L
Linus Torvalds 已提交
3739
{
3740
	const hda_nid_t *nids = mout->dac_nids;
L
Linus Torvalds 已提交
3741
	int chs = substream->runtime->channels;
3742
	struct hda_spdif_out *spdif;
L
Linus Torvalds 已提交
3743 3744
	int i;

3745
	mutex_lock(&codec->spdif_mutex);
3746
	spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
3747 3748
	if (mout->dig_out_nid && mout->share_spdif &&
	    mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3749
		if (chs == 2 && spdif != NULL &&
T
Takashi Iwai 已提交
3750 3751
		    snd_hda_is_supported_format(codec, mout->dig_out_nid,
						format) &&
3752
		    !(spdif->status & IEC958_AES0_NONAUDIO)) {
L
Linus Torvalds 已提交
3753
			mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3754 3755
			setup_dig_out_stream(codec, mout->dig_out_nid,
					     stream_tag, format);
L
Linus Torvalds 已提交
3756 3757
		} else {
			mout->dig_out_used = 0;
3758
			cleanup_dig_out_stream(codec, mout->dig_out_nid);
L
Linus Torvalds 已提交
3759 3760
		}
	}
3761
	mutex_unlock(&codec->spdif_mutex);
L
Linus Torvalds 已提交
3762 3763

	/* front */
T
Takashi Iwai 已提交
3764 3765
	snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
				   0, format);
3766 3767
	if (!mout->no_share_stream &&
	    mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
L
Linus Torvalds 已提交
3768
		/* headphone out will just decode front left/right (stereo) */
T
Takashi Iwai 已提交
3769 3770
		snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
					   0, format);
3771
	/* extra outputs copied from front */
3772 3773 3774 3775 3776
	for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
		if (!mout->no_share_stream && mout->hp_out_nid[i])
			snd_hda_codec_setup_stream(codec,
						   mout->hp_out_nid[i],
						   stream_tag, 0, format);
3777

L
Linus Torvalds 已提交
3778 3779
	/* surrounds */
	for (i = 1; i < mout->num_dacs; i++) {
3780
		if (chs >= (i + 1) * 2) /* independent out */
T
Takashi Iwai 已提交
3781 3782
			snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
						   i * 2, format);
3783
		else if (!mout->no_share_stream) /* copy front */
T
Takashi Iwai 已提交
3784 3785
			snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
						   0, format);
L
Linus Torvalds 已提交
3786
	}
3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800

	/* extra surrounds */
	for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) {
		int ch = 0;
		if (!mout->extra_out_nid[i])
			break;
		if (chs >= (i + 1) * 2)
			ch = i * 2;
		else if (!mout->no_share_stream)
			break;
		snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i],
					   stream_tag, ch, format);
	}

L
Linus Torvalds 已提交
3801 3802
	return 0;
}
3803
EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
L
Linus Torvalds 已提交
3804

3805 3806
/**
 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
3807 3808
 * @codec: the HDA codec
 * @mout: hda_multi_out object
L
Linus Torvalds 已提交
3809
 */
T
Takashi Iwai 已提交
3810 3811
int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
				     struct hda_multi_out *mout)
L
Linus Torvalds 已提交
3812
{
3813
	const hda_nid_t *nids = mout->dac_nids;
L
Linus Torvalds 已提交
3814 3815 3816
	int i;

	for (i = 0; i < mout->num_dacs; i++)
3817
		snd_hda_codec_cleanup_stream(codec, nids[i]);
L
Linus Torvalds 已提交
3818
	if (mout->hp_nid)
3819
		snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3820 3821 3822 3823
	for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
		if (mout->hp_out_nid[i])
			snd_hda_codec_cleanup_stream(codec,
						     mout->hp_out_nid[i]);
3824 3825
	for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
		if (mout->extra_out_nid[i])
3826 3827
			snd_hda_codec_cleanup_stream(codec,
						     mout->extra_out_nid[i]);
3828
	mutex_lock(&codec->spdif_mutex);
L
Linus Torvalds 已提交
3829
	if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3830
		cleanup_dig_out_stream(codec, mout->dig_out_nid);
L
Linus Torvalds 已提交
3831 3832
		mout->dig_out_used = 0;
	}
3833
	mutex_unlock(&codec->spdif_mutex);
L
Linus Torvalds 已提交
3834 3835
	return 0;
}
3836
EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
L
Linus Torvalds 已提交
3837

3838 3839
/**
 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
3840 3841
 * @codec: the HDA codec
 * @pin: referred pin NID
3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864
 *
 * Guess the suitable VREF pin bits to be set as the pin-control value.
 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
 */
unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
{
	unsigned int pincap;
	unsigned int oldval;
	oldval = snd_hda_codec_read(codec, pin, 0,
				    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
	pincap = snd_hda_query_pin_caps(codec, pin);
	pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
	/* Exception: if the default pin setup is vref50, we give it priority */
	if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
		return AC_PINCTL_VREF_80;
	else if (pincap & AC_PINCAP_VREF_50)
		return AC_PINCTL_VREF_50;
	else if (pincap & AC_PINCAP_VREF_100)
		return AC_PINCTL_VREF_100;
	else if (pincap & AC_PINCAP_VREF_GRD)
		return AC_PINCTL_VREF_GRD;
	return AC_PINCTL_VREF_HIZ;
}
3865
EXPORT_SYMBOL_GPL(snd_hda_get_default_vref);
3866

3867 3868 3869 3870 3871 3872
/**
 * snd_hda_correct_pin_ctl - correct the pin ctl value for matching with the pin cap
 * @codec: the HDA codec
 * @pin: referred pin NID
 * @val: pin ctl value to audit
 */
3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920
unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
				     hda_nid_t pin, unsigned int val)
{
	static unsigned int cap_lists[][2] = {
		{ AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
		{ AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
		{ AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
		{ AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
	};
	unsigned int cap;

	if (!val)
		return 0;
	cap = snd_hda_query_pin_caps(codec, pin);
	if (!cap)
		return val; /* don't know what to do... */

	if (val & AC_PINCTL_OUT_EN) {
		if (!(cap & AC_PINCAP_OUT))
			val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
		else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
			val &= ~AC_PINCTL_HP_EN;
	}

	if (val & AC_PINCTL_IN_EN) {
		if (!(cap & AC_PINCAP_IN))
			val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
		else {
			unsigned int vcap, vref;
			int i;
			vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
			vref = val & AC_PINCTL_VREFEN;
			for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
				if (vref == cap_lists[i][0] &&
				    !(vcap & cap_lists[i][1])) {
					if (i == ARRAY_SIZE(cap_lists) - 1)
						vref = AC_PINCTL_VREF_HIZ;
					else
						vref = cap_lists[i + 1][0];
				}
			}
			val &= ~AC_PINCTL_VREFEN;
			val |= vref;
		}
	}

	return val;
}
3921
EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl);
3922

3923 3924 3925 3926 3927 3928 3929 3930 3931 3932
/**
 * _snd_hda_pin_ctl - Helper to set pin ctl value
 * @codec: the HDA codec
 * @pin: referred pin NID
 * @val: pin control value to set
 * @cached: access over codec pinctl cache or direct write
 *
 * This function is a helper to set a pin ctl value more safely.
 * It corrects the pin ctl value via snd_hda_correct_pin_ctl(), stores the
 * value in pin target array via snd_hda_codec_set_pin_target(), then
3933
 * actually writes the value via either snd_hda_codec_write_cache() or
3934 3935
 * snd_hda_codec_write() depending on @cached flag.
 */
3936 3937 3938
int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
			 unsigned int val, bool cached)
{
3939
	val = snd_hda_correct_pin_ctl(codec, pin, val);
3940
	snd_hda_codec_set_pin_target(codec, pin, val);
3941
	if (cached)
3942
		return snd_hda_codec_write_cache(codec, pin, 0,
3943 3944 3945 3946 3947
				AC_VERB_SET_PIN_WIDGET_CONTROL, val);
	else
		return snd_hda_codec_write(codec, pin, 0,
					   AC_VERB_SET_PIN_WIDGET_CONTROL, val);
}
3948
EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl);
3949

3950 3951
/**
 * snd_hda_add_imux_item - Add an item to input_mux
3952 3953 3954 3955 3956
 * @codec: the HDA codec
 * @imux: imux helper object
 * @label: the name of imux item to assign
 * @index: index number of imux item to assign
 * @type_idx: pointer to store the resultant label index
3957 3958 3959 3960 3961
 *
 * When the same label is used already in the existing items, the number
 * suffix is appended to the label.  This label index number is stored
 * to type_idx when non-NULL pointer is given.
 */
3962 3963
int snd_hda_add_imux_item(struct hda_codec *codec,
			  struct hda_input_mux *imux, const char *label,
3964 3965 3966 3967
			  int index, int *type_idx)
{
	int i, label_idx = 0;
	if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
3968
		codec_err(codec, "hda_codec: Too many imux items!\n");
3969 3970 3971 3972 3973
		return -EINVAL;
	}
	for (i = 0; i < imux->num_items; i++) {
		if (!strncmp(label, imux->items[i].label, strlen(label)))
			label_idx++;
3974
	}
3975 3976 3977 3978 3979 3980
	if (type_idx)
		*type_idx = label_idx;
	if (label_idx > 0)
		snprintf(imux->items[imux->num_items].label,
			 sizeof(imux->items[imux->num_items].label),
			 "%s %d", label, label_idx);
3981
	else
3982 3983 3984 3985 3986
		strlcpy(imux->items[imux->num_items].label, label,
			sizeof(imux->items[imux->num_items].label));
	imux->items[imux->num_items].index = index;
	imux->num_items++;
	return 0;
3987
}
3988
EXPORT_SYMBOL_GPL(snd_hda_add_imux_item);
3989

L
Linus Torvalds 已提交
3990
/**
3991
 * snd_hda_bus_reset_codecs - Reset the bus
3992
 * @bus: HD-audio bus
L
Linus Torvalds 已提交
3993
 */
3994
void snd_hda_bus_reset_codecs(struct hda_bus *bus)
L
Linus Torvalds 已提交
3995
{
T
Takashi Iwai 已提交
3996
	struct hda_codec *codec;
L
Linus Torvalds 已提交
3997

3998
	list_for_each_codec(codec, bus) {
3999
		/* FIXME: maybe a better way needed for forced reset */
4000 4001
		if (current_work() != &codec->jackpoll_work.work)
			cancel_delayed_work_sync(&codec->jackpoll_work);
4002
#ifdef CONFIG_PM
4003
		if (hda_codec_is_power_on(codec)) {
4004
			hda_call_codec_suspend(codec);
4005
			hda_call_codec_resume(codec);
4006 4007
		}
#endif
L
Linus Torvalds 已提交
4008 4009
	}
}
T
Takashi Iwai 已提交
4010

4011 4012 4013 4014 4015 4016 4017 4018
/**
 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
 * @pcm: PCM caps bits
 * @buf: the string buffer to write
 * @buflen: the max buffer length
 *
 * used by hda_proc.c and hda_eld.c
 */
4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029
void snd_print_pcm_bits(int pcm, char *buf, int buflen)
{
	static unsigned int bits[] = { 8, 16, 20, 24, 32 };
	int i, j;

	for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
		if (pcm & (AC_SUPPCM_BITS_8 << i))
			j += snprintf(buf + j, buflen - j,  " %d", bits[i]);

	buf[j] = '\0'; /* necessary when j == 0 */
}
4030
EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
4031 4032 4033

MODULE_DESCRIPTION("HDA codec core");
MODULE_LICENSE("GPL");