brintos / linux-shallow public Read only

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