1 // SPDX-License-Identifier: GPL-2.0-or-later
3  * Universal Interface for Intel High Definition Audio Codec
27 #define codec_in_pm(codec)		snd_hdac_is_in_pm(&codec->core)  argument
28 #define hda_codec_is_power_on(codec)	snd_hdac_is_power_on(&codec->core)  argument
29 #define codec_has_epss(codec) \  argument
30 	((codec)->core.power_caps & AC_PWRST_EPSS)
31 #define codec_has_clkstop(codec) \  argument
32 	((codec)->core.power_caps & AC_PWRST_CLKSTOP)
35  * Send and receive a verb - passed to exec_verb override for hdac_device
40 	struct hda_codec *codec = container_of(dev, struct hda_codec, core);  in codec_exec_verb()  local
41 	struct hda_bus *bus = codec->bus;  in codec_exec_verb()
44 	if (cmd == ~0)  in codec_exec_verb()
45 		return -1;  in codec_exec_verb()
48 	snd_hda_power_up_pm(codec);  in codec_exec_verb()
49 	mutex_lock(&bus->core.cmd_mutex);  in codec_exec_verb()
51 		bus->no_response_fallback = 1;  in codec_exec_verb()
52 	err = snd_hdac_bus_exec_verb_unlocked(&bus->core, codec->core.addr,  in codec_exec_verb()
54 	bus->no_response_fallback = 0;  in codec_exec_verb()
55 	mutex_unlock(&bus->core.cmd_mutex);  in codec_exec_verb()
56 	snd_hda_power_down_pm(codec);  in codec_exec_verb()
57 	if (!codec_in_pm(codec) && res && err == -EAGAIN) {  in codec_exec_verb()
58 		if (bus->response_reset) {  in codec_exec_verb()
59 			codec_dbg(codec,  in codec_exec_verb()
65 	/* clear reset-flag when the communication gets recovered */  in codec_exec_verb()
66 	if (!err || codec_in_pm(codec))  in codec_exec_verb()
67 		bus->response_reset = 0;  in codec_exec_verb()
72  * snd_hda_sequence_write - sequence writes
73  * @codec: the HDA codec
77  * The array must be terminated with NID=0.
79 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)  in snd_hda_sequence_write()  argument
81 	for (; seq->nid; seq++)  in snd_hda_sequence_write()
82 		snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);  in snd_hda_sequence_write()
96 lookup_conn_list(struct hda_codec *codec, hda_nid_t nid)  in lookup_conn_list()  argument
99 	list_for_each_entry(p, &codec->conn_list, list) {  in lookup_conn_list()
100 		if (p->nid == nid)  in lookup_conn_list()
106 static int add_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,  in add_conn_list()  argument
113 		return -ENOMEM;  in add_conn_list()
114 	p->len = len;  in add_conn_list()
115 	p->nid = nid;  in add_conn_list()
116 	memcpy(p->conns, list, len * sizeof(hda_nid_t));  in add_conn_list()
117 	list_add(&p->list, &codec->conn_list);  in add_conn_list()
118 	return 0;  in add_conn_list()
121 static void remove_conn_list(struct hda_codec *codec)  in remove_conn_list()  argument
123 	while (!list_empty(&codec->conn_list)) {  in remove_conn_list()
125 		p = list_first_entry(&codec->conn_list, typeof(*p), list);  in remove_conn_list()
126 		list_del(&p->list);  in remove_conn_list()
132 static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)  in read_and_add_raw_conns()  argument
138 	len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));  in read_and_add_raw_conns()
139 	if (len == -ENOSPC) {  in read_and_add_raw_conns()
140 		len = snd_hda_get_num_raw_conns(codec, nid);  in read_and_add_raw_conns()
143 			return -ENOMEM;  in read_and_add_raw_conns()
144 		len = snd_hda_get_raw_connections(codec, nid, result, len);  in read_and_add_raw_conns()
146 	if (len >= 0)  in read_and_add_raw_conns()
147 		len = snd_hda_override_conn_list(codec, nid, len, result);  in read_and_add_raw_conns()
154  * snd_hda_get_conn_list - get connection list
155  * @codec: the HDA codec
168 int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,  in snd_hda_get_conn_list()  argument
177 		/* if the connection-list is already cached, read it */  in snd_hda_get_conn_list()
178 		p = lookup_conn_list(codec, nid);  in snd_hda_get_conn_list()
181 				*listp = p->conns;  in snd_hda_get_conn_list()
182 			return p->len;  in snd_hda_get_conn_list()
185 			return -EINVAL;  in snd_hda_get_conn_list()
187 		err = read_and_add_raw_conns(codec, nid);  in snd_hda_get_conn_list()
188 		if (err < 0)  in snd_hda_get_conn_list()
196  * snd_hda_get_connections - copy connection list
197  * @codec: the HDA codec
207 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,  in snd_hda_get_connections()  argument
211 	int len = snd_hda_get_conn_list(codec, nid, &list);  in snd_hda_get_connections()
213 	if (len > 0 && conn_list) {  in snd_hda_get_connections()
215 			codec_err(codec, "Too many connections %d for NID 0x%x\n",  in snd_hda_get_connections()
217 			return -EINVAL;  in snd_hda_get_connections()
227  * snd_hda_override_conn_list - add/modify the connection-list to cache
228  * @codec: the HDA codec
233  * Add or modify the given connection-list to the cache.  If the corresponding
238 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,  in snd_hda_override_conn_list()  argument
243 	p = lookup_conn_list(codec, nid);  in snd_hda_override_conn_list()
245 		list_del(&p->list);  in snd_hda_override_conn_list()
249 	return add_conn_list(codec, nid, len, list);  in snd_hda_override_conn_list()
254  * snd_hda_get_conn_index - get the connection index of the given NID
255  * @codec: the HDA codec
258  * @recursive: 1 when searching NID recursively, otherwise 0
262  * Otherwise it returns -1.
264 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,  in snd_hda_get_conn_index()  argument
270 	nums = snd_hda_get_conn_list(codec, mux, &conn);  in snd_hda_get_conn_index()
271 	for (i = 0; i < nums; i++)  in snd_hda_get_conn_index()
275 		return -1;  in snd_hda_get_conn_index()
277 		codec_dbg(codec, "too deep connection for 0x%x\n", nid);  in snd_hda_get_conn_index()
278 		return -1;  in snd_hda_get_conn_index()
281 	for (i = 0; i < nums; i++) {  in snd_hda_get_conn_index()
282 		unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));  in snd_hda_get_conn_index()
285 		if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)  in snd_hda_get_conn_index()
288 	return -1;  in snd_hda_get_conn_index()
293  * snd_hda_get_num_devices - get DEVLIST_LEN parameter of the given widget
294  *  @codec: the HDA codec
300 unsigned int snd_hda_get_num_devices(struct hda_codec *codec, hda_nid_t nid)  in snd_hda_get_num_devices()  argument
302 	unsigned int wcaps = get_wcaps(codec, nid);  in snd_hda_get_num_devices()
305 	if (!codec->dp_mst || !(wcaps & AC_WCAP_DIGITAL) ||  in snd_hda_get_num_devices()
307 		return 0;  in snd_hda_get_num_devices()
309 	parm = snd_hdac_read_parm_uncached(&codec->core, nid, AC_PAR_DEVLIST_LEN);  in snd_hda_get_num_devices()
310 	if (parm == -1)  in snd_hda_get_num_devices()
311 		parm = 0;  in snd_hda_get_num_devices()
317  * snd_hda_get_devices - copy device list without cache
318  * @codec: the HDA codec
326 int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,  in snd_hda_get_devices()  argument
332 	parm = snd_hda_get_num_devices(codec, nid);  in snd_hda_get_devices()
333 	if (!parm)	/* not multi-stream capable */  in snd_hda_get_devices()
334 		return 0;  in snd_hda_get_devices()
339 	devices = 0;  in snd_hda_get_devices()
341 		if (snd_hdac_read(&codec->core, nid,  in snd_hda_get_devices()
345 		for (i = 0; i < 8; i++) {  in snd_hda_get_devices()
357  * snd_hda_get_dev_select - get device entry select on the pin
358  * @codec: the HDA codec
362  * id selected on the pin. Return 0 means the first device entry
365 int snd_hda_get_dev_select(struct hda_codec *codec, hda_nid_t nid)  in snd_hda_get_dev_select()  argument
367 	/* not support dp_mst will always return 0, using first dev_entry */  in snd_hda_get_dev_select()
368 	if (!codec->dp_mst)  in snd_hda_get_dev_select()
369 		return 0;  in snd_hda_get_dev_select()
371 	return snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DEVICE_SEL, 0);  in snd_hda_get_dev_select()
376  * snd_hda_set_dev_select - set device entry select on the pin
377  * @codec: the HDA codec
383 int snd_hda_set_dev_select(struct hda_codec *codec, hda_nid_t nid, int dev_id)  in snd_hda_set_dev_select()  argument
387 	/* not support dp_mst will always return 0, using first dev_entry */  in snd_hda_set_dev_select()
388 	if (!codec->dp_mst)  in snd_hda_set_dev_select()
389 		return 0;  in snd_hda_set_dev_select()
391 	/* AC_PAR_DEVLIST_LEN is 0 based. */  in snd_hda_set_dev_select()
392 	num_devices = snd_hda_get_num_devices(codec, nid) + 1;  in snd_hda_set_dev_select()
393 	/* If Device List Length is 0 (num_device = 1),  in snd_hda_set_dev_select()
398 		return 0;  in snd_hda_set_dev_select()
404 		return -EINVAL;  in snd_hda_set_dev_select()
406 	ret = snd_hda_codec_write(codec, nid, 0,  in snd_hda_set_dev_select()
416 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)  in read_widget_caps()  argument
421 	codec->wcaps = kmalloc_array(codec->core.num_nodes, 4, GFP_KERNEL);  in read_widget_caps()
422 	if (!codec->wcaps)  in read_widget_caps()
423 		return -ENOMEM;  in read_widget_caps()
424 	nid = codec->core.start_nid;  in read_widget_caps()
425 	for (i = 0; i < codec->core.num_nodes; i++, nid++)  in read_widget_caps()
426 		codec->wcaps[i] = snd_hdac_read_parm_uncached(&codec->core,  in read_widget_caps()
428 	return 0;  in read_widget_caps()
431 /* read all pin default configurations and save codec->init_pins */
432 static int read_pin_defaults(struct hda_codec *codec)  in read_pin_defaults()  argument
436 	for_each_hda_codec_node(nid, codec) {  in read_pin_defaults()
438 		unsigned int wcaps = get_wcaps(codec, nid);  in read_pin_defaults()
442 		pin = snd_array_new(&codec->init_pins);  in read_pin_defaults()
444 			return -ENOMEM;  in read_pin_defaults()
445 		pin->nid = nid;  in read_pin_defaults()
446 		pin->cfg = snd_hda_codec_read(codec, nid, 0,  in read_pin_defaults()
447 					      AC_VERB_GET_CONFIG_DEFAULT, 0);  in read_pin_defaults()
450 		 * fixme: if any codec is different, need fix here  in read_pin_defaults()
452 		pin->ctrl = snd_hda_codec_read(codec, nid, 0,  in read_pin_defaults()
454 					       0);  in read_pin_defaults()
456 	return 0;  in read_pin_defaults()
460 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,  in look_up_pincfg()  argument
468 		if (pin->nid == nid)  in look_up_pincfg()
477 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,  in snd_hda_add_pincfg()  argument
487 	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)  in snd_hda_add_pincfg()
488 		return -EINVAL;  in snd_hda_add_pincfg()
491 	pin = look_up_pincfg(codec, list, nid);  in snd_hda_add_pincfg()
495 			return -ENOMEM;  in snd_hda_add_pincfg()
496 		pin->nid = nid;  in snd_hda_add_pincfg()
498 	pin->cfg = cfg;  in snd_hda_add_pincfg()
499 	return 0;  in snd_hda_add_pincfg()
503  * snd_hda_codec_set_pincfg - Override a pin default configuration
504  * @codec: the HDA codec
512 int snd_hda_codec_set_pincfg(struct hda_codec *codec,  in snd_hda_codec_set_pincfg()  argument
515 	return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);  in snd_hda_codec_set_pincfg()
520  * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
521  * @codec: the HDA codec
528 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)  in snd_hda_codec_get_pincfg()  argument
534 		unsigned int cfg = 0;  in snd_hda_codec_get_pincfg()
535 		mutex_lock(&codec->user_mutex);  in snd_hda_codec_get_pincfg()
536 		pin = look_up_pincfg(codec, &codec->user_pins, nid);  in snd_hda_codec_get_pincfg()
538 			cfg = pin->cfg;  in snd_hda_codec_get_pincfg()
539 		mutex_unlock(&codec->user_mutex);  in snd_hda_codec_get_pincfg()
544 	pin = look_up_pincfg(codec, &codec->driver_pins, nid);  in snd_hda_codec_get_pincfg()
546 		return pin->cfg;  in snd_hda_codec_get_pincfg()
547 	pin = look_up_pincfg(codec, &codec->init_pins, nid);  in snd_hda_codec_get_pincfg()
549 		return pin->cfg;  in snd_hda_codec_get_pincfg()
550 	return 0;  in snd_hda_codec_get_pincfg()
555  * snd_hda_codec_set_pin_target - remember the current pinctl target value
556  * @codec: the HDA codec
564 int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,  in snd_hda_codec_set_pin_target()  argument
569 	pin = look_up_pincfg(codec, &codec->init_pins, nid);  in snd_hda_codec_set_pin_target()
571 		return -EINVAL;  in snd_hda_codec_set_pin_target()
572 	pin->target = val;  in snd_hda_codec_set_pin_target()
573 	return 0;  in snd_hda_codec_set_pin_target()
578  * snd_hda_codec_get_pin_target - return the current pinctl target value
579  * @codec: the HDA codec
582 int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)  in snd_hda_codec_get_pin_target()  argument
586 	pin = look_up_pincfg(codec, &codec->init_pins, nid);  in snd_hda_codec_get_pin_target()
588 		return 0;  in snd_hda_codec_get_pin_target()
589 	return pin->target;  in snd_hda_codec_get_pin_target()
594  * snd_hda_shutup_pins - Shut up all pins
595  * @codec: the HDA codec
600 void snd_hda_shutup_pins(struct hda_codec *codec)  in snd_hda_shutup_pins()  argument
608 	if (codec->bus->shutdown)  in snd_hda_shutup_pins()
610 	snd_array_for_each(&codec->init_pins, i, pin) {  in snd_hda_shutup_pins()
612 		snd_hda_codec_read(codec, pin->nid, 0,  in snd_hda_shutup_pins()
613 				   AC_VERB_SET_PIN_WIDGET_CONTROL, 0);  in snd_hda_shutup_pins()
615 	codec->pins_shutup = 1;  in snd_hda_shutup_pins()
620 static void restore_shutup_pins(struct hda_codec *codec)  in restore_shutup_pins()  argument
625 	if (!codec->pins_shutup)  in restore_shutup_pins()
627 	if (codec->bus->shutdown)  in restore_shutup_pins()
629 	snd_array_for_each(&codec->init_pins, i, pin) {  in restore_shutup_pins()
630 		snd_hda_codec_write(codec, pin->nid, 0,  in restore_shutup_pins()
632 				    pin->ctrl);  in restore_shutup_pins()
634 	codec->pins_shutup = 0;  in restore_shutup_pins()
639 	struct hda_codec *codec =  in hda_jackpoll_work()  local
642 	/* for non-polling trigger: we need nothing if already powered on */  in hda_jackpoll_work()
643 	if (!codec->jackpoll_interval && snd_hdac_is_power_on(&codec->core))  in hda_jackpoll_work()
646 	/* the power-up/down sequence triggers the runtime resume */  in hda_jackpoll_work()
647 	snd_hda_power_up_pm(codec);  in hda_jackpoll_work()
649 	if (codec->jackpoll_interval) {  in hda_jackpoll_work()
650 		snd_hda_jack_set_dirty_all(codec);  in hda_jackpoll_work()
651 		snd_hda_jack_poll_all(codec);  in hda_jackpoll_work()
653 	snd_hda_power_down_pm(codec);  in hda_jackpoll_work()
655 	if (!codec->jackpoll_interval)  in hda_jackpoll_work()
658 	schedule_delayed_work(&codec->jackpoll_work,  in hda_jackpoll_work()
659 			      codec->jackpoll_interval);  in hda_jackpoll_work()
663 static void free_init_pincfgs(struct hda_codec *codec)  in free_init_pincfgs()  argument
665 	snd_array_free(&codec->driver_pins);  in free_init_pincfgs()
667 	snd_array_free(&codec->user_pins);  in free_init_pincfgs()
669 	snd_array_free(&codec->init_pins);  in free_init_pincfgs()
673  * audio-converter setup caches
686 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)  in get_hda_cvt_setup()  argument
691 	snd_array_for_each(&codec->cvt_setups, i, p) {  in get_hda_cvt_setup()
692 		if (p->nid == nid)  in get_hda_cvt_setup()
695 	p = snd_array_new(&codec->cvt_setups);  in get_hda_cvt_setup()
697 		p->nid = nid;  in get_hda_cvt_setup()
706 	if (refcount_dec_and_test(&pcm->codec->pcm_ref))  in snd_hda_codec_pcm_put()
707 		wake_up(&pcm->codec->remove_sleep);  in snd_hda_codec_pcm_put()
711 struct hda_pcm *snd_hda_codec_pcm_new(struct hda_codec *codec,  in snd_hda_codec_pcm_new()  argument
721 	pcm->codec = codec;  in snd_hda_codec_pcm_new()
723 	pcm->name = kvasprintf(GFP_KERNEL, fmt, args);  in snd_hda_codec_pcm_new()
725 	if (!pcm->name) {  in snd_hda_codec_pcm_new()
730 	list_add_tail(&pcm->list, &codec->pcm_list_head);  in snd_hda_codec_pcm_new()
731 	refcount_inc(&codec->pcm_ref);  in snd_hda_codec_pcm_new()
737  * codec destructor
739 void snd_hda_codec_disconnect_pcms(struct hda_codec *codec)  in snd_hda_codec_disconnect_pcms()  argument
743 	list_for_each_entry(pcm, &codec->pcm_list_head, list) {  in snd_hda_codec_disconnect_pcms()
744 		if (pcm->disconnected)  in snd_hda_codec_disconnect_pcms()
746 		if (pcm->pcm)  in snd_hda_codec_disconnect_pcms()
747 			snd_device_disconnect(codec->card, pcm->pcm);  in snd_hda_codec_disconnect_pcms()
749 		pcm->disconnected = 1;  in snd_hda_codec_disconnect_pcms()
753 static void codec_release_pcms(struct hda_codec *codec)  in codec_release_pcms()  argument
757 	list_for_each_entry_safe(pcm, n, &codec->pcm_list_head, list) {  in codec_release_pcms()
758 		list_del(&pcm->list);  in codec_release_pcms()
759 		if (pcm->pcm)  in codec_release_pcms()
760 			snd_device_free(pcm->codec->card, pcm->pcm);  in codec_release_pcms()
761 		clear_bit(pcm->device, pcm->codec->bus->pcm_dev_bits);  in codec_release_pcms()
762 		kfree(pcm->name);  in codec_release_pcms()
768  * snd_hda_codec_cleanup_for_unbind - Prepare codec for removal
769  * @codec: codec device to cleanup
771 void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec)  in snd_hda_codec_cleanup_for_unbind()  argument
773 	if (codec->core.registered) {  in snd_hda_codec_cleanup_for_unbind()
775 		pm_runtime_get_noresume(hda_codec_dev(codec));  in snd_hda_codec_cleanup_for_unbind()
776 		pm_runtime_disable(hda_codec_dev(codec));  in snd_hda_codec_cleanup_for_unbind()
777 		codec->core.registered = 0;  in snd_hda_codec_cleanup_for_unbind()
780 	snd_hda_codec_disconnect_pcms(codec);  in snd_hda_codec_cleanup_for_unbind()
781 	cancel_delayed_work_sync(&codec->jackpoll_work);  in snd_hda_codec_cleanup_for_unbind()
782 	if (!codec->in_freeing)  in snd_hda_codec_cleanup_for_unbind()
783 		snd_hda_ctls_clear(codec);  in snd_hda_codec_cleanup_for_unbind()
784 	codec_release_pcms(codec);  in snd_hda_codec_cleanup_for_unbind()
785 	snd_hda_detach_beep_device(codec);  in snd_hda_codec_cleanup_for_unbind()
786 	memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));  in snd_hda_codec_cleanup_for_unbind()
787 	snd_hda_jack_tbl_clear(codec);  in snd_hda_codec_cleanup_for_unbind()
788 	codec->proc_widget_hook = NULL;  in snd_hda_codec_cleanup_for_unbind()
789 	codec->spec = NULL;  in snd_hda_codec_cleanup_for_unbind()
792 	snd_array_free(&codec->driver_pins);  in snd_hda_codec_cleanup_for_unbind()
793 	snd_array_free(&codec->cvt_setups);  in snd_hda_codec_cleanup_for_unbind()
794 	snd_array_free(&codec->spdif_out);  in snd_hda_codec_cleanup_for_unbind()
795 	snd_array_free(&codec->verbs);  in snd_hda_codec_cleanup_for_unbind()
796 	codec->follower_dig_outs = NULL;  in snd_hda_codec_cleanup_for_unbind()
797 	codec->spdif_status_reset = 0;  in snd_hda_codec_cleanup_for_unbind()
798 	snd_array_free(&codec->mixers);  in snd_hda_codec_cleanup_for_unbind()
799 	snd_array_free(&codec->nids);  in snd_hda_codec_cleanup_for_unbind()
800 	remove_conn_list(codec);  in snd_hda_codec_cleanup_for_unbind()
801 	snd_hdac_regmap_exit(&codec->core);  in snd_hda_codec_cleanup_for_unbind()
802 	codec->configured = 0;  in snd_hda_codec_cleanup_for_unbind()
803 	refcount_set(&codec->pcm_ref, 1); /* reset refcount */  in snd_hda_codec_cleanup_for_unbind()
807 static unsigned int hda_set_power_state(struct hda_codec *codec,
810 /* enable/disable display power per codec */
811 void snd_hda_codec_display_power(struct hda_codec *codec, bool enable)  in snd_hda_codec_display_power()  argument
813 	if (codec->display_power_control)  in snd_hda_codec_display_power()
814 		snd_hdac_display_power(&codec->bus->core, codec->addr, enable);  in snd_hda_codec_display_power()
818  * snd_hda_codec_register - Finalize codec initialization
819  * @codec: codec device to register
823 void snd_hda_codec_register(struct hda_codec *codec)  in snd_hda_codec_register()  argument
825 	if (codec->core.registered)  in snd_hda_codec_register()
827 	if (device_is_registered(hda_codec_dev(codec))) {  in snd_hda_codec_register()
828 		snd_hda_codec_display_power(codec, true);  in snd_hda_codec_register()
829 		pm_runtime_enable(hda_codec_dev(codec));  in snd_hda_codec_register()
831 		snd_hda_power_down(codec);  in snd_hda_codec_register()
832 		codec->core.registered = 1;  in snd_hda_codec_register()
839 	snd_hda_codec_register(device->device_data);  in snd_hda_codec_dev_register()
840 	return 0;  in snd_hda_codec_dev_register()
844  * snd_hda_codec_unregister - Unregister specified codec device
845  * @codec: codec device to unregister
847 void snd_hda_codec_unregister(struct hda_codec *codec)  in snd_hda_codec_unregister()  argument
849 	codec->in_freeing = 1;  in snd_hda_codec_unregister()
855 	if (codec->core.type == HDA_DEV_LEGACY)  in snd_hda_codec_unregister()
856 		snd_hdac_device_unregister(&codec->core);  in snd_hda_codec_unregister()
857 	snd_hda_codec_display_power(codec, false);  in snd_hda_codec_unregister()
860 	 * In the case of ASoC HD-audio bus, the device refcount is released in  in snd_hda_codec_unregister()
863 	if (codec->core.type == HDA_DEV_LEGACY)  in snd_hda_codec_unregister()
864 		put_device(hda_codec_dev(codec));  in snd_hda_codec_unregister()
870 	snd_hda_codec_unregister(device->device_data);  in snd_hda_codec_dev_free()
871 	return 0;  in snd_hda_codec_dev_free()
876 	struct hda_codec *codec = dev_to_hda_codec(dev);  in snd_hda_codec_dev_release()  local
878 	free_init_pincfgs(codec);  in snd_hda_codec_dev_release()
879 	snd_hdac_device_exit(&codec->core);  in snd_hda_codec_dev_release()
880 	snd_hda_sysfs_clear(codec);  in snd_hda_codec_dev_release()
881 	kfree(codec->modelname);  in snd_hda_codec_dev_release()
882 	kfree(codec->wcaps);  in snd_hda_codec_dev_release()
883 	kfree(codec);  in snd_hda_codec_dev_release()
889  * snd_hda_codec_device_init - allocate HDA codec device
890  * @bus: codec's parent bus
891  * @codec_addr: the codec address on the parent bus
894  * Returns newly allocated codec device or ERR_PTR() on failure.
902 	struct hda_codec *codec;  in snd_hda_codec_device_init()  local
906 		return ERR_PTR(-EINVAL);  in snd_hda_codec_device_init()
908 		return ERR_PTR(-EINVAL);  in snd_hda_codec_device_init()
910 	codec = kzalloc(sizeof(*codec), GFP_KERNEL);  in snd_hda_codec_device_init()
911 	if (!codec)  in snd_hda_codec_device_init()
912 		return ERR_PTR(-ENOMEM);  in snd_hda_codec_device_init()
918 	err = snd_hdac_device_init(&codec->core, &bus->core, name, codec_addr);  in snd_hda_codec_device_init()
919 	if (err < 0) {  in snd_hda_codec_device_init()
920 		kfree(codec);  in snd_hda_codec_device_init()
924 	codec->bus = bus;  in snd_hda_codec_device_init()
925 	codec->depop_delay = -1;  in snd_hda_codec_device_init()
926 	codec->fixup_id = HDA_FIXUP_ID_NOT_SET;  in snd_hda_codec_device_init()
927 	codec->core.dev.release = snd_hda_codec_dev_release;  in snd_hda_codec_device_init()
928 	codec->core.type = HDA_DEV_LEGACY;  in snd_hda_codec_device_init()
930 	mutex_init(&codec->spdif_mutex);  in snd_hda_codec_device_init()
931 	mutex_init(&codec->control_mutex);  in snd_hda_codec_device_init()
932 	snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);  in snd_hda_codec_device_init()
933 	snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);  in snd_hda_codec_device_init()
934 	snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);  in snd_hda_codec_device_init()
935 	snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);  in snd_hda_codec_device_init()
936 	snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);  in snd_hda_codec_device_init()
937 	snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);  in snd_hda_codec_device_init()
938 	snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);  in snd_hda_codec_device_init()
939 	snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);  in snd_hda_codec_device_init()
940 	INIT_LIST_HEAD(&codec->conn_list);  in snd_hda_codec_device_init()
941 	INIT_LIST_HEAD(&codec->pcm_list_head);  in snd_hda_codec_device_init()
942 	INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);  in snd_hda_codec_device_init()
943 	refcount_set(&codec->pcm_ref, 1);  in snd_hda_codec_device_init()
944 	init_waitqueue_head(&codec->remove_sleep);  in snd_hda_codec_device_init()
946 	return codec;  in snd_hda_codec_device_init()
951  * snd_hda_codec_new - create a HDA codec
953  * @card: card for this codec
954  * @codec_addr: the codec address
955  * @codecp: the pointer to store the generated codec
957  * Returns 0 if successful, or a negative error code.
962 	struct hda_codec *codec;  in snd_hda_codec_new()  local
965 	codec = snd_hda_codec_device_init(bus, codec_addr, "hdaudioC%dD%d",  in snd_hda_codec_new()
966 					  card->number, codec_addr);  in snd_hda_codec_new()
967 	if (IS_ERR(codec))  in snd_hda_codec_new()
968 		return PTR_ERR(codec);  in snd_hda_codec_new()
969 	*codecp = codec;  in snd_hda_codec_new()
980 			unsigned int codec_addr, struct hda_codec *codec,  in snd_hda_codec_device_new()  argument
991 	dev_dbg(card->dev, "%s: entry\n", __func__);  in snd_hda_codec_device_new()
994 		return -EINVAL;  in snd_hda_codec_device_new()
996 		return -EINVAL;  in snd_hda_codec_device_new()
998 	codec->core.exec_verb = codec_exec_verb;  in snd_hda_codec_device_new()
999 	codec->card = card;  in snd_hda_codec_device_new()
1000 	codec->addr = codec_addr;  in snd_hda_codec_device_new()
1002 	codec->power_jiffies = jiffies;  in snd_hda_codec_device_new()
1004 	snd_hda_sysfs_init(codec);  in snd_hda_codec_device_new()
1006 	if (codec->bus->modelname) {  in snd_hda_codec_device_new()
1007 		codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);  in snd_hda_codec_device_new()
1008 		if (!codec->modelname)  in snd_hda_codec_device_new()
1009 			return -ENOMEM;  in snd_hda_codec_device_new()
1012 	fg = codec->core.afg ? codec->core.afg : codec->core.mfg;  in snd_hda_codec_device_new()
1013 	err = read_widget_caps(codec, fg);  in snd_hda_codec_device_new()
1014 	if (err < 0)  in snd_hda_codec_device_new()
1016 	err = read_pin_defaults(codec);  in snd_hda_codec_device_new()
1017 	if (err < 0)  in snd_hda_codec_device_new()
1020 	/* power-up all before initialization */  in snd_hda_codec_device_new()
1021 	hda_set_power_state(codec, AC_PWRST_D0);  in snd_hda_codec_device_new()
1022 	codec->core.dev.power.power_state = PMSG_ON;  in snd_hda_codec_device_new()
1024 	snd_hda_codec_proc_new(codec);  in snd_hda_codec_device_new()
1026 	snd_hda_create_hwdep(codec);  in snd_hda_codec_device_new()
1028 	sprintf(component, "HDA:%08x,%08x,%08x", codec->core.vendor_id,  in snd_hda_codec_device_new()
1029 		codec->core.subsystem_id, codec->core.revision_id);  in snd_hda_codec_device_new()
1034 		err = snd_device_new(card, SNDRV_DEV_CODEC, codec, &dev_ops);  in snd_hda_codec_device_new()
1035 		if (err < 0)  in snd_hda_codec_device_new()
1040 	/* PM runtime needs to be enabled later after binding codec */  in snd_hda_codec_device_new()
1041 	if (codec->core.dev.power.runtime_auto)  in snd_hda_codec_device_new()
1042 		pm_runtime_forbid(&codec->core.dev);  in snd_hda_codec_device_new()
1045 		pm_runtime_get_noresume(&codec->core.dev);  in snd_hda_codec_device_new()
1048 	return 0;  in snd_hda_codec_device_new()
1053  * snd_hda_codec_update_widgets - Refresh widget caps and pin defaults
1054  * @codec: the HDA codec
1057  * the given codec.
1059 int snd_hda_codec_update_widgets(struct hda_codec *codec)  in snd_hda_codec_update_widgets()  argument
1064 	err = snd_hdac_refresh_widgets(&codec->core);  in snd_hda_codec_update_widgets()
1065 	if (err < 0)  in snd_hda_codec_update_widgets()
1071 	kfree(codec->wcaps);  in snd_hda_codec_update_widgets()
1072 	fg = codec->core.afg ? codec->core.afg : codec->core.mfg;  in snd_hda_codec_update_widgets()
1073 	err = read_widget_caps(codec, fg);  in snd_hda_codec_update_widgets()
1074 	if (err < 0)  in snd_hda_codec_update_widgets()
1077 	snd_array_free(&codec->init_pins);  in snd_hda_codec_update_widgets()
1078 	err = read_pin_defaults(codec);  in snd_hda_codec_update_widgets()
1084 /* update the stream-id if changed */
1085 static void update_pcm_stream_id(struct hda_codec *codec,  in update_pcm_stream_id()  argument
1091 	if (p->stream_tag != stream_tag || p->channel_id != channel_id) {  in update_pcm_stream_id()
1092 		oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);  in update_pcm_stream_id()
1095 			snd_hda_codec_write(codec, nid, 0,  in update_pcm_stream_id()
1098 		p->stream_tag = stream_tag;  in update_pcm_stream_id()
1099 		p->channel_id = channel_id;  in update_pcm_stream_id()
1103 /* update the format-id if changed */
1104 static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,  in update_pcm_format()  argument
1109 	if (p->format_id != format) {  in update_pcm_format()
1110 		oldval = snd_hda_codec_read(codec, nid, 0,  in update_pcm_format()
1111 					    AC_VERB_GET_STREAM_FORMAT, 0);  in update_pcm_format()
1114 			snd_hda_codec_write(codec, nid, 0,  in update_pcm_format()
1118 		p->format_id = format;  in update_pcm_format()
1123  * snd_hda_codec_setup_stream - set up the codec for streaming
1124  * @codec: the CODEC to set up
1126  * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1130 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,  in snd_hda_codec_setup_stream()  argument
1142 	codec_dbg(codec,  in snd_hda_codec_setup_stream()
1143 		  "hda_codec_setup_stream: NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",  in snd_hda_codec_setup_stream()
1145 	p = get_hda_cvt_setup(codec, nid);  in snd_hda_codec_setup_stream()
1149 	if (codec->patch_ops.stream_pm)  in snd_hda_codec_setup_stream()
1150 		codec->patch_ops.stream_pm(codec, nid, true);  in snd_hda_codec_setup_stream()
1151 	if (codec->pcm_format_first)  in snd_hda_codec_setup_stream()
1152 		update_pcm_format(codec, p, nid, format);  in snd_hda_codec_setup_stream()
1153 	update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);  in snd_hda_codec_setup_stream()
1154 	if (!codec->pcm_format_first)  in snd_hda_codec_setup_stream()
1155 		update_pcm_format(codec, p, nid, format);  in snd_hda_codec_setup_stream()
1157 	p->active = 1;  in snd_hda_codec_setup_stream()
1158 	p->dirty = 0;  in snd_hda_codec_setup_stream()
1160 	/* make other inactive cvts with the same stream-tag dirty */  in snd_hda_codec_setup_stream()
1161 	type = get_wcaps_type(get_wcaps(codec, nid));  in snd_hda_codec_setup_stream()
1162 	list_for_each_codec(c, codec->bus) {  in snd_hda_codec_setup_stream()
1163 		snd_array_for_each(&c->cvt_setups, i, p) {  in snd_hda_codec_setup_stream()
1164 			if (!p->active && p->stream_tag == stream_tag &&  in snd_hda_codec_setup_stream()
1165 			    get_wcaps_type(get_wcaps(c, p->nid)) == type)  in snd_hda_codec_setup_stream()
1166 				p->dirty = 1;  in snd_hda_codec_setup_stream()
1172 static void really_cleanup_stream(struct hda_codec *codec,
1176  * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1177  * @codec: the CODEC to clean up
1181 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,  in __snd_hda_codec_cleanup_stream()  argument
1189 	if (codec->no_sticky_stream)  in __snd_hda_codec_cleanup_stream()
1192 	codec_dbg(codec, "hda_codec_cleanup_stream: NID=0x%x\n", nid);  in __snd_hda_codec_cleanup_stream()
1193 	p = get_hda_cvt_setup(codec, nid);  in __snd_hda_codec_cleanup_stream()
1196 		 * actual clean-ups will be done later in  in __snd_hda_codec_cleanup_stream()
1200 			really_cleanup_stream(codec, p);  in __snd_hda_codec_cleanup_stream()
1202 			p->active = 0;  in __snd_hda_codec_cleanup_stream()
1207 static void really_cleanup_stream(struct hda_codec *codec,  in really_cleanup_stream()  argument
1210 	hda_nid_t nid = q->nid;  in really_cleanup_stream()
1211 	if (q->stream_tag || q->channel_id)  in really_cleanup_stream()
1212 		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);  in really_cleanup_stream()
1213 	if (q->format_id)  in really_cleanup_stream()
1214 		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0  in really_cleanup_stream()
1216 	memset(q, 0, sizeof(*q));  in really_cleanup_stream()
1217 	q->nid = nid;  in really_cleanup_stream()
1218 	if (codec->patch_ops.stream_pm)  in really_cleanup_stream()
1219 		codec->patch_ops.stream_pm(codec, nid, false);  in really_cleanup_stream()
1223 static void purify_inactive_streams(struct hda_codec *codec)  in purify_inactive_streams()  argument
1229 	list_for_each_codec(c, codec->bus) {  in purify_inactive_streams()
1230 		snd_array_for_each(&c->cvt_setups, i, p) {  in purify_inactive_streams()
1231 			if (p->dirty)  in purify_inactive_streams()
1238 static void hda_cleanup_all_streams(struct hda_codec *codec)  in hda_cleanup_all_streams()  argument
1243 	snd_array_for_each(&codec->cvt_setups, i, p) {  in hda_cleanup_all_streams()
1244 		if (p->stream_tag)  in hda_cleanup_all_streams()
1245 			really_cleanup_stream(codec, p);  in hda_cleanup_all_streams()
1254  * query_amp_caps - query AMP capabilities
1255  * @codec: the HD-auio codec
1265 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)  in query_amp_caps()  argument
1267 	if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))  in query_amp_caps()
1268 		nid = codec->core.afg;  in query_amp_caps()
1269 	return snd_hda_param_read(codec, nid,  in query_amp_caps()
1276  * snd_hda_check_amp_caps - query AMP capabilities
1277  * @codec: the HD-audio codec
1284 bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid,  in snd_hda_check_amp_caps()  argument
1289 	if (get_wcaps(codec, nid) & (1 << (dir + 1)))  in snd_hda_check_amp_caps()
1290 		if (query_amp_caps(codec, nid, dir) & bits)  in snd_hda_check_amp_caps()
1297  * snd_hda_override_amp_caps - Override the AMP capabilities
1298  * @codec: the CODEC to clean up
1305  * e.g. limit to 0dB, etc.
1309 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,  in snd_hda_override_amp_caps()  argument
1314 	snd_hda_override_wcaps(codec, nid,  in snd_hda_override_amp_caps()
1315 			       get_wcaps(codec, nid) | AC_WCAP_AMP_OVRD);  in snd_hda_override_amp_caps()
1317 	return snd_hdac_override_parm(&codec->core, nid, parm, caps);  in snd_hda_override_amp_caps()
1321 static unsigned int encode_amp(struct hda_codec *codec, hda_nid_t nid,  in encode_amp()  argument
1327 	if ((query_amp_caps(codec, nid, dir) &  in encode_amp()
1334  * snd_hda_codec_amp_update - update the AMP mono value
1335  * @codec: HD-audio codec
1337  * @ch: channel to update (0 or 1)
1345 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid,  in snd_hda_codec_amp_update()  argument
1348 	unsigned int cmd = encode_amp(codec, nid, ch, dir, idx);  in snd_hda_codec_amp_update()
1350 	return snd_hdac_regmap_update_raw(&codec->core, cmd, mask, val);  in snd_hda_codec_amp_update()
1355  * snd_hda_codec_amp_stereo - update the AMP stereo values
1356  * @codec: HD-audio codec
1366 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,  in snd_hda_codec_amp_stereo()  argument
1369 	int ch, ret = 0;  in snd_hda_codec_amp_stereo()
1371 	if (snd_BUG_ON(mask & ~0xff))  in snd_hda_codec_amp_stereo()
1372 		mask &= 0xff;  in snd_hda_codec_amp_stereo()
1373 	for (ch = 0; ch < 2; ch++)  in snd_hda_codec_amp_stereo()
1374 		ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,  in snd_hda_codec_amp_stereo()
1381  * snd_hda_codec_amp_init - initialize the AMP value
1382  * @codec: the HDA codec
1384  * @ch: channel (left=0 or right=1)
1394 int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,  in snd_hda_codec_amp_init()  argument
1397 	unsigned int cmd = encode_amp(codec, nid, ch, dir, idx);  in snd_hda_codec_amp_init()
1399 	if (!codec->core.regmap)  in snd_hda_codec_amp_init()
1400 		return -EINVAL;  in snd_hda_codec_amp_init()
1401 	return snd_hdac_regmap_update_raw_once(&codec->core, cmd, mask, val);  in snd_hda_codec_amp_init()
1406  * snd_hda_codec_amp_init_stereo - initialize the stereo AMP value
1407  * @codec: the HDA codec
1416 int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,  in snd_hda_codec_amp_init_stereo()  argument
1419 	int ch, ret = 0;  in snd_hda_codec_amp_init_stereo()
1421 	if (snd_BUG_ON(mask & ~0xff))  in snd_hda_codec_amp_init_stereo()
1422 		mask &= 0xff;  in snd_hda_codec_amp_init_stereo()
1423 	for (ch = 0; ch < 2; ch++)  in snd_hda_codec_amp_init_stereo()
1424 		ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,  in snd_hda_codec_amp_init_stereo()
1430 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,  in get_amp_max_value()  argument
1433 	u32 caps = query_amp_caps(codec, nid, dir);  in get_amp_max_value()
1437 		caps -= ofs;  in get_amp_max_value()
1442  * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1452 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);  in snd_hda_mixer_amp_volume_info()  local
1458 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in snd_hda_mixer_amp_volume_info()
1459 	uinfo->count = chs == 3 ? 2 : 1;  in snd_hda_mixer_amp_volume_info()
1460 	uinfo->value.integer.min = 0;  in snd_hda_mixer_amp_volume_info()
1461 	uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);  in snd_hda_mixer_amp_volume_info()
1462 	if (!uinfo->value.integer.max) {  in snd_hda_mixer_amp_volume_info()
1463 		codec_warn(codec,  in snd_hda_mixer_amp_volume_info()
1464 			   "num_steps = 0 for NID=0x%x (ctl = %s)\n",  in snd_hda_mixer_amp_volume_info()
1465 			   nid, kcontrol->id.name);  in snd_hda_mixer_amp_volume_info()
1466 		return -EINVAL;  in snd_hda_mixer_amp_volume_info()
1468 	return 0;  in snd_hda_mixer_amp_volume_info()
1474 read_amp_value(struct hda_codec *codec, hda_nid_t nid,  in read_amp_value()  argument
1478 	val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);  in read_amp_value()
1481 		val -= ofs;  in read_amp_value()
1483 		val = 0;  in read_amp_value()
1488 update_amp_value(struct hda_codec *codec, hda_nid_t nid,  in update_amp_value()  argument
1494 	if (val > 0)  in update_amp_value()
1496 	/* ofs = 0: raw max value */  in update_amp_value()
1497 	maxval = get_amp_max_value(codec, nid, dir, 0);  in update_amp_value()
1499 		return -EINVAL;  in update_amp_value()
1500 	return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,  in update_amp_value()
1505  * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1515 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);  in snd_hda_mixer_amp_volume_get()  local
1521 	long *valp = ucontrol->value.integer.value;  in snd_hda_mixer_amp_volume_get()
1524 		*valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);  in snd_hda_mixer_amp_volume_get()
1526 		*valp = read_amp_value(codec, nid, 1, dir, idx, ofs);  in snd_hda_mixer_amp_volume_get()
1527 	return 0;  in snd_hda_mixer_amp_volume_get()
1532  * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1542 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);  in snd_hda_mixer_amp_volume_put()  local
1548 	long *valp = ucontrol->value.integer.value;  in snd_hda_mixer_amp_volume_put()
1549 	int change = 0;  in snd_hda_mixer_amp_volume_put()
1553 		err = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);  in snd_hda_mixer_amp_volume_put()
1554 		if (err < 0)  in snd_hda_mixer_amp_volume_put()
1560 		err = update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);  in snd_hda_mixer_amp_volume_put()
1561 		if (err < 0)  in snd_hda_mixer_amp_volume_put()
1572 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);  in get_ctl_amp_tlv()  local
1579 	caps = query_amp_caps(codec, nid, dir);  in get_ctl_amp_tlv()
1582 	val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);  in get_ctl_amp_tlv()
1594  * snd_hda_mixer_amp_tlv - TLV callback for a standard AMP mixer volume
1609 		return -ENOMEM;  in snd_hda_mixer_amp_tlv()
1612 		return -EFAULT;  in snd_hda_mixer_amp_tlv()
1613 	return 0;  in snd_hda_mixer_amp_tlv()
1618  * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1619  * @codec: HD-audio codec
1626  * The volume range is recalculated as if the max volume is 0dB.
1628 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,  in snd_hda_set_vmaster_tlv()  argument
1634 	caps = query_amp_caps(codec, nid, dir);  in snd_hda_set_vmaster_tlv()
1640 	tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN] = -nums * step;  in snd_hda_set_vmaster_tlv()
1647 find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)  in find_mixer_ctl()  argument
1650 	memset(&id, 0, sizeof(id));  in find_mixer_ctl()
1657 	return snd_ctl_find_id(codec->card, &id);  in find_mixer_ctl()
1661  * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1662  * @codec: HD-audio codec
1667 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,  in snd_hda_find_mixer_ctl()  argument
1670 	return find_mixer_ctl(codec, name, 0, 0);  in snd_hda_find_mixer_ctl()
1674 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,  in find_empty_mixer_ctl_idx()  argument
1679 	for (i = 0, idx = start_idx; i < 16; i++, idx++) {  in find_empty_mixer_ctl_idx()
1680 		if (!find_mixer_ctl(codec, name, 0, idx))  in find_empty_mixer_ctl_idx()
1683 	return -EBUSY;  in find_empty_mixer_ctl_idx()
1687  * snd_hda_ctl_add - Add a control element and assign to the codec
1688  * @codec: HD-audio codec
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 added
1694  * by this function so that a proper clean-up works at the free or
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.
1703  * specifies if kctl->private_value is a HDA amplifier value.
1705 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,  in snd_hda_ctl_add()  argument
1709 	unsigned short flags = 0;  in snd_hda_ctl_add()
1712 	if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {  in snd_hda_ctl_add()
1714 		if (nid == 0)  in snd_hda_ctl_add()
1715 			nid = get_amp_nid_(kctl->private_value);  in snd_hda_ctl_add()
1717 	if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)  in snd_hda_ctl_add()
1718 		nid = kctl->id.subdevice & 0xffff;  in snd_hda_ctl_add()
1719 	if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))  in snd_hda_ctl_add()
1720 		kctl->id.subdevice = 0;  in snd_hda_ctl_add()
1721 	err = snd_ctl_add(codec->card, kctl);  in snd_hda_ctl_add()
1722 	if (err < 0)  in snd_hda_ctl_add()
1724 	item = snd_array_new(&codec->mixers);  in snd_hda_ctl_add()
1726 		return -ENOMEM;  in snd_hda_ctl_add()
1727 	item->kctl = kctl;  in snd_hda_ctl_add()
1728 	item->nid = nid;  in snd_hda_ctl_add()
1729 	item->flags = flags;  in snd_hda_ctl_add()
1730 	return 0;  in snd_hda_ctl_add()
1735  * snd_hda_add_nid - Assign a NID to a control element
1736  * @codec: HD-audio codec
1741  * Add the given control element to an array inside the codec instance.
1743  * NID:KCTL mapping - for example "Capture Source" selector.
1745 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,  in snd_hda_add_nid()  argument
1750 	if (nid > 0) {  in snd_hda_add_nid()
1751 		item = snd_array_new(&codec->nids);  in snd_hda_add_nid()
1753 			return -ENOMEM;  in snd_hda_add_nid()
1754 		item->kctl = kctl;  in snd_hda_add_nid()
1755 		item->index = index;  in snd_hda_add_nid()
1756 		item->nid = nid;  in snd_hda_add_nid()
1757 		return 0;  in snd_hda_add_nid()
1759 	codec_err(codec, "no NID for mapping control %s:%d:%d\n",  in snd_hda_add_nid()
1760 		  kctl->id.name, kctl->id.index, index);  in snd_hda_add_nid()
1761 	return -EINVAL;  in snd_hda_add_nid()
1766  * snd_hda_ctls_clear - Clear all controls assigned to the given codec
1767  * @codec: HD-audio codec
1769 void snd_hda_ctls_clear(struct hda_codec *codec)  in snd_hda_ctls_clear()  argument
1772 	struct hda_nid_item *items = codec->mixers.list;  in snd_hda_ctls_clear()
1774 	for (i = 0; i < codec->mixers.used; i++)  in snd_hda_ctls_clear()
1775 		snd_ctl_remove(codec->card, items[i].kctl);  in snd_hda_ctls_clear()
1776 	snd_array_free(&codec->mixers);  in snd_hda_ctls_clear()
1777 	snd_array_free(&codec->nids);  in snd_hda_ctls_clear()
1781  * snd_hda_lock_devices - pseudo device locking
1784  * toggle card->shutdown to allow/disallow the device access (as a hack)
1788 	struct snd_card *card = bus->card;  in snd_hda_lock_devices()
1789 	struct hda_codec *codec;  in snd_hda_lock_devices()  local
1791 	spin_lock(&card->files_lock);  in snd_hda_lock_devices()
1792 	if (card->shutdown)  in snd_hda_lock_devices()
1794 	card->shutdown = 1;  in snd_hda_lock_devices()
1795 	if (!list_empty(&card->ctl_files))  in snd_hda_lock_devices()
1798 	list_for_each_codec(codec, bus) {  in snd_hda_lock_devices()
1800 		list_for_each_entry(cpcm, &codec->pcm_list_head, list) {  in snd_hda_lock_devices()
1801 			if (!cpcm->pcm)  in snd_hda_lock_devices()
1803 			if (cpcm->pcm->streams[0].substream_opened ||  in snd_hda_lock_devices()
1804 			    cpcm->pcm->streams[1].substream_opened)  in snd_hda_lock_devices()
1808 	spin_unlock(&card->files_lock);  in snd_hda_lock_devices()
1809 	return 0;  in snd_hda_lock_devices()
1812 	card->shutdown = 0;  in snd_hda_lock_devices()
1814 	spin_unlock(&card->files_lock);  in snd_hda_lock_devices()
1815 	return -EINVAL;  in snd_hda_lock_devices()
1820  * snd_hda_unlock_devices - pseudo device unlocking
1825 	struct snd_card *card = bus->card;  in snd_hda_unlock_devices()
1827 	spin_lock(&card->files_lock);  in snd_hda_unlock_devices()
1828 	card->shutdown = 0;  in snd_hda_unlock_devices()
1829 	spin_unlock(&card->files_lock);  in snd_hda_unlock_devices()
1834  * snd_hda_codec_reset - Clear all objects assigned to the codec
1835  * @codec: HD-audio codec
1837  * This frees the all PCM and control elements assigned to the codec, and
1840  * When a device is being used, it returns -EBSY.  If successfully freed,
1843 int snd_hda_codec_reset(struct hda_codec *codec)  in snd_hda_codec_reset()  argument
1845 	struct hda_bus *bus = codec->bus;  in snd_hda_codec_reset()
1847 	if (snd_hda_lock_devices(bus) < 0)  in snd_hda_codec_reset()
1848 		return -EBUSY;  in snd_hda_codec_reset()
1851 	device_release_driver(hda_codec_dev(codec));  in snd_hda_codec_reset()
1855 	return 0;  in snd_hda_codec_reset()
1861 static int map_followers(struct hda_codec *codec, const char * const *followers,  in map_followers()  argument
1868 	items = codec->mixers.list;  in map_followers()
1869 	for (i = 0; i < codec->mixers.used; i++) {  in map_followers()
1871 		if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)  in map_followers()
1874 			char tmpname[sizeof(sctl->id.name)];  in map_followers()
1881 			if (!strcmp(sctl->id.name, name)) {  in map_followers()
1882 				err = func(codec, data, sctl);  in map_followers()
1889 	return 0;  in map_followers()
1892 static int check_follower_present(struct hda_codec *codec,  in check_follower_present()  argument
1898 /* call kctl->put with the given value(s) */
1904 		return -ENOMEM;  in put_kctl_with_value()
1905 	ucontrol->value.integer.value[0] = val;  in put_kctl_with_value()
1906 	ucontrol->value.integer.value[1] = val;  in put_kctl_with_value()
1907 	kctl->put(kctl, ucontrol);  in put_kctl_with_value()
1909 	return 0;  in put_kctl_with_value()
1913 	struct hda_codec *codec;  member
1917 /* initialize the follower volume with 0dB via snd_ctl_apply_vmaster_followers() */
1928 	if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {  in init_follower_0dB()
1929 		if (kctl->tlv.c != snd_hda_mixer_amp_tlv) {  in init_follower_0dB()
1930 			codec_err(arg->codec,  in init_follower_0dB()
1932 				  kctl->id.name, kctl->id.index);  in init_follower_0dB()
1933 			return 0; /* ignore */  in init_follower_0dB()
1937 	} else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)  in init_follower_0dB()
1938 		tlv = kctl->tlv.p;  in init_follower_0dB()
1941 		return 0;  in init_follower_0dB()
1946 		return 0;  in init_follower_0dB()
1947 	if (arg->step && arg->step != step) {  in init_follower_0dB()
1948 		codec_err(arg->codec,  in init_follower_0dB()
1950 			  arg->step, step);  in init_follower_0dB()
1951 		return 0;  in init_follower_0dB()
1954 	arg->step = step;  in init_follower_0dB()
1955 	val = -tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN] / step;  in init_follower_0dB()
1956 	if (val > 0) {  in init_follower_0dB()
1961 	return 0;  in init_follower_0dB()
1972 static int add_follower(struct hda_codec *codec,  in add_follower()  argument
1979  * __snd_hda_add_vmaster - create a virtual master control and add followers
1980  * @codec: HD-audio codec
1985  * @init_follower_vol: initialize followers to unmute/0dB
1992  * @followers is a NULL-terminated array of strings, each of which is a
1998 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,  in __snd_hda_add_vmaster()  argument
2009 	err = map_followers(codec, followers, suffix, check_follower_present, NULL);  in __snd_hda_add_vmaster()
2011 		codec_dbg(codec, "No follower found for %s\n", name);  in __snd_hda_add_vmaster()
2012 		return 0;  in __snd_hda_add_vmaster()
2016 		return -ENOMEM;  in __snd_hda_add_vmaster()
2017 	kctl->vd[0].access |= access;  in __snd_hda_add_vmaster()
2018 	err = snd_hda_ctl_add(codec, 0, kctl);  in __snd_hda_add_vmaster()
2019 	if (err < 0)  in __snd_hda_add_vmaster()
2022 	err = map_followers(codec, followers, suffix, add_follower, kctl);  in __snd_hda_add_vmaster()
2023 	if (err < 0)  in __snd_hda_add_vmaster()
2027 	put_kctl_with_value(kctl, 0);  in __snd_hda_add_vmaster()
2030 			.codec = codec,  in __snd_hda_add_vmaster()
2031 			.step = 0,  in __snd_hda_add_vmaster()
2040 	return 0;  in __snd_hda_add_vmaster()
2049 	hook->hook(hook->codec, enabled);  in vmaster_hook()
2053  * snd_hda_add_vmaster_hook - Add a vmaster hw specific hook
2054  * @codec: the HDA codec
2059 int snd_hda_add_vmaster_hook(struct hda_codec *codec,  in snd_hda_add_vmaster_hook()  argument
2062 	if (!hook->hook || !hook->sw_kctl)  in snd_hda_add_vmaster_hook()
2063 		return 0;  in snd_hda_add_vmaster_hook()
2064 	hook->codec = codec;  in snd_hda_add_vmaster_hook()
2065 	snd_ctl_add_vmaster_hook(hook->sw_kctl, vmaster_hook, hook);  in snd_hda_add_vmaster_hook()
2066 	return 0;  in snd_hda_add_vmaster_hook()
2071  * snd_hda_sync_vmaster_hook - Sync vmaster hook
2079 	if (!hook->hook || !hook->codec)  in snd_hda_sync_vmaster_hook()
2084 	if (hook->codec->bus->shutdown)  in snd_hda_sync_vmaster_hook()
2086 	snd_ctl_sync_vmaster_hook(hook->sw_kctl);  in snd_hda_sync_vmaster_hook()
2092  * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2104 	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;  in snd_hda_mixer_amp_switch_info()
2105 	uinfo->count = chs == 3 ? 2 : 1;  in snd_hda_mixer_amp_switch_info()
2106 	uinfo->value.integer.min = 0;  in snd_hda_mixer_amp_switch_info()
2107 	uinfo->value.integer.max = 1;  in snd_hda_mixer_amp_switch_info()
2108 	return 0;  in snd_hda_mixer_amp_switch_info()
2113  * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2123 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);  in snd_hda_mixer_amp_switch_get()  local
2128 	long *valp = ucontrol->value.integer.value;  in snd_hda_mixer_amp_switch_get()
2131 		*valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &  in snd_hda_mixer_amp_switch_get()
2132 			   HDA_AMP_MUTE) ? 0 : 1;  in snd_hda_mixer_amp_switch_get()
2134 		*valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &  in snd_hda_mixer_amp_switch_get()
2135 			 HDA_AMP_MUTE) ? 0 : 1;  in snd_hda_mixer_amp_switch_get()
2136 	return 0;  in snd_hda_mixer_amp_switch_get()
2141  * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2151 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);  in snd_hda_mixer_amp_switch_put()  local
2156 	long *valp = ucontrol->value.integer.value;  in snd_hda_mixer_amp_switch_put()
2157 	int change = 0;  in snd_hda_mixer_amp_switch_put()
2160 		if (*valp < 0 || *valp > 1)  in snd_hda_mixer_amp_switch_put()
2161 			return -EINVAL;  in snd_hda_mixer_amp_switch_put()
2162 		change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,  in snd_hda_mixer_amp_switch_put()
2164 						  *valp ? 0 : HDA_AMP_MUTE);  in snd_hda_mixer_amp_switch_put()
2168 		if (*valp < 0 || *valp > 1)  in snd_hda_mixer_amp_switch_put()
2169 			return -EINVAL;  in snd_hda_mixer_amp_switch_put()
2170 		change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,  in snd_hda_mixer_amp_switch_put()
2172 						   *valp ? 0 : HDA_AMP_MUTE);  in snd_hda_mixer_amp_switch_put()
2174 	hda_call_check_power_status(codec, nid);  in snd_hda_mixer_amp_switch_put()
2186 	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;  in snd_hda_spdif_mask_info()
2187 	uinfo->count = 1;  in snd_hda_spdif_mask_info()
2188 	return 0;  in snd_hda_spdif_mask_info()
2194 	ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |  in snd_hda_spdif_cmask_get()
2198 	ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |  in snd_hda_spdif_cmask_get()
2200 	return 0;  in snd_hda_spdif_cmask_get()
2206 	ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |  in snd_hda_spdif_pmask_get()
2209 	return 0;  in snd_hda_spdif_pmask_get()
2215 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);  in snd_hda_spdif_default_get()  local
2216 	int idx = kcontrol->private_value;  in snd_hda_spdif_default_get()
2219 	if (WARN_ON(codec->spdif_out.used <= idx))  in snd_hda_spdif_default_get()
2220 		return -EINVAL;  in snd_hda_spdif_default_get()
2221 	mutex_lock(&codec->spdif_mutex);  in snd_hda_spdif_default_get()
2222 	spdif = snd_array_elem(&codec->spdif_out, idx);  in snd_hda_spdif_default_get()
2223 	ucontrol->value.iec958.status[0] = spdif->status & 0xff;  in snd_hda_spdif_default_get()
2224 	ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;  in snd_hda_spdif_default_get()
2225 	ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;  in snd_hda_spdif_default_get()
2226 	ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;  in snd_hda_spdif_default_get()
2227 	mutex_unlock(&codec->spdif_mutex);  in snd_hda_spdif_default_get()
2229 	return 0;  in snd_hda_spdif_default_get()
2233  * bit 0 (DigEn) is always set zero (to be filled later)
2237 	unsigned short val = 0;  in convert_from_spdif_status()
2264 	unsigned int sbits = 0;  in convert_to_spdif_status()
2280 		sbits |= val & (0x7f << 8);  in convert_to_spdif_status()
2286 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,  in set_dig_out()  argument
2291 	snd_hdac_regmap_update(&codec->core, nid, AC_VERB_SET_DIGI_CONVERT_1,  in set_dig_out()
2293 	d = codec->follower_dig_outs;  in set_dig_out()
2297 		snd_hdac_regmap_update(&codec->core, *d,  in set_dig_out()
2301 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,  in set_dig_out_convert()  argument
2304 	unsigned int mask = 0;  in set_dig_out_convert()
2305 	unsigned int val = 0;  in set_dig_out_convert()
2307 	if (dig1 != -1) {  in set_dig_out_convert()
2308 		mask |= 0xff;  in set_dig_out_convert()
2311 	if (dig2 != -1) {  in set_dig_out_convert()
2312 		mask |= 0xff00;  in set_dig_out_convert()
2315 	set_dig_out(codec, nid, mask, val);  in set_dig_out_convert()
2321 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);  in snd_hda_spdif_default_put()  local
2322 	int idx = kcontrol->private_value;  in snd_hda_spdif_default_put()
2328 	if (WARN_ON(codec->spdif_out.used <= idx))  in snd_hda_spdif_default_put()
2329 		return -EINVAL;  in snd_hda_spdif_default_put()
2330 	mutex_lock(&codec->spdif_mutex);  in snd_hda_spdif_default_put()
2331 	spdif = snd_array_elem(&codec->spdif_out, idx);  in snd_hda_spdif_default_put()
2332 	nid = spdif->nid;  in snd_hda_spdif_default_put()
2333 	spdif->status = ucontrol->value.iec958.status[0] |  in snd_hda_spdif_default_put()
2334 		((unsigned int)ucontrol->value.iec958.status[1] << 8) |  in snd_hda_spdif_default_put()
2335 		((unsigned int)ucontrol->value.iec958.status[2] << 16) |  in snd_hda_spdif_default_put()
2336 		((unsigned int)ucontrol->value.iec958.status[3] << 24);  in snd_hda_spdif_default_put()
2337 	val = convert_from_spdif_status(spdif->status);  in snd_hda_spdif_default_put()
2338 	val |= spdif->ctls & 1;  in snd_hda_spdif_default_put()
2339 	change = spdif->ctls != val;  in snd_hda_spdif_default_put()
2340 	spdif->ctls = val;  in snd_hda_spdif_default_put()
2341 	if (change && nid != (u16)-1)  in snd_hda_spdif_default_put()
2342 		set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);  in snd_hda_spdif_default_put()
2343 	mutex_unlock(&codec->spdif_mutex);  in snd_hda_spdif_default_put()
2352 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);  in snd_hda_spdif_out_switch_get()  local
2353 	int idx = kcontrol->private_value;  in snd_hda_spdif_out_switch_get()
2356 	if (WARN_ON(codec->spdif_out.used <= idx))  in snd_hda_spdif_out_switch_get()
2357 		return -EINVAL;  in snd_hda_spdif_out_switch_get()
2358 	mutex_lock(&codec->spdif_mutex);  in snd_hda_spdif_out_switch_get()
2359 	spdif = snd_array_elem(&codec->spdif_out, idx);  in snd_hda_spdif_out_switch_get()
2360 	ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;  in snd_hda_spdif_out_switch_get()
2361 	mutex_unlock(&codec->spdif_mutex);  in snd_hda_spdif_out_switch_get()
2362 	return 0;  in snd_hda_spdif_out_switch_get()
2365 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,  in set_spdif_ctls()  argument
2368 	set_dig_out_convert(codec, nid, dig1, dig2);  in set_spdif_ctls()
2370 	if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&  in set_spdif_ctls()
2372 		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,  in set_spdif_ctls()
2373 					    HDA_AMP_MUTE, 0);  in set_spdif_ctls()
2379 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);  in snd_hda_spdif_out_switch_put()  local
2380 	int idx = kcontrol->private_value;  in snd_hda_spdif_out_switch_put()
2386 	if (WARN_ON(codec->spdif_out.used <= idx))  in snd_hda_spdif_out_switch_put()
2387 		return -EINVAL;  in snd_hda_spdif_out_switch_put()
2388 	mutex_lock(&codec->spdif_mutex);  in snd_hda_spdif_out_switch_put()
2389 	spdif = snd_array_elem(&codec->spdif_out, idx);  in snd_hda_spdif_out_switch_put()
2390 	nid = spdif->nid;  in snd_hda_spdif_out_switch_put()
2391 	val = spdif->ctls & ~AC_DIG1_ENABLE;  in snd_hda_spdif_out_switch_put()
2392 	if (ucontrol->value.integer.value[0])  in snd_hda_spdif_out_switch_put()
2394 	change = spdif->ctls != val;  in snd_hda_spdif_out_switch_put()
2395 	spdif->ctls = val;  in snd_hda_spdif_out_switch_put()
2396 	if (change && nid != (u16)-1)  in snd_hda_spdif_out_switch_put()
2397 		set_spdif_ctls(codec, nid, val & 0xff, -1);  in snd_hda_spdif_out_switch_put()
2398 	mutex_unlock(&codec->spdif_mutex);  in snd_hda_spdif_out_switch_put()
2435  * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
2436  * @codec: the HDA codec
2443  * Returns 0 if successful, or a negative error code.
2445 int snd_hda_create_dig_out_ctls(struct hda_codec *codec,  in snd_hda_create_dig_out_ctls()  argument
2453 	int idx = 0;  in snd_hda_create_dig_out_ctls()
2454 	int val = 0;  in snd_hda_create_dig_out_ctls()
2457 	struct hda_bus *bus = codec->bus;  in snd_hda_create_dig_out_ctls()
2459 	if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&  in snd_hda_create_dig_out_ctls()
2462 	} else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&  in snd_hda_create_dig_out_ctls()
2465 		for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {  in snd_hda_create_dig_out_ctls()
2468 			kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);  in snd_hda_create_dig_out_ctls()
2471 			id = kctl->id;  in snd_hda_create_dig_out_ctls()
2473 			err = snd_ctl_rename_id(codec->card, &kctl->id, &id);  in snd_hda_create_dig_out_ctls()
2474 			if (err < 0)  in snd_hda_create_dig_out_ctls()
2477 		bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;  in snd_hda_create_dig_out_ctls()
2479 	if (!bus->primary_dig_out_type)  in snd_hda_create_dig_out_ctls()
2480 		bus->primary_dig_out_type = type;  in snd_hda_create_dig_out_ctls()
2482 	idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);  in snd_hda_create_dig_out_ctls()
2483 	if (idx < 0) {  in snd_hda_create_dig_out_ctls()
2484 		codec_err(codec, "too many IEC958 outputs\n");  in snd_hda_create_dig_out_ctls()
2485 		return -EBUSY;  in snd_hda_create_dig_out_ctls()
2487 	spdif = snd_array_new(&codec->spdif_out);  in snd_hda_create_dig_out_ctls()
2489 		return -ENOMEM;  in snd_hda_create_dig_out_ctls()
2490 	for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {  in snd_hda_create_dig_out_ctls()
2491 		kctl = snd_ctl_new1(dig_mix, codec);  in snd_hda_create_dig_out_ctls()
2493 			return -ENOMEM;  in snd_hda_create_dig_out_ctls()
2494 		kctl->id.index = idx;  in snd_hda_create_dig_out_ctls()
2495 		kctl->private_value = codec->spdif_out.used - 1;  in snd_hda_create_dig_out_ctls()
2496 		err = snd_hda_ctl_add(codec, associated_nid, kctl);  in snd_hda_create_dig_out_ctls()
2497 		if (err < 0)  in snd_hda_create_dig_out_ctls()
2500 	spdif->nid = cvt_nid;  in snd_hda_create_dig_out_ctls()
2501 	snd_hdac_regmap_read(&codec->core, cvt_nid,  in snd_hda_create_dig_out_ctls()
2503 	spdif->ctls = val;  in snd_hda_create_dig_out_ctls()
2504 	spdif->status = convert_to_spdif_status(spdif->ctls);  in snd_hda_create_dig_out_ctls()
2505 	return 0;  in snd_hda_create_dig_out_ctls()
2510  * snd_hda_spdif_out_of_nid - get the hda_spdif_out entry from the given NID
2511  * @codec: the HDA codec
2516 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,  in snd_hda_spdif_out_of_nid()  argument
2522 	snd_array_for_each(&codec->spdif_out, i, spdif) {  in snd_hda_spdif_out_of_nid()
2523 		if (spdif->nid == nid)  in snd_hda_spdif_out_of_nid()
2531  * snd_hda_spdif_ctls_unassign - Unassign the given SPDIF ctl
2532  * @codec: the HDA codec
2537 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)  in snd_hda_spdif_ctls_unassign()  argument
2541 	if (WARN_ON(codec->spdif_out.used <= idx))  in snd_hda_spdif_ctls_unassign()
2543 	mutex_lock(&codec->spdif_mutex);  in snd_hda_spdif_ctls_unassign()
2544 	spdif = snd_array_elem(&codec->spdif_out, idx);  in snd_hda_spdif_ctls_unassign()
2545 	spdif->nid = (u16)-1;  in snd_hda_spdif_ctls_unassign()
2546 	mutex_unlock(&codec->spdif_mutex);  in snd_hda_spdif_ctls_unassign()
2551  * snd_hda_spdif_ctls_assign - Assign the SPDIF controls to the given NID
2552  * @codec: the HDA codec
2558 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)  in snd_hda_spdif_ctls_assign()  argument
2563 	if (WARN_ON(codec->spdif_out.used <= idx))  in snd_hda_spdif_ctls_assign()
2565 	mutex_lock(&codec->spdif_mutex);  in snd_hda_spdif_ctls_assign()
2566 	spdif = snd_array_elem(&codec->spdif_out, idx);  in snd_hda_spdif_ctls_assign()
2567 	if (spdif->nid != nid) {  in snd_hda_spdif_ctls_assign()
2568 		spdif->nid = nid;  in snd_hda_spdif_ctls_assign()
2569 		val = spdif->ctls;  in snd_hda_spdif_ctls_assign()
2570 		set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);  in snd_hda_spdif_ctls_assign()
2572 	mutex_unlock(&codec->spdif_mutex);  in snd_hda_spdif_ctls_assign()
2583 	ucontrol->value.integer.value[0] = mout->share_spdif;  in spdif_share_sw_get()
2584 	return 0;  in spdif_share_sw_get()
2591 	mout->share_spdif = !!ucontrol->value.integer.value[0];  in spdif_share_sw_put()
2592 	return 0;  in spdif_share_sw_put()
2604  * snd_hda_create_spdif_share_sw - create Default PCM switch
2605  * @codec: the HDA codec
2606  * @mout: multi-out instance
2608 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,  in snd_hda_create_spdif_share_sw()  argument
2613 	if (!mout->dig_out_nid)  in snd_hda_create_spdif_share_sw()
2614 		return 0;  in snd_hda_create_spdif_share_sw()
2618 		return -ENOMEM;  in snd_hda_create_spdif_share_sw()
2619 	/* ATTENTION: here mout is passed as private_data, instead of codec */  in snd_hda_create_spdif_share_sw()
2620 	return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);  in snd_hda_create_spdif_share_sw()
2633 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);  in snd_hda_spdif_in_switch_get()  local
2635 	ucontrol->value.integer.value[0] = codec->spdif_in_enable;  in snd_hda_spdif_in_switch_get()
2636 	return 0;  in snd_hda_spdif_in_switch_get()
2642 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);  in snd_hda_spdif_in_switch_put()  local
2643 	hda_nid_t nid = kcontrol->private_value;  in snd_hda_spdif_in_switch_put()
2644 	unsigned int val = !!ucontrol->value.integer.value[0];  in snd_hda_spdif_in_switch_put()
2647 	mutex_lock(&codec->spdif_mutex);  in snd_hda_spdif_in_switch_put()
2648 	change = codec->spdif_in_enable != val;  in snd_hda_spdif_in_switch_put()
2650 		codec->spdif_in_enable = val;  in snd_hda_spdif_in_switch_put()
2651 		snd_hdac_regmap_write(&codec->core, nid,  in snd_hda_spdif_in_switch_put()
2654 	mutex_unlock(&codec->spdif_mutex);  in snd_hda_spdif_in_switch_put()
2661 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);  in snd_hda_spdif_in_status_get()  local
2662 	hda_nid_t nid = kcontrol->private_value;  in snd_hda_spdif_in_status_get()
2666 	snd_hdac_regmap_read(&codec->core, nid,  in snd_hda_spdif_in_status_get()
2669 	ucontrol->value.iec958.status[0] = sbits;  in snd_hda_spdif_in_status_get()
2670 	ucontrol->value.iec958.status[1] = sbits >> 8;  in snd_hda_spdif_in_status_get()
2671 	ucontrol->value.iec958.status[2] = sbits >> 16;  in snd_hda_spdif_in_status_get()
2672 	ucontrol->value.iec958.status[3] = sbits >> 24;  in snd_hda_spdif_in_status_get()
2673 	return 0;  in snd_hda_spdif_in_status_get()
2695  * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2696  * @codec: the HDA codec
2702  * Returns 0 if successful, or a negative error code.
2704 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)  in snd_hda_create_spdif_in_ctls()  argument
2711 	idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);  in snd_hda_create_spdif_in_ctls()
2712 	if (idx < 0) {  in snd_hda_create_spdif_in_ctls()
2713 		codec_err(codec, "too many IEC958 inputs\n");  in snd_hda_create_spdif_in_ctls()
2714 		return -EBUSY;  in snd_hda_create_spdif_in_ctls()
2716 	for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {  in snd_hda_create_spdif_in_ctls()
2717 		kctl = snd_ctl_new1(dig_mix, codec);  in snd_hda_create_spdif_in_ctls()
2719 			return -ENOMEM;  in snd_hda_create_spdif_in_ctls()
2720 		kctl->private_value = nid;  in snd_hda_create_spdif_in_ctls()
2721 		err = snd_hda_ctl_add(codec, nid, kctl);  in snd_hda_create_spdif_in_ctls()
2722 		if (err < 0)  in snd_hda_create_spdif_in_ctls()
2725 	codec->spdif_in_enable =  in snd_hda_create_spdif_in_ctls()
2726 		snd_hda_codec_read(codec, nid, 0,  in snd_hda_create_spdif_in_ctls()
2727 				   AC_VERB_GET_DIGI_CONVERT_1, 0) &  in snd_hda_create_spdif_in_ctls()
2729 	return 0;  in snd_hda_create_spdif_in_ctls()
2734  * snd_hda_codec_set_power_to_all - Set the power state to all widgets
2735  * @codec: the HDA codec
2740  * If the codec has power_filter set, it evaluates the power state and
2743 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,  in snd_hda_codec_set_power_to_all()  argument
2748 	for_each_hda_codec_node(nid, codec) {  in snd_hda_codec_set_power_to_all()
2749 		unsigned int wcaps = get_wcaps(codec, nid);  in snd_hda_codec_set_power_to_all()
2753 		if (codec->power_filter) {  in snd_hda_codec_set_power_to_all()
2754 			state = codec->power_filter(codec, nid, power_state);  in snd_hda_codec_set_power_to_all()
2758 		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,  in snd_hda_codec_set_power_to_all()
2765  * snd_hda_codec_eapd_power_filter - A power filter callback for EAPD
2766  * @codec: the HDA codec
2771  * This can be used a codec power_filter callback.
2773 unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,  in snd_hda_codec_eapd_power_filter()  argument
2777 	if (nid == codec->core.afg || nid == codec->core.mfg)  in snd_hda_codec_eapd_power_filter()
2780 	    get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&  in snd_hda_codec_eapd_power_filter()
2781 	    (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {  in snd_hda_codec_eapd_power_filter()
2782 		int eapd = snd_hda_codec_read(codec, nid, 0,  in snd_hda_codec_eapd_power_filter()
2783 					      AC_VERB_GET_EAPD_BTLENABLE, 0);  in snd_hda_codec_eapd_power_filter()
2784 		if (eapd & 0x02)  in snd_hda_codec_eapd_power_filter()
2792  * set power state of the codec, and return the power state
2794 static unsigned int hda_set_power_state(struct hda_codec *codec,  in hda_set_power_state()  argument
2797 	hda_nid_t fg = codec->core.afg ? codec->core.afg : codec->core.mfg;  in hda_set_power_state()
2800 	int flags = 0;  in hda_set_power_state()
2802 	/* this delay seems necessary to avoid click noise at power-down */  in hda_set_power_state()
2804 		if (codec->depop_delay < 0)  in hda_set_power_state()
2805 			msleep(codec_has_epss(codec) ? 10 : 100);  in hda_set_power_state()
2806 		else if (codec->depop_delay > 0)  in hda_set_power_state()
2807 			msleep(codec->depop_delay);  in hda_set_power_state()
2812 	for (count = 0; count < 10; count++) {  in hda_set_power_state()
2813 		if (codec->patch_ops.set_power_state)  in hda_set_power_state()
2814 			codec->patch_ops.set_power_state(codec, fg,  in hda_set_power_state()
2818 			if (codec->power_filter)  in hda_set_power_state()
2819 				state = codec->power_filter(codec, fg, state);  in hda_set_power_state()
2821 				snd_hda_codec_read(codec, fg, flags,  in hda_set_power_state()
2824 			snd_hda_codec_set_power_to_all(codec, fg, power_state);  in hda_set_power_state()
2826 		state = snd_hda_sync_power_state(codec, fg, power_state);  in hda_set_power_state()
2835  * this is called at the end of codec parsing
2837 static void sync_power_up_states(struct hda_codec *codec)  in sync_power_up_states()  argument
2842 	if (!codec->power_filter)  in sync_power_up_states()
2845 	for_each_hda_codec_node(nid, codec) {  in sync_power_up_states()
2846 		unsigned int wcaps = get_wcaps(codec, nid);  in sync_power_up_states()
2850 		target = codec->power_filter(codec, nid, AC_PWRST_D0);  in sync_power_up_states()
2853 		if (!snd_hda_check_power_state(codec, nid, target))  in sync_power_up_states()
2854 			snd_hda_codec_write(codec, nid, 0,  in sync_power_up_states()
2861 static void hda_exec_init_verbs(struct hda_codec *codec)  in hda_exec_init_verbs()  argument
2863 	if (codec->init_verbs.list)  in hda_exec_init_verbs()
2864 		snd_hda_sequence_write(codec, codec->init_verbs.list);  in hda_exec_init_verbs()
2867 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}  in hda_exec_init_verbs()  argument
2871 static void update_power_acct(struct hda_codec *codec, bool on)  in update_power_acct()  argument
2873 	unsigned long delta = jiffies - codec->power_jiffies;  in update_power_acct()
2876 		codec->power_on_acct += delta;  in update_power_acct()
2878 		codec->power_off_acct += delta;  in update_power_acct()
2879 	codec->power_jiffies += delta;  in update_power_acct()
2882 void snd_hda_update_power_acct(struct hda_codec *codec)  in snd_hda_update_power_acct()  argument
2884 	update_power_acct(codec, hda_codec_is_power_on(codec));  in snd_hda_update_power_acct()
2888  * call suspend and power-down; used both from PM and power-save
2891 static unsigned int hda_call_codec_suspend(struct hda_codec *codec)  in hda_call_codec_suspend()  argument
2895 	snd_hdac_enter_pm(&codec->core);  in hda_call_codec_suspend()
2896 	if (codec->patch_ops.suspend)  in hda_call_codec_suspend()
2897 		codec->patch_ops.suspend(codec);  in hda_call_codec_suspend()
2898 	if (!codec->no_stream_clean_at_suspend)  in hda_call_codec_suspend()
2899 		hda_cleanup_all_streams(codec);  in hda_call_codec_suspend()
2900 	state = hda_set_power_state(codec, AC_PWRST_D3);  in hda_call_codec_suspend()
2901 	update_power_acct(codec, true);  in hda_call_codec_suspend()
2902 	snd_hdac_leave_pm(&codec->core);  in hda_call_codec_suspend()
2907  * kick up codec; used both from PM and power-save
2909 static void hda_call_codec_resume(struct hda_codec *codec)  in hda_call_codec_resume()  argument
2911 	snd_hdac_enter_pm(&codec->core);  in hda_call_codec_resume()
2912 	if (codec->core.regmap)  in hda_call_codec_resume()
2913 		regcache_mark_dirty(codec->core.regmap);  in hda_call_codec_resume()
2915 	codec->power_jiffies = jiffies;  in hda_call_codec_resume()
2917 	hda_set_power_state(codec, AC_PWRST_D0);  in hda_call_codec_resume()
2918 	restore_shutup_pins(codec);  in hda_call_codec_resume()
2919 	hda_exec_init_verbs(codec);  in hda_call_codec_resume()
2920 	snd_hda_jack_set_dirty_all(codec);  in hda_call_codec_resume()
2921 	if (codec->patch_ops.resume)  in hda_call_codec_resume()
2922 		codec->patch_ops.resume(codec);  in hda_call_codec_resume()
2924 		if (codec->patch_ops.init)  in hda_call_codec_resume()
2925 			codec->patch_ops.init(codec);  in hda_call_codec_resume()
2926 		snd_hda_regmap_sync(codec);  in hda_call_codec_resume()
2929 	if (codec->jackpoll_interval)  in hda_call_codec_resume()
2930 		hda_jackpoll_work(&codec->jackpoll_work.work);  in hda_call_codec_resume()
2932 		snd_hda_jack_report_sync(codec);  in hda_call_codec_resume()
2933 	codec->core.dev.power.power_state = PMSG_ON;  in hda_call_codec_resume()
2934 	snd_hdac_leave_pm(&codec->core);  in hda_call_codec_resume()
2939 	struct hda_codec *codec = dev_to_hda_codec(dev);  in hda_codec_runtime_suspend()  local
2943 	if (!codec->card)  in hda_codec_runtime_suspend()
2944 		return 0;  in hda_codec_runtime_suspend()
2946 	cancel_delayed_work_sync(&codec->jackpoll_work);  in hda_codec_runtime_suspend()
2948 	state = hda_call_codec_suspend(codec);  in hda_codec_runtime_suspend()
2949 	if (codec->link_down_at_suspend ||  in hda_codec_runtime_suspend()
2950 	    (codec_has_clkstop(codec) && codec_has_epss(codec) &&  in hda_codec_runtime_suspend()
2952 		snd_hdac_codec_link_down(&codec->core);  in hda_codec_runtime_suspend()
2953 	snd_hda_codec_display_power(codec, false);  in hda_codec_runtime_suspend()
2955 	if (codec->bus->jackpoll_in_suspend &&  in hda_codec_runtime_suspend()
2956 		(dev->power.power_state.event != PM_EVENT_SUSPEND))  in hda_codec_runtime_suspend()
2957 		schedule_delayed_work(&codec->jackpoll_work,  in hda_codec_runtime_suspend()
2958 					codec->jackpoll_interval);  in hda_codec_runtime_suspend()
2959 	return 0;  in hda_codec_runtime_suspend()
2964 	struct hda_codec *codec = dev_to_hda_codec(dev);  in hda_codec_runtime_resume()  local
2967 	if (!codec->card)  in hda_codec_runtime_resume()
2968 		return 0;  in hda_codec_runtime_resume()
2970 	snd_hda_codec_display_power(codec, true);  in hda_codec_runtime_resume()
2971 	snd_hdac_codec_link_up(&codec->core);  in hda_codec_runtime_resume()
2972 	hda_call_codec_resume(codec);  in hda_codec_runtime_resume()
2974 	return 0;  in hda_codec_runtime_resume()
2979 	struct hda_codec *codec = dev_to_hda_codec(dev);  in hda_codec_pm_prepare()  local
2981 	cancel_delayed_work_sync(&codec->jackpoll_work);  in hda_codec_pm_prepare()
2982 	dev->power.power_state = PMSG_SUSPEND;  in hda_codec_pm_prepare()
2988 	struct hda_codec *codec = dev_to_hda_codec(dev);  in hda_codec_pm_complete()  local
2990 	/* If no other pm-functions are called between prepare() and complete() */  in hda_codec_pm_complete()
2991 	if (dev->power.power_state.event == PM_EVENT_SUSPEND)  in hda_codec_pm_complete()
2992 		dev->power.power_state = PMSG_RESUME;  in hda_codec_pm_complete()
2994 	if (pm_runtime_suspended(dev) && (codec->jackpoll_interval ||  in hda_codec_pm_complete()
2995 	    hda_codec_need_resume(codec) || codec->forced_resume))  in hda_codec_pm_complete()
3001 	dev->power.power_state = PMSG_SUSPEND;  in hda_codec_pm_suspend()
3007 	dev->power.power_state = PMSG_RESUME;  in hda_codec_pm_resume()
3013 	struct hda_codec *codec = dev_to_hda_codec(dev);  in hda_codec_pm_freeze()  local
3015 	cancel_delayed_work_sync(&codec->jackpoll_work);  in hda_codec_pm_freeze()
3016 	dev->power.power_state = PMSG_FREEZE;  in hda_codec_pm_freeze()
3022 	dev->power.power_state = PMSG_THAW;  in hda_codec_pm_thaw()
3028 	dev->power.power_state = PMSG_RESTORE;  in hda_codec_pm_restore()
3046 /* suspend the codec at shutdown; called from driver's shutdown callback */
3047 void snd_hda_codec_shutdown(struct hda_codec *codec)  in snd_hda_codec_shutdown()  argument
3051 	/* Skip the shutdown if codec is not registered */  in snd_hda_codec_shutdown()
3052 	if (!codec->core.registered)  in snd_hda_codec_shutdown()
3055 	cancel_delayed_work_sync(&codec->jackpoll_work);  in snd_hda_codec_shutdown()
3056 	list_for_each_entry(cpcm, &codec->pcm_list_head, list)  in snd_hda_codec_shutdown()
3057 		snd_pcm_suspend_all(cpcm->pcm);  in snd_hda_codec_shutdown()
3059 	pm_runtime_force_suspend(hda_codec_dev(codec));  in snd_hda_codec_shutdown()
3060 	pm_runtime_disable(hda_codec_dev(codec));  in snd_hda_codec_shutdown()
3066 static int add_std_chmaps(struct hda_codec *codec)  in add_std_chmaps()  argument
3071 	list_for_each_entry(pcm, &codec->pcm_list_head, list) {  in add_std_chmaps()
3072 		for (str = 0; str < 2; str++) {  in add_std_chmaps()
3073 			struct hda_pcm_stream *hinfo = &pcm->stream[str];  in add_std_chmaps()
3077 			if (!pcm->pcm || pcm->own_chmap || !hinfo->substreams)  in add_std_chmaps()
3079 			elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;  in add_std_chmaps()
3080 			err = snd_pcm_add_chmap_ctls(pcm->pcm, str, elem,  in add_std_chmaps()
3081 						     hinfo->channels_max,  in add_std_chmaps()
3082 						     0, &chmap);  in add_std_chmaps()
3083 			if (err < 0)  in add_std_chmaps()
3085 			chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;  in add_std_chmaps()
3088 	return 0;  in add_std_chmaps()
3092  * since HD-audio supports only stereo, odd number channels are omitted
3104 int snd_hda_codec_build_controls(struct hda_codec *codec)  in snd_hda_codec_build_controls()  argument
3106 	int err = 0;  in snd_hda_codec_build_controls()
3107 	hda_exec_init_verbs(codec);  in snd_hda_codec_build_controls()
3109 	if (codec->patch_ops.init)  in snd_hda_codec_build_controls()
3110 		err = codec->patch_ops.init(codec);  in snd_hda_codec_build_controls()
3111 	if (!err && codec->patch_ops.build_controls)  in snd_hda_codec_build_controls()
3112 		err = codec->patch_ops.build_controls(codec);  in snd_hda_codec_build_controls()
3113 	if (err < 0)  in snd_hda_codec_build_controls()
3117 	err = add_std_chmaps(codec);  in snd_hda_codec_build_controls()
3118 	if (err < 0)  in snd_hda_codec_build_controls()
3121 	if (codec->jackpoll_interval)  in snd_hda_codec_build_controls()
3122 		hda_jackpoll_work(&codec->jackpoll_work.work);  in snd_hda_codec_build_controls()
3124 		snd_hda_jack_report_sync(codec); /* call at the last init point */  in snd_hda_codec_build_controls()
3125 	sync_power_up_states(codec);  in snd_hda_codec_build_controls()
3126 	return 0;  in snd_hda_codec_build_controls()
3134 				      struct hda_codec *codec,  in hda_pcm_default_open_close()  argument
3137 	return 0;  in hda_pcm_default_open_close()
3141 				   struct hda_codec *codec,  in hda_pcm_default_prepare()  argument
3146 	snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);  in hda_pcm_default_prepare()
3147 	return 0;  in hda_pcm_default_prepare()
3151 				   struct hda_codec *codec,  in hda_pcm_default_cleanup()  argument
3154 	snd_hda_codec_cleanup_stream(codec, hinfo->nid);  in hda_pcm_default_cleanup()
3155 	return 0;  in hda_pcm_default_cleanup()
3158 static int set_pcm_default_values(struct hda_codec *codec,  in set_pcm_default_values()  argument
3164 	if (info->nid && (!info->rates || !info->formats)) {  in set_pcm_default_values()
3165 		err = snd_hda_query_supported_pcm(codec, info->nid,  in set_pcm_default_values()
3166 				info->rates ? NULL : &info->rates,  in set_pcm_default_values()
3167 				info->formats ? NULL : &info->formats,  in set_pcm_default_values()
3168 				info->subformats ? NULL : &info->subformats,  in set_pcm_default_values()
3169 				info->maxbps ? NULL : &info->maxbps);  in set_pcm_default_values()
3170 		if (err < 0)  in set_pcm_default_values()
3173 	if (info->ops.open == NULL)  in set_pcm_default_values()
3174 		info->ops.open = hda_pcm_default_open_close;  in set_pcm_default_values()
3175 	if (info->ops.close == NULL)  in set_pcm_default_values()
3176 		info->ops.close = hda_pcm_default_open_close;  in set_pcm_default_values()
3177 	if (info->ops.prepare == NULL) {  in set_pcm_default_values()
3178 		if (snd_BUG_ON(!info->nid))  in set_pcm_default_values()
3179 			return -EINVAL;  in set_pcm_default_values()
3180 		info->ops.prepare = hda_pcm_default_prepare;  in set_pcm_default_values()
3182 	if (info->ops.cleanup == NULL) {  in set_pcm_default_values()
3183 		if (snd_BUG_ON(!info->nid))  in set_pcm_default_values()
3184 			return -EINVAL;  in set_pcm_default_values()
3185 		info->ops.cleanup = hda_pcm_default_cleanup;  in set_pcm_default_values()
3187 	return 0;  in set_pcm_default_values()
3191  * codec prepare/cleanup entries
3194  * snd_hda_codec_prepare - Prepare a stream
3195  * @codec: the HDA codec
3201  * Calls the prepare callback set by the codec with the given arguments.
3204 int snd_hda_codec_prepare(struct hda_codec *codec,  in snd_hda_codec_prepare()  argument
3211 	mutex_lock(&codec->bus->prepare_mutex);  in snd_hda_codec_prepare()
3212 	if (hinfo->ops.prepare)  in snd_hda_codec_prepare()
3213 		ret = hinfo->ops.prepare(hinfo, codec, stream, format,  in snd_hda_codec_prepare()
3216 		ret = -ENODEV;  in snd_hda_codec_prepare()
3217 	if (ret >= 0)  in snd_hda_codec_prepare()
3218 		purify_inactive_streams(codec);  in snd_hda_codec_prepare()
3219 	mutex_unlock(&codec->bus->prepare_mutex);  in snd_hda_codec_prepare()
3225  * snd_hda_codec_cleanup - Clean up stream resources
3226  * @codec: the HDA codec
3230  * Calls the cleanup callback set by the codec with the given arguments.
3232 void snd_hda_codec_cleanup(struct hda_codec *codec,  in snd_hda_codec_cleanup()  argument
3236 	mutex_lock(&codec->bus->prepare_mutex);  in snd_hda_codec_cleanup()
3237 	if (hinfo->ops.cleanup)  in snd_hda_codec_cleanup()
3238 		hinfo->ops.cleanup(hinfo, codec, substream);  in snd_hda_codec_cleanup()
3239 	mutex_unlock(&codec->bus->prepare_mutex);  in snd_hda_codec_cleanup()
3258 		[HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },  in get_empty_pcm_device()
3259 		[HDA_PCM_TYPE_SPDIF] = { 1, -1 },  in get_empty_pcm_device()
3260 		[HDA_PCM_TYPE_HDMI]  = { 3, 7, 8, 9, -1 },  in get_empty_pcm_device()
3261 		[HDA_PCM_TYPE_MODEM] = { 6, -1 },  in get_empty_pcm_device()
3266 		dev_err(bus->card->dev, "Invalid PCM type %d\n", type);  in get_empty_pcm_device()
3267 		return -EINVAL;  in get_empty_pcm_device()
3270 	for (i = 0; audio_idx[type][i] >= 0; i++) {  in get_empty_pcm_device()
3275 		if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))  in get_empty_pcm_device()
3280 	/* non-fixed slots starting from 10 */  in get_empty_pcm_device()
3282 		if (!test_and_set_bit(i, bus->pcm_dev_bits))  in get_empty_pcm_device()
3287 	dev_warn(bus->card->dev, "Too many %s devices\n",  in get_empty_pcm_device()
3290 	dev_warn(bus->card->dev,  in get_empty_pcm_device()
3293 	return -EAGAIN;  in get_empty_pcm_device()
3296 /* call build_pcms ops of the given codec and set up the default parameters */
3297 int snd_hda_codec_parse_pcms(struct hda_codec *codec)  in snd_hda_codec_parse_pcms()  argument
3302 	if (!list_empty(&codec->pcm_list_head))  in snd_hda_codec_parse_pcms()
3303 		return 0; /* already parsed */  in snd_hda_codec_parse_pcms()
3305 	if (!codec->patch_ops.build_pcms)  in snd_hda_codec_parse_pcms()
3306 		return 0;  in snd_hda_codec_parse_pcms()
3308 	err = codec->patch_ops.build_pcms(codec);  in snd_hda_codec_parse_pcms()
3309 	if (err < 0) {  in snd_hda_codec_parse_pcms()
3310 		codec_err(codec, "cannot build PCMs for #%d (error %d)\n",  in snd_hda_codec_parse_pcms()
3311 			  codec->core.addr, err);  in snd_hda_codec_parse_pcms()
3315 	list_for_each_entry(cpcm, &codec->pcm_list_head, list) {  in snd_hda_codec_parse_pcms()
3319 			struct hda_pcm_stream *info = &cpcm->stream[stream];  in snd_hda_codec_parse_pcms()
3321 			if (!info->substreams)  in snd_hda_codec_parse_pcms()
3323 			err = set_pcm_default_values(codec, info);  in snd_hda_codec_parse_pcms()
3324 			if (err < 0) {  in snd_hda_codec_parse_pcms()
3325 				codec_warn(codec,  in snd_hda_codec_parse_pcms()
3327 					   cpcm->name);  in snd_hda_codec_parse_pcms()
3333 	return 0;  in snd_hda_codec_parse_pcms()
3337 /* assign all PCMs of the given codec */
3338 int snd_hda_codec_build_pcms(struct hda_codec *codec)  in snd_hda_codec_build_pcms()  argument
3340 	struct hda_bus *bus = codec->bus;  in snd_hda_codec_build_pcms()
3344 	err = snd_hda_codec_parse_pcms(codec);  in snd_hda_codec_build_pcms()
3345 	if (err < 0)  in snd_hda_codec_build_pcms()
3349 	list_for_each_entry(cpcm, &codec->pcm_list_head, list) {  in snd_hda_codec_build_pcms()
3350 		if (cpcm->pcm)  in snd_hda_codec_build_pcms()
3352 		if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)  in snd_hda_codec_build_pcms()
3355 		dev = get_empty_pcm_device(bus, cpcm->pcm_type);  in snd_hda_codec_build_pcms()
3356 		if (dev < 0) {  in snd_hda_codec_build_pcms()
3357 			cpcm->device = SNDRV_PCM_INVALID_DEVICE;  in snd_hda_codec_build_pcms()
3360 		cpcm->device = dev;  in snd_hda_codec_build_pcms()
3361 		err =  snd_hda_attach_pcm_stream(bus, codec, cpcm);  in snd_hda_codec_build_pcms()
3362 		if (err < 0) {  in snd_hda_codec_build_pcms()
3363 			codec_err(codec,  in snd_hda_codec_build_pcms()
3364 				  "cannot attach PCM stream %d for codec #%d\n",  in snd_hda_codec_build_pcms()
3365 				  dev, codec->core.addr);  in snd_hda_codec_build_pcms()
3370 	return 0;  in snd_hda_codec_build_pcms()
3374  * snd_hda_add_new_ctls - create controls from the array
3375  * @codec: the HDA codec
3381  * Returns 0 if successful, or a negative error code.
3383 int snd_hda_add_new_ctls(struct hda_codec *codec,  in snd_hda_add_new_ctls()  argument
3388 	for (; knew->name; knew++) {  in snd_hda_add_new_ctls()
3390 		int addr = 0, idx = 0;  in snd_hda_add_new_ctls()
3391 		if (knew->iface == (__force snd_ctl_elem_iface_t)-1)  in snd_hda_add_new_ctls()
3392 			continue; /* skip this codec private value */  in snd_hda_add_new_ctls()
3394 			kctl = snd_ctl_new1(knew, codec);  in snd_hda_add_new_ctls()
3396 				return -ENOMEM;  in snd_hda_add_new_ctls()
3402 			if (addr > 0 && codec->ctl_dev_id)  in snd_hda_add_new_ctls()
3403 				kctl->id.device = addr;  in snd_hda_add_new_ctls()
3404 			if (idx > 0)  in snd_hda_add_new_ctls()
3405 				kctl->id.index = idx;  in snd_hda_add_new_ctls()
3406 			err = snd_hda_ctl_add(codec, 0, kctl);  in snd_hda_add_new_ctls()
3410 			 * the codec addr; if it still fails (or it's the  in snd_hda_add_new_ctls()
3411 			 * primary codec), then try another control index  in snd_hda_add_new_ctls()
3413 			if (!addr && codec->core.addr) {  in snd_hda_add_new_ctls()
3414 				addr = codec->core.addr;  in snd_hda_add_new_ctls()
3415 				if (!codec->ctl_dev_id)  in snd_hda_add_new_ctls()
3417 			} else if (!idx && !knew->index) {  in snd_hda_add_new_ctls()
3418 				idx = find_empty_mixer_ctl_idx(codec,  in snd_hda_add_new_ctls()
3419 							       knew->name, 0);  in snd_hda_add_new_ctls()
3420 				if (idx <= 0)  in snd_hda_add_new_ctls()
3426 	return 0;  in snd_hda_add_new_ctls()
3431  * snd_hda_codec_set_power_save - Configure codec's runtime PM
3432  * @codec: codec device to configure
3435 void snd_hda_codec_set_power_save(struct hda_codec *codec, int delay)  in snd_hda_codec_set_power_save()  argument
3437 	struct device *dev = hda_codec_dev(codec);  in snd_hda_codec_set_power_save()
3439 	if (delay == 0 && codec->auto_runtime_pm)  in snd_hda_codec_set_power_save()
3442 	if (delay > 0) {  in snd_hda_codec_set_power_save()
3456  * snd_hda_set_power_save - reprogram autosuspend for the given delay
3457  * @bus: HD-audio bus
3458  * @delay: autosuspend delay in msec, 0 = off
3472  * snd_hda_check_amp_list_power - Check the amp list and update the power
3473  * @codec: HD-audio codec
3478  * check the current AMP status, and update the power-status according
3484 int snd_hda_check_amp_list_power(struct hda_codec *codec,  in snd_hda_check_amp_list_power()  argument
3491 	if (!check->amplist)  in snd_hda_check_amp_list_power()
3492 		return 0;  in snd_hda_check_amp_list_power()
3493 	for (p = check->amplist; p->nid; p++) {  in snd_hda_check_amp_list_power()
3494 		if (p->nid == nid)  in snd_hda_check_amp_list_power()
3497 	if (!p->nid)  in snd_hda_check_amp_list_power()
3498 		return 0; /* nothing changed */  in snd_hda_check_amp_list_power()
3500 	for (p = check->amplist; p->nid; p++) {  in snd_hda_check_amp_list_power()
3501 		for (ch = 0; ch < 2; ch++) {  in snd_hda_check_amp_list_power()
3502 			v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,  in snd_hda_check_amp_list_power()
3503 						   p->idx);  in snd_hda_check_amp_list_power()
3504 			if (!(v & HDA_AMP_MUTE) && v > 0) {  in snd_hda_check_amp_list_power()
3505 				if (!check->power_on) {  in snd_hda_check_amp_list_power()
3506 					check->power_on = 1;  in snd_hda_check_amp_list_power()
3507 					snd_hda_power_up_pm(codec);  in snd_hda_check_amp_list_power()
3513 	if (check->power_on) {  in snd_hda_check_amp_list_power()
3514 		check->power_on = 0;  in snd_hda_check_amp_list_power()
3515 		snd_hda_power_down_pm(codec);  in snd_hda_check_amp_list_power()
3517 	return 0;  in snd_hda_check_amp_list_power()
3526  * snd_hda_input_mux_info - Info callback helper for the input-mux enum
3535 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;  in snd_hda_input_mux_info()
3536 	uinfo->count = 1;  in snd_hda_input_mux_info()
3537 	uinfo->value.enumerated.items = imux->num_items;  in snd_hda_input_mux_info()
3538 	if (!imux->num_items)  in snd_hda_input_mux_info()
3539 		return 0;  in snd_hda_input_mux_info()
3540 	index = uinfo->value.enumerated.item;  in snd_hda_input_mux_info()
3541 	if (index >= imux->num_items)  in snd_hda_input_mux_info()
3542 		index = imux->num_items - 1;  in snd_hda_input_mux_info()
3543 	strcpy(uinfo->value.enumerated.name, imux->items[index].label);  in snd_hda_input_mux_info()
3544 	return 0;  in snd_hda_input_mux_info()
3549  * snd_hda_input_mux_put - Put callback helper for the input-mux enum
3550  * @codec: the HDA codec
3556 int snd_hda_input_mux_put(struct hda_codec *codec,  in snd_hda_input_mux_put()  argument
3564 	if (!imux->num_items)  in snd_hda_input_mux_put()
3565 		return 0;  in snd_hda_input_mux_put()
3566 	idx = ucontrol->value.enumerated.item[0];  in snd_hda_input_mux_put()
3567 	if (idx >= imux->num_items)  in snd_hda_input_mux_put()
3568 		idx = imux->num_items - 1;  in snd_hda_input_mux_put()
3570 		return 0;  in snd_hda_input_mux_put()
3571 	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,  in snd_hda_input_mux_put()
3572 				  imux->items[idx].index);  in snd_hda_input_mux_put()
3580  * snd_hda_enum_helper_info - Helper for simple enum ctls
3587  * when @num_items is 0 or @texts is NULL, assume a boolean enum array
3607  * Multi-channel / digital-out PCM helper functions
3611 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,  in setup_dig_out_stream()  argument
3618 	spdif = snd_hda_spdif_out_of_nid(codec, nid);  in setup_dig_out_stream()
3625 	curr_fmt = snd_hda_codec_read(codec, nid, 0,  in setup_dig_out_stream()
3626 				      AC_VERB_GET_STREAM_FORMAT, 0);  in setup_dig_out_stream()
3627 	reset = codec->spdif_status_reset &&  in setup_dig_out_stream()
3628 		(spdif->ctls & AC_DIG1_ENABLE) &&  in setup_dig_out_stream()
3634 		set_dig_out_convert(codec, nid,  in setup_dig_out_stream()
3635 				    spdif->ctls & ~AC_DIG1_ENABLE & 0xff,  in setup_dig_out_stream()
3636 				    -1);  in setup_dig_out_stream()
3637 	snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);  in setup_dig_out_stream()
3638 	if (codec->follower_dig_outs) {  in setup_dig_out_stream()
3640 		for (d = codec->follower_dig_outs; *d; d++)  in setup_dig_out_stream()
3641 			snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,  in setup_dig_out_stream()
3646 		set_dig_out_convert(codec, nid,  in setup_dig_out_stream()
3647 				    spdif->ctls & 0xff, -1);  in setup_dig_out_stream()
3650 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)  in cleanup_dig_out_stream()  argument
3652 	snd_hda_codec_cleanup_stream(codec, nid);  in cleanup_dig_out_stream()
3653 	if (codec->follower_dig_outs) {  in cleanup_dig_out_stream()
3655 		for (d = codec->follower_dig_outs; *d; d++)  in cleanup_dig_out_stream()
3656 			snd_hda_codec_cleanup_stream(codec, *d);  in cleanup_dig_out_stream()
3661  * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
3662  * @codec: the HDA codec
3665 int snd_hda_multi_out_dig_open(struct hda_codec *codec,  in snd_hda_multi_out_dig_open()  argument
3668 	mutex_lock(&codec->spdif_mutex);  in snd_hda_multi_out_dig_open()
3669 	if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)  in snd_hda_multi_out_dig_open()
3671 		cleanup_dig_out_stream(codec, mout->dig_out_nid);  in snd_hda_multi_out_dig_open()
3672 	mout->dig_out_used = HDA_DIG_EXCLUSIVE;  in snd_hda_multi_out_dig_open()
3673 	mutex_unlock(&codec->spdif_mutex);  in snd_hda_multi_out_dig_open()
3674 	return 0;  in snd_hda_multi_out_dig_open()
3679  * snd_hda_multi_out_dig_prepare - prepare the digital out stream
3680  * @codec: the HDA codec
3686 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,  in snd_hda_multi_out_dig_prepare()  argument
3692 	mutex_lock(&codec->spdif_mutex);  in snd_hda_multi_out_dig_prepare()
3693 	setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);  in snd_hda_multi_out_dig_prepare()
3694 	mutex_unlock(&codec->spdif_mutex);  in snd_hda_multi_out_dig_prepare()
3695 	return 0;  in snd_hda_multi_out_dig_prepare()
3700  * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
3701  * @codec: the HDA codec
3704 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,  in snd_hda_multi_out_dig_cleanup()  argument
3707 	mutex_lock(&codec->spdif_mutex);  in snd_hda_multi_out_dig_cleanup()
3708 	cleanup_dig_out_stream(codec, mout->dig_out_nid);  in snd_hda_multi_out_dig_cleanup()
3709 	mutex_unlock(&codec->spdif_mutex);  in snd_hda_multi_out_dig_cleanup()
3710 	return 0;  in snd_hda_multi_out_dig_cleanup()
3715  * snd_hda_multi_out_dig_close - release the digital out stream
3716  * @codec: the HDA codec
3719 int snd_hda_multi_out_dig_close(struct hda_codec *codec,  in snd_hda_multi_out_dig_close()  argument
3722 	mutex_lock(&codec->spdif_mutex);  in snd_hda_multi_out_dig_close()
3723 	mout->dig_out_used = 0;  in snd_hda_multi_out_dig_close()
3724 	mutex_unlock(&codec->spdif_mutex);  in snd_hda_multi_out_dig_close()
3725 	return 0;  in snd_hda_multi_out_dig_close()
3730  * snd_hda_multi_out_analog_open - open analog outputs
3731  * @codec: the HDA codec
3736  * Open analog outputs and set up the hw-constraints.
3740 int snd_hda_multi_out_analog_open(struct hda_codec *codec,  in snd_hda_multi_out_analog_open()  argument
3745 	struct snd_pcm_runtime *runtime = substream->runtime;  in snd_hda_multi_out_analog_open()
3746 	runtime->hw.channels_max = mout->max_channels;  in snd_hda_multi_out_analog_open()
3747 	if (mout->dig_out_nid) {  in snd_hda_multi_out_analog_open()
3748 		if (!mout->analog_rates) {  in snd_hda_multi_out_analog_open()
3749 			mout->analog_rates = hinfo->rates;  in snd_hda_multi_out_analog_open()
3750 			mout->analog_formats = hinfo->formats;  in snd_hda_multi_out_analog_open()
3751 			mout->analog_maxbps = hinfo->maxbps;  in snd_hda_multi_out_analog_open()
3753 			runtime->hw.rates = mout->analog_rates;  in snd_hda_multi_out_analog_open()
3754 			runtime->hw.formats = mout->analog_formats;  in snd_hda_multi_out_analog_open()
3755 			hinfo->maxbps = mout->analog_maxbps;  in snd_hda_multi_out_analog_open()
3757 		if (!mout->spdif_rates) {  in snd_hda_multi_out_analog_open()
3758 			snd_hda_query_supported_pcm(codec, mout->dig_out_nid,  in snd_hda_multi_out_analog_open()
3759 						    &mout->spdif_rates,  in snd_hda_multi_out_analog_open()
3760 						    &mout->spdif_formats,  in snd_hda_multi_out_analog_open()
3762 						    &mout->spdif_maxbps);  in snd_hda_multi_out_analog_open()
3764 		mutex_lock(&codec->spdif_mutex);  in snd_hda_multi_out_analog_open()
3765 		if (mout->share_spdif) {  in snd_hda_multi_out_analog_open()
3766 			if ((runtime->hw.rates & mout->spdif_rates) &&  in snd_hda_multi_out_analog_open()
3767 			    (runtime->hw.formats & mout->spdif_formats)) {  in snd_hda_multi_out_analog_open()
3768 				runtime->hw.rates &= mout->spdif_rates;  in snd_hda_multi_out_analog_open()
3769 				runtime->hw.formats &= mout->spdif_formats;  in snd_hda_multi_out_analog_open()
3770 				if (mout->spdif_maxbps < hinfo->maxbps)  in snd_hda_multi_out_analog_open()
3771 					hinfo->maxbps = mout->spdif_maxbps;  in snd_hda_multi_out_analog_open()
3773 				mout->share_spdif = 0;  in snd_hda_multi_out_analog_open()
3777 		mutex_unlock(&codec->spdif_mutex);  in snd_hda_multi_out_analog_open()
3779 	return snd_pcm_hw_constraint_step(substream->runtime, 0,  in snd_hda_multi_out_analog_open()
3785  * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
3786  * @codec: the HDA codec
3795 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,  in snd_hda_multi_out_analog_prepare()  argument
3801 	const hda_nid_t *nids = mout->dac_nids;  in snd_hda_multi_out_analog_prepare()
3802 	int chs = substream->runtime->channels;  in snd_hda_multi_out_analog_prepare()
3806 	mutex_lock(&codec->spdif_mutex);  in snd_hda_multi_out_analog_prepare()
3807 	spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);  in snd_hda_multi_out_analog_prepare()
3808 	if (mout->dig_out_nid && mout->share_spdif &&  in snd_hda_multi_out_analog_prepare()
3809 	    mout->dig_out_used != HDA_DIG_EXCLUSIVE) {  in snd_hda_multi_out_analog_prepare()
3811 		    snd_hda_is_supported_format(codec, mout->dig_out_nid,  in snd_hda_multi_out_analog_prepare()
3813 		    !(spdif->status & IEC958_AES0_NONAUDIO)) {  in snd_hda_multi_out_analog_prepare()
3814 			mout->dig_out_used = HDA_DIG_ANALOG_DUP;  in snd_hda_multi_out_analog_prepare()
3815 			setup_dig_out_stream(codec, mout->dig_out_nid,  in snd_hda_multi_out_analog_prepare()
3818 			mout->dig_out_used = 0;  in snd_hda_multi_out_analog_prepare()
3819 			cleanup_dig_out_stream(codec, mout->dig_out_nid);  in snd_hda_multi_out_analog_prepare()
3822 	mutex_unlock(&codec->spdif_mutex);  in snd_hda_multi_out_analog_prepare()
3825 	snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,  in snd_hda_multi_out_analog_prepare()
3826 				   0, format);  in snd_hda_multi_out_analog_prepare()
3827 	if (!mout->no_share_stream &&  in snd_hda_multi_out_analog_prepare()
3828 	    mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])  in snd_hda_multi_out_analog_prepare()
3830 		snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,  in snd_hda_multi_out_analog_prepare()
3831 					   0, format);  in snd_hda_multi_out_analog_prepare()
3833 	for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)  in snd_hda_multi_out_analog_prepare()
3834 		if (!mout->no_share_stream && mout->hp_out_nid[i])  in snd_hda_multi_out_analog_prepare()
3835 			snd_hda_codec_setup_stream(codec,  in snd_hda_multi_out_analog_prepare()
3836 						   mout->hp_out_nid[i],  in snd_hda_multi_out_analog_prepare()
3837 						   stream_tag, 0, format);  in snd_hda_multi_out_analog_prepare()
3840 	for (i = 1; i < mout->num_dacs; i++) {  in snd_hda_multi_out_analog_prepare()
3842 			snd_hda_codec_setup_stream(codec, nids[i], stream_tag,  in snd_hda_multi_out_analog_prepare()
3844 		else if (!mout->no_share_stream) /* copy front */  in snd_hda_multi_out_analog_prepare()
3845 			snd_hda_codec_setup_stream(codec, nids[i], stream_tag,  in snd_hda_multi_out_analog_prepare()
3846 						   0, format);  in snd_hda_multi_out_analog_prepare()
3850 	for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) {  in snd_hda_multi_out_analog_prepare()
3851 		int ch = 0;  in snd_hda_multi_out_analog_prepare()
3852 		if (!mout->extra_out_nid[i])  in snd_hda_multi_out_analog_prepare()
3856 		else if (!mout->no_share_stream)  in snd_hda_multi_out_analog_prepare()
3858 		snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i],  in snd_hda_multi_out_analog_prepare()
3862 	return 0;  in snd_hda_multi_out_analog_prepare()
3867  * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
3868  * @codec: the HDA codec
3871 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,  in snd_hda_multi_out_analog_cleanup()  argument
3874 	const hda_nid_t *nids = mout->dac_nids;  in snd_hda_multi_out_analog_cleanup()
3877 	for (i = 0; i < mout->num_dacs; i++)  in snd_hda_multi_out_analog_cleanup()
3878 		snd_hda_codec_cleanup_stream(codec, nids[i]);  in snd_hda_multi_out_analog_cleanup()
3879 	if (mout->hp_nid)  in snd_hda_multi_out_analog_cleanup()
3880 		snd_hda_codec_cleanup_stream(codec, mout->hp_nid);  in snd_hda_multi_out_analog_cleanup()
3881 	for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)  in snd_hda_multi_out_analog_cleanup()
3882 		if (mout->hp_out_nid[i])  in snd_hda_multi_out_analog_cleanup()
3883 			snd_hda_codec_cleanup_stream(codec,  in snd_hda_multi_out_analog_cleanup()
3884 						     mout->hp_out_nid[i]);  in snd_hda_multi_out_analog_cleanup()
3885 	for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)  in snd_hda_multi_out_analog_cleanup()
3886 		if (mout->extra_out_nid[i])  in snd_hda_multi_out_analog_cleanup()
3887 			snd_hda_codec_cleanup_stream(codec,  in snd_hda_multi_out_analog_cleanup()
3888 						     mout->extra_out_nid[i]);  in snd_hda_multi_out_analog_cleanup()
3889 	mutex_lock(&codec->spdif_mutex);  in snd_hda_multi_out_analog_cleanup()
3890 	if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {  in snd_hda_multi_out_analog_cleanup()
3891 		cleanup_dig_out_stream(codec, mout->dig_out_nid);  in snd_hda_multi_out_analog_cleanup()
3892 		mout->dig_out_used = 0;  in snd_hda_multi_out_analog_cleanup()
3894 	mutex_unlock(&codec->spdif_mutex);  in snd_hda_multi_out_analog_cleanup()
3895 	return 0;  in snd_hda_multi_out_analog_cleanup()
3900  * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
3901  * @codec: the HDA codec
3904  * Guess the suitable VREF pin bits to be set as the pin-control value.
3907 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)  in snd_hda_get_default_vref()  argument
3911 	oldval = snd_hda_codec_read(codec, pin, 0,  in snd_hda_get_default_vref()
3912 				    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);  in snd_hda_get_default_vref()
3913 	pincap = snd_hda_query_pin_caps(codec, pin);  in snd_hda_get_default_vref()
3929  * snd_hda_correct_pin_ctl - correct the pin ctl value for matching with the pin cap
3930  * @codec: the HDA codec
3934 unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,  in snd_hda_correct_pin_ctl()  argument
3946 		return 0;  in snd_hda_correct_pin_ctl()
3947 	cap = snd_hda_query_pin_caps(codec, pin);  in snd_hda_correct_pin_ctl()
3966 			for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {  in snd_hda_correct_pin_ctl()
3967 				if (vref == cap_lists[i][0] &&  in snd_hda_correct_pin_ctl()
3969 					if (i == ARRAY_SIZE(cap_lists) - 1)  in snd_hda_correct_pin_ctl()
3972 						vref = cap_lists[i + 1][0];  in snd_hda_correct_pin_ctl()
3985  * _snd_hda_set_pin_ctl - Helper to set pin ctl value
3986  * @codec: the HDA codec
3989  * @cached: access over codec pinctl cache or direct write
3997 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,  in _snd_hda_set_pin_ctl()  argument
4000 	val = snd_hda_correct_pin_ctl(codec, pin, val);  in _snd_hda_set_pin_ctl()
4001 	snd_hda_codec_set_pin_target(codec, pin, val);  in _snd_hda_set_pin_ctl()
4003 		return snd_hda_codec_write_cache(codec, pin, 0,  in _snd_hda_set_pin_ctl()
4006 		return snd_hda_codec_write(codec, pin, 0,  in _snd_hda_set_pin_ctl()
4012  * snd_hda_add_imux_item - Add an item to input_mux
4013  * @codec: the HDA codec
4021  * to type_idx when non-NULL pointer is given.
4023 int snd_hda_add_imux_item(struct hda_codec *codec,  in snd_hda_add_imux_item()  argument
4027 	int i, label_idx = 0;  in snd_hda_add_imux_item()
4028 	if (imux->num_items >= HDA_MAX_NUM_INPUTS) {  in snd_hda_add_imux_item()
4029 		codec_err(codec, "hda_codec: Too many imux items!\n");  in snd_hda_add_imux_item()
4030 		return -EINVAL;  in snd_hda_add_imux_item()
4032 	for (i = 0; i < imux->num_items; i++) {  in snd_hda_add_imux_item()
4033 		if (!strncmp(label, imux->items[i].label, strlen(label)))  in snd_hda_add_imux_item()
4038 	if (label_idx > 0)  in snd_hda_add_imux_item()
4039 		snprintf(imux->items[imux->num_items].label,  in snd_hda_add_imux_item()
4040 			 sizeof(imux->items[imux->num_items].label),  in snd_hda_add_imux_item()
4043 		strscpy(imux->items[imux->num_items].label, label,  in snd_hda_add_imux_item()
4044 			sizeof(imux->items[imux->num_items].label));  in snd_hda_add_imux_item()
4045 	imux->items[imux->num_items].index = index;  in snd_hda_add_imux_item()
4046 	imux->num_items++;  in snd_hda_add_imux_item()
4047 	return 0;  in snd_hda_add_imux_item()
4052  * snd_hda_bus_reset_codecs - Reset the bus
4053  * @bus: HD-audio bus
4057 	struct hda_codec *codec;  in snd_hda_bus_reset_codecs()  local
4059 	list_for_each_codec(codec, bus) {  in snd_hda_bus_reset_codecs()
4061 		if (current_work() != &codec->jackpoll_work.work)  in snd_hda_bus_reset_codecs()
4062 			cancel_delayed_work_sync(&codec->jackpoll_work);  in snd_hda_bus_reset_codecs()
4063 		if (hda_codec_is_power_on(codec)) {  in snd_hda_bus_reset_codecs()
4064 			hda_call_codec_suspend(codec);  in snd_hda_bus_reset_codecs()
4065 			hda_call_codec_resume(codec);  in snd_hda_bus_reset_codecs()
4071  * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4083 	for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)  in snd_print_pcm_bits()
4085 			j += scnprintf(buf + j, buflen - j,  " %d", bits[i]);  in snd_print_pcm_bits()
4087 	buf[j] = '\0'; /* necessary when j == 0 */  in snd_print_pcm_bits()
4091 MODULE_DESCRIPTION("HDA codec core");