2 * Universal Interface for Intel High Definition Audio Codec
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/slab.h>
26 #include <linux/mutex.h>
27 #include <linux/module.h>
28 #include <linux/async.h>
30 #include <linux/pm_runtime.h>
31 #include <sound/core.h>
32 #include "hda_codec.h"
33 #include <sound/asoundef.h>
34 #include <sound/tlv.h>
35 #include <sound/initval.h>
36 #include <sound/jack.h>
37 #include "hda_local.h"
40 #include <sound/hda_hwdep.h>
43 #define codec_in_pm(codec) atomic_read(&(codec)->core.in_pm)
44 #define hda_codec_is_power_on(codec) \
45 (!pm_runtime_suspended(hda_codec_dev(codec)))
47 #define codec_in_pm(codec) 0
48 #define hda_codec_is_power_on(codec) 1
51 #define codec_has_epss(codec) \
52 ((codec)->core.power_caps & AC_PWRST_EPSS)
53 #define codec_has_clkstop(codec) \
54 ((codec)->core.power_caps & AC_PWRST_CLKSTOP)
57 * snd_hda_get_jack_location - Give a location string of the jack
58 * @cfg: pin default config value
60 * Parse the pin default config value and returns the string of the
61 * jack location, e.g. "Rear", "Front", etc.
63 const char *snd_hda_get_jack_location(u32 cfg)
65 static char *bases[7] = {
66 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
68 static unsigned char specials_idx[] = {
73 static char *specials[] = {
74 "Rear Panel", "Drive Bar",
75 "Riser", "HDMI", "ATAPI",
76 "Mobile-In", "Mobile-Out"
79 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
81 return bases[cfg & 0x0f];
82 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
83 if (cfg == specials_idx[i])
88 EXPORT_SYMBOL_GPL(snd_hda_get_jack_location);
91 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
92 * @cfg: pin default config value
94 * Parse the pin default config value and returns the string of the
95 * jack connectivity, i.e. external or internal connection.
97 const char *snd_hda_get_jack_connectivity(u32 cfg)
99 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
101 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
103 EXPORT_SYMBOL_GPL(snd_hda_get_jack_connectivity);
106 * snd_hda_get_jack_type - Give a type string of the jack
107 * @cfg: pin default config value
109 * Parse the pin default config value and returns the string of the
110 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
112 const char *snd_hda_get_jack_type(u32 cfg)
114 static char *jack_types[16] = {
115 "Line Out", "Speaker", "HP Out", "CD",
116 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
117 "Line In", "Aux", "Mic", "Telephony",
118 "SPDIF In", "Digital In", "Reserved", "Other"
121 return jack_types[(cfg & AC_DEFCFG_DEVICE)
122 >> AC_DEFCFG_DEVICE_SHIFT];
124 EXPORT_SYMBOL_GPL(snd_hda_get_jack_type);
127 * Send and receive a verb - passed to exec_verb override for hdac_device
129 static int codec_exec_verb(struct hdac_device *dev, unsigned int cmd,
130 unsigned int flags, unsigned int *res)
132 struct hda_codec *codec = container_of(dev, struct hda_codec, core);
133 struct hda_bus *bus = codec->bus;
140 snd_hda_power_up_pm(codec);
141 mutex_lock(&bus->core.cmd_mutex);
142 if (flags & HDA_RW_NO_RESPONSE_FALLBACK)
143 bus->no_response_fallback = 1;
144 err = snd_hdac_bus_exec_verb_unlocked(&bus->core, codec->core.addr,
146 bus->no_response_fallback = 0;
147 mutex_unlock(&bus->core.cmd_mutex);
148 snd_hda_power_down_pm(codec);
149 if (!codec_in_pm(codec) && res && err < 0 && bus->rirb_error) {
150 if (bus->response_reset) {
152 "resetting BUS due to fatal communication error\n");
153 bus->ops.bus_reset(bus);
157 /* clear reset-flag when the communication gets recovered */
158 if (!err || codec_in_pm(codec))
159 bus->response_reset = 0;
164 * snd_hda_codec_read - send a command and get the response
165 * @codec: the HDA codec
166 * @nid: NID to send the command
167 * @flags: optional bit flags
168 * @verb: the verb to send
169 * @parm: the parameter for the verb
171 * Send a single command and read the corresponding response.
173 * Returns the obtained response value, or -1 for an error.
175 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
177 unsigned int verb, unsigned int parm)
179 unsigned int cmd = snd_hdac_make_cmd(&codec->core, nid, verb, parm);
181 if (snd_hdac_exec_verb(&codec->core, cmd, flags, &res))
185 EXPORT_SYMBOL_GPL(snd_hda_codec_read);
188 * snd_hda_codec_write - send a single command without waiting for response
189 * @codec: the HDA codec
190 * @nid: NID to send the command
191 * @flags: optional bit flags
192 * @verb: the verb to send
193 * @parm: the parameter for the verb
195 * Send a single command without waiting for response.
197 * Returns 0 if successful, or a negative error code.
199 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags,
200 unsigned int verb, unsigned int parm)
202 unsigned int cmd = snd_hdac_make_cmd(&codec->core, nid, verb, parm);
203 return snd_hdac_exec_verb(&codec->core, cmd, flags, NULL);
205 EXPORT_SYMBOL_GPL(snd_hda_codec_write);
208 * snd_hda_sequence_write - sequence writes
209 * @codec: the HDA codec
210 * @seq: VERB array to send
212 * Send the commands sequentially from the given array.
213 * The array must be terminated with NID=0.
215 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
217 for (; seq->nid; seq++)
218 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
220 EXPORT_SYMBOL_GPL(snd_hda_sequence_write);
222 /* connection list element */
223 struct hda_conn_list {
224 struct list_head list;
230 /* look up the cached results */
231 static struct hda_conn_list *
232 lookup_conn_list(struct hda_codec *codec, hda_nid_t nid)
234 struct hda_conn_list *p;
235 list_for_each_entry(p, &codec->conn_list, list) {
242 static int add_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
243 const hda_nid_t *list)
245 struct hda_conn_list *p;
247 p = kmalloc(sizeof(*p) + len * sizeof(hda_nid_t), GFP_KERNEL);
252 memcpy(p->conns, list, len * sizeof(hda_nid_t));
253 list_add(&p->list, &codec->conn_list);
257 static void remove_conn_list(struct hda_codec *codec)
259 while (!list_empty(&codec->conn_list)) {
260 struct hda_conn_list *p;
261 p = list_first_entry(&codec->conn_list, typeof(*p), list);
267 /* read the connection and add to the cache */
268 static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
271 hda_nid_t *result = list;
274 len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
275 if (len == -ENOSPC) {
276 len = snd_hda_get_num_raw_conns(codec, nid);
277 result = kmalloc(sizeof(hda_nid_t) * len, GFP_KERNEL);
280 len = snd_hda_get_raw_connections(codec, nid, result, len);
283 len = snd_hda_override_conn_list(codec, nid, len, result);
290 * snd_hda_get_conn_list - get connection list
291 * @codec: the HDA codec
293 * @listp: the pointer to store NID list
295 * Parses the connection list of the given widget and stores the pointer
296 * to the list of NIDs.
298 * Returns the number of connections, or a negative error code.
300 * Note that the returned pointer isn't protected against the list
301 * modification. If snd_hda_override_conn_list() might be called
302 * concurrently, protect with a mutex appropriately.
304 int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
305 const hda_nid_t **listp)
311 const struct hda_conn_list *p;
313 /* if the connection-list is already cached, read it */
314 p = lookup_conn_list(codec, nid);
320 if (snd_BUG_ON(added))
323 err = read_and_add_raw_conns(codec, nid);
329 EXPORT_SYMBOL_GPL(snd_hda_get_conn_list);
332 * snd_hda_get_connections - copy connection list
333 * @codec: the HDA codec
335 * @conn_list: connection list array; when NULL, checks only the size
336 * @max_conns: max. number of connections to store
338 * Parses the connection list of the given widget and stores the list
341 * Returns the number of connections, or a negative error code.
343 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
344 hda_nid_t *conn_list, int max_conns)
346 const hda_nid_t *list;
347 int len = snd_hda_get_conn_list(codec, nid, &list);
349 if (len > 0 && conn_list) {
350 if (len > max_conns) {
351 codec_err(codec, "Too many connections %d for NID 0x%x\n",
355 memcpy(conn_list, list, len * sizeof(hda_nid_t));
360 EXPORT_SYMBOL_GPL(snd_hda_get_connections);
363 * snd_hda_override_conn_list - add/modify the connection-list to cache
364 * @codec: the HDA codec
366 * @len: number of connection list entries
367 * @list: the list of connection entries
369 * Add or modify the given connection-list to the cache. If the corresponding
370 * cache already exists, invalidate it and append a new one.
372 * Returns zero or a negative error code.
374 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
375 const hda_nid_t *list)
377 struct hda_conn_list *p;
379 p = lookup_conn_list(codec, nid);
385 return add_conn_list(codec, nid, len, list);
387 EXPORT_SYMBOL_GPL(snd_hda_override_conn_list);
390 * snd_hda_get_conn_index - get the connection index of the given NID
391 * @codec: the HDA codec
392 * @mux: NID containing the list
393 * @nid: NID to select
394 * @recursive: 1 when searching NID recursively, otherwise 0
396 * Parses the connection list of the widget @mux and checks whether the
397 * widget @nid is present. If it is, return the connection index.
398 * Otherwise it returns -1.
400 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
401 hda_nid_t nid, int recursive)
403 const hda_nid_t *conn;
406 nums = snd_hda_get_conn_list(codec, mux, &conn);
407 for (i = 0; i < nums; i++)
412 if (recursive > 10) {
413 codec_dbg(codec, "too deep connection for 0x%x\n", nid);
417 for (i = 0; i < nums; i++) {
418 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
419 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
421 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
426 EXPORT_SYMBOL_GPL(snd_hda_get_conn_index);
429 /* return DEVLIST_LEN parameter of the given widget */
430 static unsigned int get_num_devices(struct hda_codec *codec, hda_nid_t nid)
432 unsigned int wcaps = get_wcaps(codec, nid);
435 if (!codec->dp_mst || !(wcaps & AC_WCAP_DIGITAL) ||
436 get_wcaps_type(wcaps) != AC_WID_PIN)
439 parm = snd_hda_param_read(codec, nid, AC_PAR_DEVLIST_LEN);
440 if (parm == -1 && codec->bus->rirb_error)
442 return parm & AC_DEV_LIST_LEN_MASK;
446 * snd_hda_get_devices - copy device list without cache
447 * @codec: the HDA codec
448 * @nid: NID of the pin to parse
449 * @dev_list: device list array
450 * @max_devices: max. number of devices to store
452 * Copy the device list. This info is dynamic and so not cached.
453 * Currently called only from hda_proc.c, so not exported.
455 int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
456 u8 *dev_list, int max_devices)
459 int i, dev_len, devices;
461 parm = get_num_devices(codec, nid);
462 if (!parm) /* not multi-stream capable */
466 dev_len = dev_len < max_devices ? dev_len : max_devices;
469 while (devices < dev_len) {
470 parm = snd_hda_codec_read(codec, nid, 0,
471 AC_VERB_GET_DEVICE_LIST, devices);
472 if (parm == -1 && codec->bus->rirb_error)
475 for (i = 0; i < 8; i++) {
476 dev_list[devices] = (u8)parm;
479 if (devices >= dev_len)
489 static void snd_hda_bus_free(struct hda_bus *bus)
493 if (bus->ops.private_free)
494 bus->ops.private_free(bus);
495 snd_hdac_bus_exit(&bus->core);
499 static int snd_hda_bus_dev_free(struct snd_device *device)
501 snd_hda_bus_free(device->device_data);
505 static int snd_hda_bus_dev_disconnect(struct snd_device *device)
507 struct hda_bus *bus = device->device_data;
512 /* hdac_bus_ops translations */
513 static int _hda_bus_command(struct hdac_bus *_bus, unsigned int cmd)
515 struct hda_bus *bus = container_of(_bus, struct hda_bus, core);
516 return bus->ops.command(bus, cmd);
519 static int _hda_bus_get_response(struct hdac_bus *_bus, unsigned int addr,
522 struct hda_bus *bus = container_of(_bus, struct hda_bus, core);
523 *res = bus->ops.get_response(bus, addr);
524 return bus->rirb_error ? -EIO : 0;
527 static const struct hdac_bus_ops bus_ops = {
528 .command = _hda_bus_command,
529 .get_response = _hda_bus_get_response,
533 * snd_hda_bus_new - create a HDA bus
534 * @card: the card entry
535 * @busp: the pointer to store the created bus instance
537 * Returns 0 if successful, or a negative error code.
539 int snd_hda_bus_new(struct snd_card *card,
540 struct hda_bus **busp)
544 static struct snd_device_ops dev_ops = {
545 .dev_disconnect = snd_hda_bus_dev_disconnect,
546 .dev_free = snd_hda_bus_dev_free,
552 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
556 err = snd_hdac_bus_init(&bus->core, card->dev, &bus_ops);
563 mutex_init(&bus->prepare_mutex);
565 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
567 snd_hda_bus_free(bus);
574 EXPORT_SYMBOL_GPL(snd_hda_bus_new);
577 * read widget caps for each widget and store in cache
579 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
584 codec->wcaps = kmalloc(codec->core.num_nodes * 4, GFP_KERNEL);
587 nid = codec->core.start_nid;
588 for (i = 0; i < codec->core.num_nodes; i++, nid++)
589 codec->wcaps[i] = snd_hdac_read_parm_uncached(&codec->core,
590 nid, AC_PAR_AUDIO_WIDGET_CAP);
594 /* read all pin default configurations and save codec->init_pins */
595 static int read_pin_defaults(struct hda_codec *codec)
599 for_each_hda_codec_node(nid, codec) {
600 struct hda_pincfg *pin;
601 unsigned int wcaps = get_wcaps(codec, nid);
602 unsigned int wid_type = get_wcaps_type(wcaps);
603 if (wid_type != AC_WID_PIN)
605 pin = snd_array_new(&codec->init_pins);
609 pin->cfg = snd_hda_codec_read(codec, nid, 0,
610 AC_VERB_GET_CONFIG_DEFAULT, 0);
611 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
612 AC_VERB_GET_PIN_WIDGET_CONTROL,
618 /* look up the given pin config list and return the item matching with NID */
619 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
620 struct snd_array *array,
624 for (i = 0; i < array->used; i++) {
625 struct hda_pincfg *pin = snd_array_elem(array, i);
632 /* set the current pin config value for the given NID.
633 * the value is cached, and read via snd_hda_codec_get_pincfg()
635 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
636 hda_nid_t nid, unsigned int cfg)
638 struct hda_pincfg *pin;
640 /* the check below may be invalid when pins are added by a fixup
641 * dynamically (e.g. via snd_hda_codec_update_widgets()), so disabled
645 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
649 pin = look_up_pincfg(codec, list, nid);
651 pin = snd_array_new(list);
661 * snd_hda_codec_set_pincfg - Override a pin default configuration
662 * @codec: the HDA codec
663 * @nid: NID to set the pin config
664 * @cfg: the pin default config value
666 * Override a pin default configuration value in the cache.
667 * This value can be read by snd_hda_codec_get_pincfg() in a higher
668 * priority than the real hardware value.
670 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
671 hda_nid_t nid, unsigned int cfg)
673 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
675 EXPORT_SYMBOL_GPL(snd_hda_codec_set_pincfg);
678 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
679 * @codec: the HDA codec
680 * @nid: NID to get the pin config
682 * Get the current pin config value of the given pin NID.
683 * If the pincfg value is cached or overridden via sysfs or driver,
684 * returns the cached value.
686 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
688 struct hda_pincfg *pin;
690 #ifdef CONFIG_SND_HDA_RECONFIG
692 unsigned int cfg = 0;
693 mutex_lock(&codec->user_mutex);
694 pin = look_up_pincfg(codec, &codec->user_pins, nid);
697 mutex_unlock(&codec->user_mutex);
702 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
705 pin = look_up_pincfg(codec, &codec->init_pins, nid);
710 EXPORT_SYMBOL_GPL(snd_hda_codec_get_pincfg);
713 * snd_hda_codec_set_pin_target - remember the current pinctl target value
714 * @codec: the HDA codec
716 * @val: assigned pinctl value
718 * This function stores the given value to a pinctl target value in the
719 * pincfg table. This isn't always as same as the actually written value
720 * but can be referred at any time via snd_hda_codec_get_pin_target().
722 int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
725 struct hda_pincfg *pin;
727 pin = look_up_pincfg(codec, &codec->init_pins, nid);
733 EXPORT_SYMBOL_GPL(snd_hda_codec_set_pin_target);
736 * snd_hda_codec_get_pin_target - return the current pinctl target value
737 * @codec: the HDA codec
740 int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
742 struct hda_pincfg *pin;
744 pin = look_up_pincfg(codec, &codec->init_pins, nid);
749 EXPORT_SYMBOL_GPL(snd_hda_codec_get_pin_target);
752 * snd_hda_shutup_pins - Shut up all pins
753 * @codec: the HDA codec
755 * Clear all pin controls to shup up before suspend for avoiding click noise.
756 * The controls aren't cached so that they can be resumed properly.
758 void snd_hda_shutup_pins(struct hda_codec *codec)
761 /* don't shut up pins when unloading the driver; otherwise it breaks
762 * the default pin setup at the next load of the driver
764 if (codec->bus->shutdown)
766 for (i = 0; i < codec->init_pins.used; i++) {
767 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
768 /* use read here for syncing after issuing each verb */
769 snd_hda_codec_read(codec, pin->nid, 0,
770 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
772 codec->pins_shutup = 1;
774 EXPORT_SYMBOL_GPL(snd_hda_shutup_pins);
777 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
778 static void restore_shutup_pins(struct hda_codec *codec)
781 if (!codec->pins_shutup)
783 if (codec->bus->shutdown)
785 for (i = 0; i < codec->init_pins.used; i++) {
786 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
787 snd_hda_codec_write(codec, pin->nid, 0,
788 AC_VERB_SET_PIN_WIDGET_CONTROL,
791 codec->pins_shutup = 0;
795 static void hda_jackpoll_work(struct work_struct *work)
797 struct hda_codec *codec =
798 container_of(work, struct hda_codec, jackpoll_work.work);
800 snd_hda_jack_set_dirty_all(codec);
801 snd_hda_jack_poll_all(codec);
803 if (!codec->jackpoll_interval)
806 schedule_delayed_work(&codec->jackpoll_work,
807 codec->jackpoll_interval);
810 /* release all pincfg lists */
811 static void free_init_pincfgs(struct hda_codec *codec)
813 snd_array_free(&codec->driver_pins);
814 #ifdef CONFIG_SND_HDA_RECONFIG
815 snd_array_free(&codec->user_pins);
817 snd_array_free(&codec->init_pins);
821 * audio-converter setup caches
823 struct hda_cvt_setup {
828 unsigned char active; /* cvt is currently used */
829 unsigned char dirty; /* setups should be cleared */
832 /* get or create a cache entry for the given audio converter NID */
833 static struct hda_cvt_setup *
834 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
836 struct hda_cvt_setup *p;
839 for (i = 0; i < codec->cvt_setups.used; i++) {
840 p = snd_array_elem(&codec->cvt_setups, i);
844 p = snd_array_new(&codec->cvt_setups);
853 static void release_pcm(struct kref *kref)
855 struct hda_pcm *pcm = container_of(kref, struct hda_pcm, kref);
858 snd_device_free(pcm->codec->card, pcm->pcm);
859 clear_bit(pcm->device, pcm->codec->bus->pcm_dev_bits);
864 void snd_hda_codec_pcm_put(struct hda_pcm *pcm)
866 kref_put(&pcm->kref, release_pcm);
868 EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_put);
870 struct hda_pcm *snd_hda_codec_pcm_new(struct hda_codec *codec,
871 const char *fmt, ...)
877 pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
882 kref_init(&pcm->kref);
883 pcm->name = kvasprintf(GFP_KERNEL, fmt, args);
889 list_add_tail(&pcm->list, &codec->pcm_list_head);
892 EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_new);
897 static void codec_release_pcms(struct hda_codec *codec)
899 struct hda_pcm *pcm, *n;
901 list_for_each_entry_safe(pcm, n, &codec->pcm_list_head, list) {
902 list_del_init(&pcm->list);
904 snd_device_disconnect(codec->card, pcm->pcm);
905 snd_hda_codec_pcm_put(pcm);
909 void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec)
911 if (codec->registered) {
912 /* pm_runtime_put() is called in snd_hdac_device_exit() */
913 pm_runtime_get_noresume(hda_codec_dev(codec));
914 pm_runtime_disable(hda_codec_dev(codec));
915 codec->registered = 0;
918 cancel_delayed_work_sync(&codec->jackpoll_work);
919 if (!codec->in_freeing)
920 snd_hda_ctls_clear(codec);
921 codec_release_pcms(codec);
922 snd_hda_detach_beep_device(codec);
923 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
924 snd_hda_jack_tbl_clear(codec);
925 codec->proc_widget_hook = NULL;
928 /* free only driver_pins so that init_pins + user_pins are restored */
929 snd_array_free(&codec->driver_pins);
930 snd_array_free(&codec->cvt_setups);
931 snd_array_free(&codec->spdif_out);
932 snd_array_free(&codec->verbs);
933 codec->preset = NULL;
934 codec->slave_dig_outs = NULL;
935 codec->spdif_status_reset = 0;
936 snd_array_free(&codec->mixers);
937 snd_array_free(&codec->nids);
938 remove_conn_list(codec);
939 snd_hdac_regmap_exit(&codec->core);
942 static unsigned int hda_set_power_state(struct hda_codec *codec,
943 unsigned int power_state);
945 /* also called from hda_bind.c */
946 void snd_hda_codec_register(struct hda_codec *codec)
948 if (codec->registered)
950 if (device_is_registered(hda_codec_dev(codec))) {
951 snd_hda_register_beep_device(codec);
952 pm_runtime_enable(hda_codec_dev(codec));
953 /* it was powered up in snd_hda_codec_new(), now all done */
954 snd_hda_power_down(codec);
955 codec->registered = 1;
959 static int snd_hda_codec_dev_register(struct snd_device *device)
961 snd_hda_codec_register(device->device_data);
965 static int snd_hda_codec_dev_disconnect(struct snd_device *device)
967 struct hda_codec *codec = device->device_data;
969 snd_hda_detach_beep_device(codec);
973 static int snd_hda_codec_dev_free(struct snd_device *device)
975 struct hda_codec *codec = device->device_data;
977 codec->in_freeing = 1;
978 snd_hdac_device_unregister(&codec->core);
979 put_device(hda_codec_dev(codec));
983 static void snd_hda_codec_dev_release(struct device *dev)
985 struct hda_codec *codec = dev_to_hda_codec(dev);
987 free_init_pincfgs(codec);
988 snd_hdac_device_exit(&codec->core);
989 snd_hda_sysfs_clear(codec);
990 kfree(codec->modelname);
996 * snd_hda_codec_new - create a HDA codec
997 * @bus: the bus to assign
998 * @codec_addr: the codec address
999 * @codecp: the pointer to store the generated codec
1001 * Returns 0 if successful, or a negative error code.
1003 int snd_hda_codec_new(struct hda_bus *bus, struct snd_card *card,
1004 unsigned int codec_addr, struct hda_codec **codecp)
1006 struct hda_codec *codec;
1010 static struct snd_device_ops dev_ops = {
1011 .dev_register = snd_hda_codec_dev_register,
1012 .dev_disconnect = snd_hda_codec_dev_disconnect,
1013 .dev_free = snd_hda_codec_dev_free,
1016 if (snd_BUG_ON(!bus))
1018 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1021 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1025 sprintf(component, "hdaudioC%dD%d", card->number, codec_addr);
1026 err = snd_hdac_device_init(&codec->core, &bus->core, component,
1033 codec->core.dev.release = snd_hda_codec_dev_release;
1034 codec->core.type = HDA_DEV_LEGACY;
1035 codec->core.exec_verb = codec_exec_verb;
1039 codec->addr = codec_addr;
1040 mutex_init(&codec->spdif_mutex);
1041 mutex_init(&codec->control_mutex);
1042 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1043 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1044 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1045 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1046 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1047 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1048 snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
1049 snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
1050 INIT_LIST_HEAD(&codec->conn_list);
1051 INIT_LIST_HEAD(&codec->pcm_list_head);
1053 INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
1054 codec->depop_delay = -1;
1055 codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
1058 codec->power_jiffies = jiffies;
1061 snd_hda_sysfs_init(codec);
1063 if (codec->bus->modelname) {
1064 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1065 if (!codec->modelname) {
1071 fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
1072 err = read_widget_caps(codec, fg);
1075 err = read_pin_defaults(codec);
1079 /* power-up all before initialization */
1080 hda_set_power_state(codec, AC_PWRST_D0);
1082 snd_hda_codec_proc_new(codec);
1084 snd_hda_create_hwdep(codec);
1086 sprintf(component, "HDA:%08x,%08x,%08x", codec->core.vendor_id,
1087 codec->core.subsystem_id, codec->core.revision_id);
1088 snd_component_add(card, component);
1090 err = snd_device_new(card, SNDRV_DEV_CODEC, codec, &dev_ops);
1099 put_device(hda_codec_dev(codec));
1102 EXPORT_SYMBOL_GPL(snd_hda_codec_new);
1105 * snd_hda_codec_update_widgets - Refresh widget caps and pin defaults
1106 * @codec: the HDA codec
1108 * Forcibly refresh the all widget caps and the init pin configurations of
1111 int snd_hda_codec_update_widgets(struct hda_codec *codec)
1116 err = snd_hdac_refresh_widgets(&codec->core);
1120 /* Assume the function group node does not change,
1121 * only the widget nodes may change.
1123 kfree(codec->wcaps);
1124 fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
1125 err = read_widget_caps(codec, fg);
1129 snd_array_free(&codec->init_pins);
1130 err = read_pin_defaults(codec);
1134 EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets);
1136 /* update the stream-id if changed */
1137 static void update_pcm_stream_id(struct hda_codec *codec,
1138 struct hda_cvt_setup *p, hda_nid_t nid,
1139 u32 stream_tag, int channel_id)
1141 unsigned int oldval, newval;
1143 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1144 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1145 newval = (stream_tag << 4) | channel_id;
1146 if (oldval != newval)
1147 snd_hda_codec_write(codec, nid, 0,
1148 AC_VERB_SET_CHANNEL_STREAMID,
1150 p->stream_tag = stream_tag;
1151 p->channel_id = channel_id;
1155 /* update the format-id if changed */
1156 static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1157 hda_nid_t nid, int format)
1159 unsigned int oldval;
1161 if (p->format_id != format) {
1162 oldval = snd_hda_codec_read(codec, nid, 0,
1163 AC_VERB_GET_STREAM_FORMAT, 0);
1164 if (oldval != format) {
1166 snd_hda_codec_write(codec, nid, 0,
1167 AC_VERB_SET_STREAM_FORMAT,
1170 p->format_id = format;
1175 * snd_hda_codec_setup_stream - set up the codec for streaming
1176 * @codec: the CODEC to set up
1177 * @nid: the NID to set up
1178 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1179 * @channel_id: channel id to pass, zero based.
1180 * @format: stream format.
1182 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1184 int channel_id, int format)
1186 struct hda_codec *c;
1187 struct hda_cvt_setup *p;
1195 "hda_codec_setup_stream: NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1196 nid, stream_tag, channel_id, format);
1197 p = get_hda_cvt_setup(codec, nid);
1201 if (codec->patch_ops.stream_pm)
1202 codec->patch_ops.stream_pm(codec, nid, true);
1203 if (codec->pcm_format_first)
1204 update_pcm_format(codec, p, nid, format);
1205 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1206 if (!codec->pcm_format_first)
1207 update_pcm_format(codec, p, nid, format);
1212 /* make other inactive cvts with the same stream-tag dirty */
1213 type = get_wcaps_type(get_wcaps(codec, nid));
1214 list_for_each_codec(c, codec->bus) {
1215 for (i = 0; i < c->cvt_setups.used; i++) {
1216 p = snd_array_elem(&c->cvt_setups, i);
1217 if (!p->active && p->stream_tag == stream_tag &&
1218 get_wcaps_type(get_wcaps(c, p->nid)) == type)
1223 EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream);
1225 static void really_cleanup_stream(struct hda_codec *codec,
1226 struct hda_cvt_setup *q);
1229 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1230 * @codec: the CODEC to clean up
1231 * @nid: the NID to clean up
1232 * @do_now: really clean up the stream instead of clearing the active flag
1234 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1237 struct hda_cvt_setup *p;
1242 if (codec->no_sticky_stream)
1245 codec_dbg(codec, "hda_codec_cleanup_stream: NID=0x%x\n", nid);
1246 p = get_hda_cvt_setup(codec, nid);
1248 /* here we just clear the active flag when do_now isn't set;
1249 * actual clean-ups will be done later in
1250 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1253 really_cleanup_stream(codec, p);
1258 EXPORT_SYMBOL_GPL(__snd_hda_codec_cleanup_stream);
1260 static void really_cleanup_stream(struct hda_codec *codec,
1261 struct hda_cvt_setup *q)
1263 hda_nid_t nid = q->nid;
1264 if (q->stream_tag || q->channel_id)
1265 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1267 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1269 memset(q, 0, sizeof(*q));
1271 if (codec->patch_ops.stream_pm)
1272 codec->patch_ops.stream_pm(codec, nid, false);
1275 /* clean up the all conflicting obsolete streams */
1276 static void purify_inactive_streams(struct hda_codec *codec)
1278 struct hda_codec *c;
1281 list_for_each_codec(c, codec->bus) {
1282 for (i = 0; i < c->cvt_setups.used; i++) {
1283 struct hda_cvt_setup *p;
1284 p = snd_array_elem(&c->cvt_setups, i);
1286 really_cleanup_stream(c, p);
1292 /* clean up all streams; called from suspend */
1293 static void hda_cleanup_all_streams(struct hda_codec *codec)
1297 for (i = 0; i < codec->cvt_setups.used; i++) {
1298 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1300 really_cleanup_stream(codec, p);
1306 * amp access functions
1310 * query_amp_caps - query AMP capabilities
1311 * @codec: the HD-auio codec
1312 * @nid: the NID to query
1313 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1315 * Query AMP capabilities for the given widget and direction.
1316 * Returns the obtained capability bits.
1318 * When cap bits have been already read, this doesn't read again but
1319 * returns the cached value.
1321 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1323 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1324 nid = codec->core.afg;
1325 return snd_hda_param_read(codec, nid,
1326 direction == HDA_OUTPUT ?
1327 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1329 EXPORT_SYMBOL_GPL(query_amp_caps);
1332 * snd_hda_check_amp_caps - query AMP capabilities
1333 * @codec: the HD-audio codec
1334 * @nid: the NID to query
1335 * @dir: either #HDA_INPUT or #HDA_OUTPUT
1336 * @bits: bit mask to check the result
1338 * Check whether the widget has the given amp capability for the direction.
1340 bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
1341 int dir, unsigned int bits)
1345 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
1346 if (query_amp_caps(codec, nid, dir) & bits)
1350 EXPORT_SYMBOL_GPL(snd_hda_check_amp_caps);
1353 * snd_hda_override_amp_caps - Override the AMP capabilities
1354 * @codec: the CODEC to clean up
1355 * @nid: the NID to clean up
1356 * @dir: either #HDA_INPUT or #HDA_OUTPUT
1357 * @caps: the capability bits to set
1359 * Override the cached AMP caps bits value by the given one.
1360 * This function is useful if the driver needs to adjust the AMP ranges,
1361 * e.g. limit to 0dB, etc.
1363 * Returns zero if successful or a negative error code.
1365 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1370 snd_hda_override_wcaps(codec, nid,
1371 get_wcaps(codec, nid) | AC_WCAP_AMP_OVRD);
1372 parm = dir == HDA_OUTPUT ? AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP;
1373 return snd_hdac_override_parm(&codec->core, nid, parm, caps);
1375 EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
1378 * snd_hda_codec_amp_stereo - update the AMP stereo values
1379 * @codec: HD-audio codec
1380 * @nid: NID to read the AMP value
1381 * @direction: #HDA_INPUT or #HDA_OUTPUT
1382 * @idx: the index value (only for input direction)
1383 * @mask: bit mask to set
1384 * @val: the bits value to set
1386 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1387 * stereo widget with the same mask and value.
1389 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1390 int direction, int idx, int mask, int val)
1394 if (snd_BUG_ON(mask & ~0xff))
1396 for (ch = 0; ch < 2; ch++)
1397 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1401 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
1404 * snd_hda_codec_amp_init - initialize the AMP value
1405 * @codec: the HDA codec
1406 * @nid: NID to read the AMP value
1407 * @ch: channel (left=0 or right=1)
1408 * @dir: #HDA_INPUT or #HDA_OUTPUT
1409 * @idx: the index value (only for input direction)
1410 * @mask: bit mask to set
1411 * @val: the bits value to set
1413 * Works like snd_hda_codec_amp_update() but it writes the value only at
1414 * the first access. If the amp was already initialized / updated beforehand,
1415 * this does nothing.
1417 int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
1418 int dir, int idx, int mask, int val)
1422 if (!codec->core.regmap)
1424 regcache_cache_only(codec->core.regmap, true);
1425 orig = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1426 regcache_cache_only(codec->core.regmap, false);
1429 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx, mask, val);
1431 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init);
1434 * snd_hda_codec_amp_init_stereo - initialize the stereo AMP value
1435 * @codec: the HDA codec
1436 * @nid: NID to read the AMP value
1437 * @dir: #HDA_INPUT or #HDA_OUTPUT
1438 * @idx: the index value (only for input direction)
1439 * @mask: bit mask to set
1440 * @val: the bits value to set
1442 * Call snd_hda_codec_amp_init() for both stereo channels.
1444 int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
1445 int dir, int idx, int mask, int val)
1449 if (snd_BUG_ON(mask & ~0xff))
1451 for (ch = 0; ch < 2; ch++)
1452 ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
1456 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo);
1458 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1461 u32 caps = query_amp_caps(codec, nid, dir);
1463 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1470 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1471 * @kcontrol: referred ctl element
1472 * @uinfo: pointer to get/store the data
1474 * The control element is supposed to have the private_value field
1475 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1477 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1478 struct snd_ctl_elem_info *uinfo)
1480 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1481 u16 nid = get_amp_nid(kcontrol);
1482 u8 chs = get_amp_channels(kcontrol);
1483 int dir = get_amp_direction(kcontrol);
1484 unsigned int ofs = get_amp_offset(kcontrol);
1486 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1487 uinfo->count = chs == 3 ? 2 : 1;
1488 uinfo->value.integer.min = 0;
1489 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1490 if (!uinfo->value.integer.max) {
1492 "num_steps = 0 for NID=0x%x (ctl = %s)\n",
1493 nid, kcontrol->id.name);
1498 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
1501 static inline unsigned int
1502 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1503 int ch, int dir, int idx, unsigned int ofs)
1506 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1507 val &= HDA_AMP_VOLMASK;
1516 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1517 int ch, int dir, int idx, unsigned int ofs,
1520 unsigned int maxval;
1524 /* ofs = 0: raw max value */
1525 maxval = get_amp_max_value(codec, nid, dir, 0);
1528 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1529 HDA_AMP_VOLMASK, val);
1533 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1534 * @kcontrol: ctl element
1535 * @ucontrol: pointer to get/store the data
1537 * The control element is supposed to have the private_value field
1538 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1540 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1541 struct snd_ctl_elem_value *ucontrol)
1543 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1544 hda_nid_t nid = get_amp_nid(kcontrol);
1545 int chs = get_amp_channels(kcontrol);
1546 int dir = get_amp_direction(kcontrol);
1547 int idx = get_amp_index(kcontrol);
1548 unsigned int ofs = get_amp_offset(kcontrol);
1549 long *valp = ucontrol->value.integer.value;
1552 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1554 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1557 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
1560 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1561 * @kcontrol: ctl element
1562 * @ucontrol: pointer to get/store the data
1564 * The control element is supposed to have the private_value field
1565 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1567 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1568 struct snd_ctl_elem_value *ucontrol)
1570 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1571 hda_nid_t nid = get_amp_nid(kcontrol);
1572 int chs = get_amp_channels(kcontrol);
1573 int dir = get_amp_direction(kcontrol);
1574 int idx = get_amp_index(kcontrol);
1575 unsigned int ofs = get_amp_offset(kcontrol);
1576 long *valp = ucontrol->value.integer.value;
1580 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1584 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1587 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
1590 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
1591 * @kcontrol: ctl element
1592 * @op_flag: operation flag
1593 * @size: byte size of input TLV
1596 * The control element is supposed to have the private_value field
1597 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1599 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1600 unsigned int size, unsigned int __user *_tlv)
1602 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1603 hda_nid_t nid = get_amp_nid(kcontrol);
1604 int dir = get_amp_direction(kcontrol);
1605 unsigned int ofs = get_amp_offset(kcontrol);
1606 bool min_mute = get_amp_min_mute(kcontrol);
1607 u32 caps, val1, val2;
1609 if (size < 4 * sizeof(unsigned int))
1611 caps = query_amp_caps(codec, nid, dir);
1612 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1613 val2 = (val2 + 1) * 25;
1614 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1616 val1 = ((int)val1) * ((int)val2);
1617 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
1618 val2 |= TLV_DB_SCALE_MUTE;
1619 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1621 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1623 if (put_user(val1, _tlv + 2))
1625 if (put_user(val2, _tlv + 3))
1629 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
1632 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1633 * @codec: HD-audio codec
1634 * @nid: NID of a reference widget
1635 * @dir: #HDA_INPUT or #HDA_OUTPUT
1636 * @tlv: TLV data to be stored, at least 4 elements
1638 * Set (static) TLV data for a virtual master volume using the AMP caps
1639 * obtained from the reference NID.
1640 * The volume range is recalculated as if the max volume is 0dB.
1642 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1648 caps = query_amp_caps(codec, nid, dir);
1649 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1650 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1651 step = (step + 1) * 25;
1652 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1653 tlv[1] = 2 * sizeof(unsigned int);
1654 tlv[2] = -nums * step;
1657 EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
1659 /* find a mixer control element with the given name */
1660 static struct snd_kcontrol *
1661 find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
1663 struct snd_ctl_elem_id id;
1664 memset(&id, 0, sizeof(id));
1665 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1668 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1670 strcpy(id.name, name);
1671 return snd_ctl_find_id(codec->card, &id);
1675 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1676 * @codec: HD-audio codec
1677 * @name: ctl id name string
1679 * Get the control element with the given id string and IFACE_MIXER.
1681 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1684 return find_mixer_ctl(codec, name, 0, 0);
1686 EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
1688 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
1692 /* 16 ctlrs should be large enough */
1693 for (i = 0, idx = start_idx; i < 16; i++, idx++) {
1694 if (!find_mixer_ctl(codec, name, 0, idx))
1701 * snd_hda_ctl_add - Add a control element and assign to the codec
1702 * @codec: HD-audio codec
1703 * @nid: corresponding NID (optional)
1704 * @kctl: the control element to assign
1706 * Add the given control element to an array inside the codec instance.
1707 * All control elements belonging to a codec are supposed to be added
1708 * by this function so that a proper clean-up works at the free or
1709 * reconfiguration time.
1711 * If non-zero @nid is passed, the NID is assigned to the control element.
1712 * The assignment is shown in the codec proc file.
1714 * snd_hda_ctl_add() checks the control subdev id field whether
1715 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
1716 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
1717 * specifies if kctl->private_value is a HDA amplifier value.
1719 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
1720 struct snd_kcontrol *kctl)
1723 unsigned short flags = 0;
1724 struct hda_nid_item *item;
1726 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
1727 flags |= HDA_NID_ITEM_AMP;
1729 nid = get_amp_nid_(kctl->private_value);
1731 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
1732 nid = kctl->id.subdevice & 0xffff;
1733 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
1734 kctl->id.subdevice = 0;
1735 err = snd_ctl_add(codec->card, kctl);
1738 item = snd_array_new(&codec->mixers);
1743 item->flags = flags;
1746 EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
1749 * snd_hda_add_nid - Assign a NID to a control element
1750 * @codec: HD-audio codec
1751 * @nid: corresponding NID (optional)
1752 * @kctl: the control element to assign
1753 * @index: index to kctl
1755 * Add the given control element to an array inside the codec instance.
1756 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
1757 * NID:KCTL mapping - for example "Capture Source" selector.
1759 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
1760 unsigned int index, hda_nid_t nid)
1762 struct hda_nid_item *item;
1765 item = snd_array_new(&codec->nids);
1769 item->index = index;
1773 codec_err(codec, "no NID for mapping control %s:%d:%d\n",
1774 kctl->id.name, kctl->id.index, index);
1777 EXPORT_SYMBOL_GPL(snd_hda_add_nid);
1780 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
1781 * @codec: HD-audio codec
1783 void snd_hda_ctls_clear(struct hda_codec *codec)
1786 struct hda_nid_item *items = codec->mixers.list;
1787 for (i = 0; i < codec->mixers.used; i++)
1788 snd_ctl_remove(codec->card, items[i].kctl);
1789 snd_array_free(&codec->mixers);
1790 snd_array_free(&codec->nids);
1794 * snd_hda_lock_devices - pseudo device locking
1797 * toggle card->shutdown to allow/disallow the device access (as a hack)
1799 int snd_hda_lock_devices(struct hda_bus *bus)
1801 struct snd_card *card = bus->card;
1802 struct hda_codec *codec;
1804 spin_lock(&card->files_lock);
1808 if (!list_empty(&card->ctl_files))
1811 list_for_each_codec(codec, bus) {
1812 struct hda_pcm *cpcm;
1813 list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
1816 if (cpcm->pcm->streams[0].substream_opened ||
1817 cpcm->pcm->streams[1].substream_opened)
1821 spin_unlock(&card->files_lock);
1827 spin_unlock(&card->files_lock);
1830 EXPORT_SYMBOL_GPL(snd_hda_lock_devices);
1833 * snd_hda_unlock_devices - pseudo device unlocking
1836 void snd_hda_unlock_devices(struct hda_bus *bus)
1838 struct snd_card *card = bus->card;
1840 spin_lock(&card->files_lock);
1842 spin_unlock(&card->files_lock);
1844 EXPORT_SYMBOL_GPL(snd_hda_unlock_devices);
1847 * snd_hda_codec_reset - Clear all objects assigned to the codec
1848 * @codec: HD-audio codec
1850 * This frees the all PCM and control elements assigned to the codec, and
1851 * clears the caches and restores the pin default configurations.
1853 * When a device is being used, it returns -EBSY. If successfully freed,
1856 int snd_hda_codec_reset(struct hda_codec *codec)
1858 struct hda_bus *bus = codec->bus;
1860 if (snd_hda_lock_devices(bus) < 0)
1863 /* OK, let it free */
1864 snd_hdac_device_unregister(&codec->core);
1866 /* allow device access again */
1867 snd_hda_unlock_devices(bus);
1871 typedef int (*map_slave_func_t)(struct hda_codec *, void *, struct snd_kcontrol *);
1873 /* apply the function to all matching slave ctls in the mixer list */
1874 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
1875 const char *suffix, map_slave_func_t func, void *data)
1877 struct hda_nid_item *items;
1878 const char * const *s;
1881 items = codec->mixers.list;
1882 for (i = 0; i < codec->mixers.used; i++) {
1883 struct snd_kcontrol *sctl = items[i].kctl;
1884 if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
1886 for (s = slaves; *s; s++) {
1887 char tmpname[sizeof(sctl->id.name)];
1888 const char *name = *s;
1890 snprintf(tmpname, sizeof(tmpname), "%s %s",
1894 if (!strcmp(sctl->id.name, name)) {
1895 err = func(codec, data, sctl);
1905 static int check_slave_present(struct hda_codec *codec,
1906 void *data, struct snd_kcontrol *sctl)
1911 /* guess the value corresponding to 0dB */
1912 static int get_kctl_0dB_offset(struct hda_codec *codec,
1913 struct snd_kcontrol *kctl, int *step_to_check)
1916 const int *tlv = NULL;
1919 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1920 /* FIXME: set_fs() hack for obtaining user-space TLV data */
1921 mm_segment_t fs = get_fs();
1923 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
1926 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
1928 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE) {
1930 step &= ~TLV_DB_SCALE_MUTE;
1933 if (*step_to_check && *step_to_check != step) {
1934 codec_err(codec, "Mismatching dB step for vmaster slave (%d!=%d)\n",
1935 - *step_to_check, step);
1938 *step_to_check = step;
1939 val = -tlv[2] / step;
1944 /* call kctl->put with the given value(s) */
1945 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
1947 struct snd_ctl_elem_value *ucontrol;
1948 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
1951 ucontrol->value.integer.value[0] = val;
1952 ucontrol->value.integer.value[1] = val;
1953 kctl->put(kctl, ucontrol);
1958 /* initialize the slave volume with 0dB */
1959 static int init_slave_0dB(struct hda_codec *codec,
1960 void *data, struct snd_kcontrol *slave)
1962 int offset = get_kctl_0dB_offset(codec, slave, data);
1964 put_kctl_with_value(slave, offset);
1968 /* unmute the slave */
1969 static int init_slave_unmute(struct hda_codec *codec,
1970 void *data, struct snd_kcontrol *slave)
1972 return put_kctl_with_value(slave, 1);
1975 static int add_slave(struct hda_codec *codec,
1976 void *data, struct snd_kcontrol *slave)
1978 return snd_ctl_add_slave(data, slave);
1982 * __snd_hda_add_vmaster - create a virtual master control and add slaves
1983 * @codec: HD-audio codec
1984 * @name: vmaster control name
1985 * @tlv: TLV data (optional)
1986 * @slaves: slave control names (optional)
1987 * @suffix: suffix string to each slave name (optional)
1988 * @init_slave_vol: initialize slaves to unmute/0dB
1989 * @ctl_ret: store the vmaster kcontrol in return
1991 * Create a virtual master control with the given name. The TLV data
1992 * must be either NULL or a valid data.
1994 * @slaves is a NULL-terminated array of strings, each of which is a
1995 * slave control name. All controls with these names are assigned to
1996 * the new virtual master control.
1998 * This function returns zero if successful or a negative error code.
2000 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2001 unsigned int *tlv, const char * const *slaves,
2002 const char *suffix, bool init_slave_vol,
2003 struct snd_kcontrol **ctl_ret)
2005 struct snd_kcontrol *kctl;
2011 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2013 codec_dbg(codec, "No slave found for %s\n", name);
2016 kctl = snd_ctl_make_virtual_master(name, tlv);
2019 err = snd_hda_ctl_add(codec, 0, kctl);
2023 err = map_slaves(codec, slaves, suffix, add_slave, kctl);
2027 /* init with master mute & zero volume */
2028 put_kctl_with_value(kctl, 0);
2029 if (init_slave_vol) {
2031 map_slaves(codec, slaves, suffix,
2032 tlv ? init_slave_0dB : init_slave_unmute, &step);
2039 EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster);
2042 * mute-LED control using vmaster
2044 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2045 struct snd_ctl_elem_info *uinfo)
2047 static const char * const texts[] = {
2048 "On", "Off", "Follow Master"
2051 return snd_ctl_enum_info(uinfo, 1, 3, texts);
2054 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2055 struct snd_ctl_elem_value *ucontrol)
2057 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2058 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2062 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2063 struct snd_ctl_elem_value *ucontrol)
2065 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2066 unsigned int old_mode = hook->mute_mode;
2068 hook->mute_mode = ucontrol->value.enumerated.item[0];
2069 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2070 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2071 if (old_mode == hook->mute_mode)
2073 snd_hda_sync_vmaster_hook(hook);
2077 static struct snd_kcontrol_new vmaster_mute_mode = {
2078 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2079 .name = "Mute-LED Mode",
2080 .info = vmaster_mute_mode_info,
2081 .get = vmaster_mute_mode_get,
2082 .put = vmaster_mute_mode_put,
2086 * snd_hda_add_vmaster_hook - Add a vmaster hook for mute-LED
2087 * @codec: the HDA codec
2088 * @hook: the vmaster hook object
2089 * @expose_enum_ctl: flag to create an enum ctl
2091 * Add a mute-LED hook with the given vmaster switch kctl.
2092 * When @expose_enum_ctl is set, "Mute-LED Mode" control is automatically
2093 * created and associated with the given hook.
2095 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2096 struct hda_vmaster_mute_hook *hook,
2097 bool expose_enum_ctl)
2099 struct snd_kcontrol *kctl;
2101 if (!hook->hook || !hook->sw_kctl)
2103 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2104 hook->codec = codec;
2105 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2106 if (!expose_enum_ctl)
2108 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2111 return snd_hda_ctl_add(codec, 0, kctl);
2113 EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook);
2116 * snd_hda_sync_vmaster_hook - Sync vmaster hook
2117 * @hook: the vmaster hook
2119 * Call the hook with the current value for synchronization.
2120 * Should be called in init callback.
2122 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2124 if (!hook->hook || !hook->codec)
2126 /* don't call vmaster hook in the destructor since it might have
2127 * been already destroyed
2129 if (hook->codec->bus->shutdown)
2131 switch (hook->mute_mode) {
2132 case HDA_VMUTE_FOLLOW_MASTER:
2133 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2136 hook->hook(hook->codec, hook->mute_mode);
2140 EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook);
2144 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2145 * @kcontrol: referred ctl element
2146 * @uinfo: pointer to get/store the data
2148 * The control element is supposed to have the private_value field
2149 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2151 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2152 struct snd_ctl_elem_info *uinfo)
2154 int chs = get_amp_channels(kcontrol);
2156 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2157 uinfo->count = chs == 3 ? 2 : 1;
2158 uinfo->value.integer.min = 0;
2159 uinfo->value.integer.max = 1;
2162 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
2165 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2166 * @kcontrol: ctl element
2167 * @ucontrol: pointer to get/store the data
2169 * The control element is supposed to have the private_value field
2170 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2172 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2173 struct snd_ctl_elem_value *ucontrol)
2175 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2176 hda_nid_t nid = get_amp_nid(kcontrol);
2177 int chs = get_amp_channels(kcontrol);
2178 int dir = get_amp_direction(kcontrol);
2179 int idx = get_amp_index(kcontrol);
2180 long *valp = ucontrol->value.integer.value;
2183 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2184 HDA_AMP_MUTE) ? 0 : 1;
2186 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2187 HDA_AMP_MUTE) ? 0 : 1;
2190 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
2193 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2194 * @kcontrol: ctl element
2195 * @ucontrol: pointer to get/store the data
2197 * The control element is supposed to have the private_value field
2198 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2200 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2201 struct snd_ctl_elem_value *ucontrol)
2203 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2204 hda_nid_t nid = get_amp_nid(kcontrol);
2205 int chs = get_amp_channels(kcontrol);
2206 int dir = get_amp_direction(kcontrol);
2207 int idx = get_amp_index(kcontrol);
2208 long *valp = ucontrol->value.integer.value;
2212 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2214 *valp ? 0 : HDA_AMP_MUTE);
2218 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2220 *valp ? 0 : HDA_AMP_MUTE);
2221 hda_call_check_power_status(codec, nid);
2224 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
2227 * bound volume controls
2229 * bind multiple volumes (# indices, from 0)
2232 #define AMP_VAL_IDX_SHIFT 19
2233 #define AMP_VAL_IDX_MASK (0x0f<<19)
2236 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2237 * @kcontrol: ctl element
2238 * @ucontrol: pointer to get/store the data
2240 * The control element is supposed to have the private_value field
2241 * set up via HDA_BIND_MUTE*() macros.
2243 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2244 struct snd_ctl_elem_value *ucontrol)
2246 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2250 mutex_lock(&codec->control_mutex);
2251 pval = kcontrol->private_value;
2252 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2253 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2254 kcontrol->private_value = pval;
2255 mutex_unlock(&codec->control_mutex);
2258 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_get);
2261 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2262 * @kcontrol: ctl element
2263 * @ucontrol: pointer to get/store the data
2265 * The control element is supposed to have the private_value field
2266 * set up via HDA_BIND_MUTE*() macros.
2268 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2269 struct snd_ctl_elem_value *ucontrol)
2271 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2273 int i, indices, err = 0, change = 0;
2275 mutex_lock(&codec->control_mutex);
2276 pval = kcontrol->private_value;
2277 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2278 for (i = 0; i < indices; i++) {
2279 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2280 (i << AMP_VAL_IDX_SHIFT);
2281 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2286 kcontrol->private_value = pval;
2287 mutex_unlock(&codec->control_mutex);
2288 return err < 0 ? err : change;
2290 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_put);
2293 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2294 * @kcontrol: referred ctl element
2295 * @uinfo: pointer to get/store the data
2297 * The control element is supposed to have the private_value field
2298 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2300 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2301 struct snd_ctl_elem_info *uinfo)
2303 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2304 struct hda_bind_ctls *c;
2307 mutex_lock(&codec->control_mutex);
2308 c = (struct hda_bind_ctls *)kcontrol->private_value;
2309 kcontrol->private_value = *c->values;
2310 err = c->ops->info(kcontrol, uinfo);
2311 kcontrol->private_value = (long)c;
2312 mutex_unlock(&codec->control_mutex);
2315 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_info);
2318 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2319 * @kcontrol: ctl element
2320 * @ucontrol: pointer to get/store the data
2322 * The control element is supposed to have the private_value field
2323 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2325 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2326 struct snd_ctl_elem_value *ucontrol)
2328 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2329 struct hda_bind_ctls *c;
2332 mutex_lock(&codec->control_mutex);
2333 c = (struct hda_bind_ctls *)kcontrol->private_value;
2334 kcontrol->private_value = *c->values;
2335 err = c->ops->get(kcontrol, ucontrol);
2336 kcontrol->private_value = (long)c;
2337 mutex_unlock(&codec->control_mutex);
2340 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_get);
2343 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2344 * @kcontrol: ctl element
2345 * @ucontrol: pointer to get/store the data
2347 * The control element is supposed to have the private_value field
2348 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2350 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2351 struct snd_ctl_elem_value *ucontrol)
2353 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2354 struct hda_bind_ctls *c;
2355 unsigned long *vals;
2356 int err = 0, change = 0;
2358 mutex_lock(&codec->control_mutex);
2359 c = (struct hda_bind_ctls *)kcontrol->private_value;
2360 for (vals = c->values; *vals; vals++) {
2361 kcontrol->private_value = *vals;
2362 err = c->ops->put(kcontrol, ucontrol);
2367 kcontrol->private_value = (long)c;
2368 mutex_unlock(&codec->control_mutex);
2369 return err < 0 ? err : change;
2371 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_put);
2374 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2375 * @kcontrol: ctl element
2376 * @op_flag: operation flag
2377 * @size: byte size of input TLV
2380 * The control element is supposed to have the private_value field
2381 * set up via HDA_BIND_VOL() macro.
2383 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2384 unsigned int size, unsigned int __user *tlv)
2386 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2387 struct hda_bind_ctls *c;
2390 mutex_lock(&codec->control_mutex);
2391 c = (struct hda_bind_ctls *)kcontrol->private_value;
2392 kcontrol->private_value = *c->values;
2393 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2394 kcontrol->private_value = (long)c;
2395 mutex_unlock(&codec->control_mutex);
2398 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_tlv);
2400 struct hda_ctl_ops snd_hda_bind_vol = {
2401 .info = snd_hda_mixer_amp_volume_info,
2402 .get = snd_hda_mixer_amp_volume_get,
2403 .put = snd_hda_mixer_amp_volume_put,
2404 .tlv = snd_hda_mixer_amp_tlv
2406 EXPORT_SYMBOL_GPL(snd_hda_bind_vol);
2408 struct hda_ctl_ops snd_hda_bind_sw = {
2409 .info = snd_hda_mixer_amp_switch_info,
2410 .get = snd_hda_mixer_amp_switch_get,
2411 .put = snd_hda_mixer_amp_switch_put,
2412 .tlv = snd_hda_mixer_amp_tlv
2414 EXPORT_SYMBOL_GPL(snd_hda_bind_sw);
2417 * SPDIF out controls
2420 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2421 struct snd_ctl_elem_info *uinfo)
2423 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2428 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2429 struct snd_ctl_elem_value *ucontrol)
2431 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2432 IEC958_AES0_NONAUDIO |
2433 IEC958_AES0_CON_EMPHASIS_5015 |
2434 IEC958_AES0_CON_NOT_COPYRIGHT;
2435 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2436 IEC958_AES1_CON_ORIGINAL;
2440 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2441 struct snd_ctl_elem_value *ucontrol)
2443 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2444 IEC958_AES0_NONAUDIO |
2445 IEC958_AES0_PRO_EMPHASIS_5015;
2449 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2450 struct snd_ctl_elem_value *ucontrol)
2452 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2453 int idx = kcontrol->private_value;
2454 struct hda_spdif_out *spdif;
2456 mutex_lock(&codec->spdif_mutex);
2457 spdif = snd_array_elem(&codec->spdif_out, idx);
2458 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2459 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2460 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2461 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2462 mutex_unlock(&codec->spdif_mutex);
2467 /* convert from SPDIF status bits to HDA SPDIF bits
2468 * bit 0 (DigEn) is always set zero (to be filled later)
2470 static unsigned short convert_from_spdif_status(unsigned int sbits)
2472 unsigned short val = 0;
2474 if (sbits & IEC958_AES0_PROFESSIONAL)
2475 val |= AC_DIG1_PROFESSIONAL;
2476 if (sbits & IEC958_AES0_NONAUDIO)
2477 val |= AC_DIG1_NONAUDIO;
2478 if (sbits & IEC958_AES0_PROFESSIONAL) {
2479 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2480 IEC958_AES0_PRO_EMPHASIS_5015)
2481 val |= AC_DIG1_EMPHASIS;
2483 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2484 IEC958_AES0_CON_EMPHASIS_5015)
2485 val |= AC_DIG1_EMPHASIS;
2486 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2487 val |= AC_DIG1_COPYRIGHT;
2488 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2489 val |= AC_DIG1_LEVEL;
2490 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2495 /* convert to SPDIF status bits from HDA SPDIF bits
2497 static unsigned int convert_to_spdif_status(unsigned short val)
2499 unsigned int sbits = 0;
2501 if (val & AC_DIG1_NONAUDIO)
2502 sbits |= IEC958_AES0_NONAUDIO;
2503 if (val & AC_DIG1_PROFESSIONAL)
2504 sbits |= IEC958_AES0_PROFESSIONAL;
2505 if (sbits & IEC958_AES0_PROFESSIONAL) {
2506 if (val & AC_DIG1_EMPHASIS)
2507 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2509 if (val & AC_DIG1_EMPHASIS)
2510 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2511 if (!(val & AC_DIG1_COPYRIGHT))
2512 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2513 if (val & AC_DIG1_LEVEL)
2514 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2515 sbits |= val & (0x7f << 8);
2520 /* set digital convert verbs both for the given NID and its slaves */
2521 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2526 snd_hdac_regmap_update(&codec->core, nid, AC_VERB_SET_DIGI_CONVERT_1,
2528 d = codec->slave_dig_outs;
2532 snd_hdac_regmap_update(&codec->core, nid,
2533 AC_VERB_SET_DIGI_CONVERT_1, mask, val);
2536 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2539 unsigned int mask = 0;
2540 unsigned int val = 0;
2550 set_dig_out(codec, nid, mask, val);
2553 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2554 struct snd_ctl_elem_value *ucontrol)
2556 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2557 int idx = kcontrol->private_value;
2558 struct hda_spdif_out *spdif;
2563 mutex_lock(&codec->spdif_mutex);
2564 spdif = snd_array_elem(&codec->spdif_out, idx);
2566 spdif->status = ucontrol->value.iec958.status[0] |
2567 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2568 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2569 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2570 val = convert_from_spdif_status(spdif->status);
2571 val |= spdif->ctls & 1;
2572 change = spdif->ctls != val;
2574 if (change && nid != (u16)-1)
2575 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2576 mutex_unlock(&codec->spdif_mutex);
2580 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2582 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2583 struct snd_ctl_elem_value *ucontrol)
2585 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2586 int idx = kcontrol->private_value;
2587 struct hda_spdif_out *spdif;
2589 mutex_lock(&codec->spdif_mutex);
2590 spdif = snd_array_elem(&codec->spdif_out, idx);
2591 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
2592 mutex_unlock(&codec->spdif_mutex);
2596 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2599 set_dig_out_convert(codec, nid, dig1, dig2);
2600 /* unmute amp switch (if any) */
2601 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2602 (dig1 & AC_DIG1_ENABLE))
2603 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2607 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2608 struct snd_ctl_elem_value *ucontrol)
2610 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2611 int idx = kcontrol->private_value;
2612 struct hda_spdif_out *spdif;
2617 mutex_lock(&codec->spdif_mutex);
2618 spdif = snd_array_elem(&codec->spdif_out, idx);
2620 val = spdif->ctls & ~AC_DIG1_ENABLE;
2621 if (ucontrol->value.integer.value[0])
2622 val |= AC_DIG1_ENABLE;
2623 change = spdif->ctls != val;
2625 if (change && nid != (u16)-1)
2626 set_spdif_ctls(codec, nid, val & 0xff, -1);
2627 mutex_unlock(&codec->spdif_mutex);
2631 static struct snd_kcontrol_new dig_mixes[] = {
2633 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2634 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2635 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
2636 .info = snd_hda_spdif_mask_info,
2637 .get = snd_hda_spdif_cmask_get,
2640 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2641 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2642 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
2643 .info = snd_hda_spdif_mask_info,
2644 .get = snd_hda_spdif_pmask_get,
2647 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2648 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
2649 .info = snd_hda_spdif_mask_info,
2650 .get = snd_hda_spdif_default_get,
2651 .put = snd_hda_spdif_default_put,
2654 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2655 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
2656 .info = snd_hda_spdif_out_switch_info,
2657 .get = snd_hda_spdif_out_switch_get,
2658 .put = snd_hda_spdif_out_switch_put,
2664 * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
2665 * @codec: the HDA codec
2666 * @associated_nid: NID that new ctls associated with
2667 * @cvt_nid: converter NID
2668 * @type: HDA_PCM_TYPE_*
2669 * Creates controls related with the digital output.
2670 * Called from each patch supporting the digital out.
2672 * Returns 0 if successful, or a negative error code.
2674 int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
2675 hda_nid_t associated_nid,
2680 struct snd_kcontrol *kctl;
2681 struct snd_kcontrol_new *dig_mix;
2684 const int spdif_index = 16;
2685 struct hda_spdif_out *spdif;
2686 struct hda_bus *bus = codec->bus;
2688 if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
2689 type == HDA_PCM_TYPE_SPDIF) {
2691 } else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
2692 type == HDA_PCM_TYPE_HDMI) {
2693 /* suppose a single SPDIF device */
2694 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2695 kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
2698 kctl->id.index = spdif_index;
2700 bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
2702 if (!bus->primary_dig_out_type)
2703 bus->primary_dig_out_type = type;
2705 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
2707 codec_err(codec, "too many IEC958 outputs\n");
2710 spdif = snd_array_new(&codec->spdif_out);
2713 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2714 kctl = snd_ctl_new1(dig_mix, codec);
2717 kctl->id.index = idx;
2718 kctl->private_value = codec->spdif_out.used - 1;
2719 err = snd_hda_ctl_add(codec, associated_nid, kctl);
2723 spdif->nid = cvt_nid;
2724 snd_hdac_regmap_read(&codec->core, cvt_nid,
2725 AC_VERB_GET_DIGI_CONVERT_1, &val);
2727 spdif->status = convert_to_spdif_status(spdif->ctls);
2730 EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls);
2733 * snd_hda_spdif_out_of_nid - get the hda_spdif_out entry from the given NID
2734 * @codec: the HDA codec
2737 * call within spdif_mutex lock
2739 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
2743 for (i = 0; i < codec->spdif_out.used; i++) {
2744 struct hda_spdif_out *spdif =
2745 snd_array_elem(&codec->spdif_out, i);
2746 if (spdif->nid == nid)
2751 EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_nid);
2754 * snd_hda_spdif_ctls_unassign - Unassign the given SPDIF ctl
2755 * @codec: the HDA codec
2756 * @idx: the SPDIF ctl index
2758 * Unassign the widget from the given SPDIF control.
2760 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
2762 struct hda_spdif_out *spdif;
2764 mutex_lock(&codec->spdif_mutex);
2765 spdif = snd_array_elem(&codec->spdif_out, idx);
2766 spdif->nid = (u16)-1;
2767 mutex_unlock(&codec->spdif_mutex);
2769 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
2772 * snd_hda_spdif_ctls_assign - Assign the SPDIF controls to the given NID
2773 * @codec: the HDA codec
2774 * @idx: the SPDIF ctl idx
2777 * Assign the widget to the SPDIF control with the given index.
2779 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
2781 struct hda_spdif_out *spdif;
2784 mutex_lock(&codec->spdif_mutex);
2785 spdif = snd_array_elem(&codec->spdif_out, idx);
2786 if (spdif->nid != nid) {
2789 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
2791 mutex_unlock(&codec->spdif_mutex);
2793 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
2796 * SPDIF sharing with analog output
2798 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2799 struct snd_ctl_elem_value *ucontrol)
2801 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2802 ucontrol->value.integer.value[0] = mout->share_spdif;
2806 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2807 struct snd_ctl_elem_value *ucontrol)
2809 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2810 mout->share_spdif = !!ucontrol->value.integer.value[0];
2814 static struct snd_kcontrol_new spdif_share_sw = {
2815 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2816 .name = "IEC958 Default PCM Playback Switch",
2817 .info = snd_ctl_boolean_mono_info,
2818 .get = spdif_share_sw_get,
2819 .put = spdif_share_sw_put,
2823 * snd_hda_create_spdif_share_sw - create Default PCM switch
2824 * @codec: the HDA codec
2825 * @mout: multi-out instance
2827 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2828 struct hda_multi_out *mout)
2830 struct snd_kcontrol *kctl;
2832 if (!mout->dig_out_nid)
2835 kctl = snd_ctl_new1(&spdif_share_sw, mout);
2838 /* ATTENTION: here mout is passed as private_data, instead of codec */
2839 return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
2841 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
2847 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2849 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2850 struct snd_ctl_elem_value *ucontrol)
2852 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2854 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2858 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2859 struct snd_ctl_elem_value *ucontrol)
2861 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2862 hda_nid_t nid = kcontrol->private_value;
2863 unsigned int val = !!ucontrol->value.integer.value[0];
2866 mutex_lock(&codec->spdif_mutex);
2867 change = codec->spdif_in_enable != val;
2869 codec->spdif_in_enable = val;
2870 snd_hdac_regmap_write(&codec->core, nid,
2871 AC_VERB_SET_DIGI_CONVERT_1, val);
2873 mutex_unlock(&codec->spdif_mutex);
2877 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2878 struct snd_ctl_elem_value *ucontrol)
2880 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2881 hda_nid_t nid = kcontrol->private_value;
2885 snd_hdac_regmap_read(&codec->core, nid,
2886 AC_VERB_GET_DIGI_CONVERT_1, &val);
2887 sbits = convert_to_spdif_status(val);
2888 ucontrol->value.iec958.status[0] = sbits;
2889 ucontrol->value.iec958.status[1] = sbits >> 8;
2890 ucontrol->value.iec958.status[2] = sbits >> 16;
2891 ucontrol->value.iec958.status[3] = sbits >> 24;
2895 static struct snd_kcontrol_new dig_in_ctls[] = {
2897 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2898 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
2899 .info = snd_hda_spdif_in_switch_info,
2900 .get = snd_hda_spdif_in_switch_get,
2901 .put = snd_hda_spdif_in_switch_put,
2904 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2905 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2906 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
2907 .info = snd_hda_spdif_mask_info,
2908 .get = snd_hda_spdif_in_status_get,
2914 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2915 * @codec: the HDA codec
2916 * @nid: audio in widget NID
2918 * Creates controls related with the SPDIF input.
2919 * Called from each patch supporting the SPDIF in.
2921 * Returns 0 if successful, or a negative error code.
2923 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2926 struct snd_kcontrol *kctl;
2927 struct snd_kcontrol_new *dig_mix;
2930 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
2932 codec_err(codec, "too many IEC958 inputs\n");
2935 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2936 kctl = snd_ctl_new1(dig_mix, codec);
2939 kctl->private_value = nid;
2940 err = snd_hda_ctl_add(codec, nid, kctl);
2944 codec->spdif_in_enable =
2945 snd_hda_codec_read(codec, nid, 0,
2946 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2950 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
2953 * snd_hda_codec_set_power_to_all - Set the power state to all widgets
2954 * @codec: the HDA codec
2955 * @fg: function group (not used now)
2956 * @power_state: the power state to set (AC_PWRST_*)
2958 * Set the given power state to all widgets that have the power control.
2959 * If the codec has power_filter set, it evaluates the power state and
2960 * filter out if it's unchanged as D3.
2962 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
2963 unsigned int power_state)
2967 for_each_hda_codec_node(nid, codec) {
2968 unsigned int wcaps = get_wcaps(codec, nid);
2969 unsigned int state = power_state;
2970 if (!(wcaps & AC_WCAP_POWER))
2972 if (codec->power_filter) {
2973 state = codec->power_filter(codec, nid, power_state);
2974 if (state != power_state && power_state == AC_PWRST_D3)
2977 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
2981 EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all);
2984 * wait until the state is reached, returns the current state
2986 static unsigned int hda_sync_power_state(struct hda_codec *codec,
2988 unsigned int power_state)
2990 unsigned long end_time = jiffies + msecs_to_jiffies(500);
2991 unsigned int state, actual_state;
2994 state = snd_hda_codec_read(codec, fg, 0,
2995 AC_VERB_GET_POWER_STATE, 0);
2996 if (state & AC_PWRST_ERROR)
2998 actual_state = (state >> 4) & 0x0f;
2999 if (actual_state == power_state)
3001 if (time_after_eq(jiffies, end_time))
3003 /* wait until the codec reachs to the target state */
3010 * snd_hda_codec_eapd_power_filter - A power filter callback for EAPD
3011 * @codec: the HDA codec
3013 * @power_state: power state to evalue
3015 * Don't power down the widget if it controls eapd and EAPD_BTLENABLE is set.
3016 * This can be used a codec power_filter callback.
3018 unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
3020 unsigned int power_state)
3022 if (nid == codec->core.afg || nid == codec->core.mfg)
3024 if (power_state == AC_PWRST_D3 &&
3025 get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
3026 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3027 int eapd = snd_hda_codec_read(codec, nid, 0,
3028 AC_VERB_GET_EAPD_BTLENABLE, 0);
3034 EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter);
3037 * set power state of the codec, and return the power state
3039 static unsigned int hda_set_power_state(struct hda_codec *codec,
3040 unsigned int power_state)
3042 hda_nid_t fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
3047 /* this delay seems necessary to avoid click noise at power-down */
3048 if (power_state == AC_PWRST_D3) {
3049 if (codec->depop_delay < 0)
3050 msleep(codec_has_epss(codec) ? 10 : 100);
3051 else if (codec->depop_delay > 0)
3052 msleep(codec->depop_delay);
3053 flags = HDA_RW_NO_RESPONSE_FALLBACK;
3056 /* repeat power states setting at most 10 times*/
3057 for (count = 0; count < 10; count++) {
3058 if (codec->patch_ops.set_power_state)
3059 codec->patch_ops.set_power_state(codec, fg,
3062 state = power_state;
3063 if (codec->power_filter)
3064 state = codec->power_filter(codec, fg, state);
3065 if (state == power_state || power_state != AC_PWRST_D3)
3066 snd_hda_codec_read(codec, fg, flags,
3067 AC_VERB_SET_POWER_STATE,
3069 snd_hda_codec_set_power_to_all(codec, fg, power_state);
3071 state = hda_sync_power_state(codec, fg, power_state);
3072 if (!(state & AC_PWRST_ERROR))
3079 /* sync power states of all widgets;
3080 * this is called at the end of codec parsing
3082 static void sync_power_up_states(struct hda_codec *codec)
3086 /* don't care if no filter is used */
3087 if (!codec->power_filter)
3090 for_each_hda_codec_node(nid, codec) {
3091 unsigned int wcaps = get_wcaps(codec, nid);
3092 unsigned int target;
3093 if (!(wcaps & AC_WCAP_POWER))
3095 target = codec->power_filter(codec, nid, AC_PWRST_D0);
3096 if (target == AC_PWRST_D0)
3098 if (!snd_hda_check_power_state(codec, nid, target))
3099 snd_hda_codec_write(codec, nid, 0,
3100 AC_VERB_SET_POWER_STATE, target);
3104 #ifdef CONFIG_SND_HDA_RECONFIG
3105 /* execute additional init verbs */
3106 static void hda_exec_init_verbs(struct hda_codec *codec)
3108 if (codec->init_verbs.list)
3109 snd_hda_sequence_write(codec, codec->init_verbs.list);
3112 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3116 /* update the power on/off account with the current jiffies */
3117 static void update_power_acct(struct hda_codec *codec, bool on)
3119 unsigned long delta = jiffies - codec->power_jiffies;
3122 codec->power_on_acct += delta;
3124 codec->power_off_acct += delta;
3125 codec->power_jiffies += delta;
3128 void snd_hda_update_power_acct(struct hda_codec *codec)
3130 update_power_acct(codec, hda_codec_is_power_on(codec));
3134 * call suspend and power-down; used both from PM and power-save
3135 * this function returns the power state in the end
3137 static unsigned int hda_call_codec_suspend(struct hda_codec *codec)
3141 atomic_inc(&codec->core.in_pm);
3143 if (codec->patch_ops.suspend)
3144 codec->patch_ops.suspend(codec);
3145 hda_cleanup_all_streams(codec);
3146 state = hda_set_power_state(codec, AC_PWRST_D3);
3147 update_power_acct(codec, true);
3148 atomic_dec(&codec->core.in_pm);
3153 * kick up codec; used both from PM and power-save
3155 static void hda_call_codec_resume(struct hda_codec *codec)
3157 atomic_inc(&codec->core.in_pm);
3159 if (codec->core.regmap)
3160 regcache_mark_dirty(codec->core.regmap);
3162 codec->power_jiffies = jiffies;
3164 hda_set_power_state(codec, AC_PWRST_D0);
3165 restore_shutup_pins(codec);
3166 hda_exec_init_verbs(codec);
3167 snd_hda_jack_set_dirty_all(codec);
3168 if (codec->patch_ops.resume)
3169 codec->patch_ops.resume(codec);
3171 if (codec->patch_ops.init)
3172 codec->patch_ops.init(codec);
3173 if (codec->core.regmap)
3174 regcache_sync(codec->core.regmap);
3177 if (codec->jackpoll_interval)
3178 hda_jackpoll_work(&codec->jackpoll_work.work);
3180 snd_hda_jack_report_sync(codec);
3181 atomic_dec(&codec->core.in_pm);
3184 static int hda_codec_runtime_suspend(struct device *dev)
3186 struct hda_codec *codec = dev_to_hda_codec(dev);
3187 struct hda_pcm *pcm;
3190 cancel_delayed_work_sync(&codec->jackpoll_work);
3191 list_for_each_entry(pcm, &codec->pcm_list_head, list)
3192 snd_pcm_suspend_all(pcm->pcm);
3193 state = hda_call_codec_suspend(codec);
3194 if (codec_has_clkstop(codec) && codec_has_epss(codec) &&
3195 (state & AC_PWRST_CLK_STOP_OK))
3196 snd_hdac_codec_link_down(&codec->core);
3200 static int hda_codec_runtime_resume(struct device *dev)
3202 struct hda_codec *codec = dev_to_hda_codec(dev);
3204 snd_hdac_codec_link_up(&codec->core);
3205 hda_call_codec_resume(codec);
3206 pm_runtime_mark_last_busy(dev);
3209 #endif /* CONFIG_PM */
3211 /* referred in hda_bind.c */
3212 const struct dev_pm_ops hda_codec_driver_pm = {
3213 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
3214 pm_runtime_force_resume)
3215 SET_RUNTIME_PM_OPS(hda_codec_runtime_suspend, hda_codec_runtime_resume,
3220 * add standard channel maps if not specified
3222 static int add_std_chmaps(struct hda_codec *codec)
3224 struct hda_pcm *pcm;
3227 list_for_each_entry(pcm, &codec->pcm_list_head, list) {
3228 for (str = 0; str < 2; str++) {
3229 struct hda_pcm_stream *hinfo = &pcm->stream[str];
3230 struct snd_pcm_chmap *chmap;
3231 const struct snd_pcm_chmap_elem *elem;
3233 if (!pcm || pcm->own_chmap ||
3236 elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
3237 err = snd_pcm_add_chmap_ctls(pcm->pcm, str, elem,
3238 hinfo->channels_max,
3242 chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
3248 /* default channel maps for 2.1 speakers;
3249 * since HD-audio supports only stereo, odd number channels are omitted
3251 const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
3253 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
3255 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
3256 SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
3259 EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
3261 int snd_hda_codec_build_controls(struct hda_codec *codec)
3264 hda_exec_init_verbs(codec);
3265 /* continue to initialize... */
3266 if (codec->patch_ops.init)
3267 err = codec->patch_ops.init(codec);
3268 if (!err && codec->patch_ops.build_controls)
3269 err = codec->patch_ops.build_controls(codec);
3273 /* we create chmaps here instead of build_pcms */
3274 err = add_std_chmaps(codec);
3278 if (codec->jackpoll_interval)
3279 hda_jackpoll_work(&codec->jackpoll_work.work);
3281 snd_hda_jack_report_sync(codec); /* call at the last init point */
3282 sync_power_up_states(codec);
3289 struct hda_rate_tbl {
3291 unsigned int alsa_bits;
3292 unsigned int hda_fmt;
3295 /* rate = base * mult / div */
3296 #define HDA_RATE(base, mult, div) \
3297 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3298 (((div) - 1) << AC_FMT_DIV_SHIFT))
3300 static struct hda_rate_tbl rate_bits[] = {
3301 /* rate in Hz, ALSA rate bitmask, HDA format value */
3303 /* autodetected value used in snd_hda_query_supported_pcm */
3304 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3305 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3306 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3307 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3308 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3309 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3310 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3311 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3312 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3313 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3314 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3315 #define AC_PAR_PCM_RATE_BITS 11
3316 /* up to bits 10, 384kHZ isn't supported properly */
3318 /* not autodetected value */
3319 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3321 { 0 } /* terminator */
3325 * snd_hda_calc_stream_format - calculate format bitset
3326 * @codec: HD-audio codec
3327 * @rate: the sample rate
3328 * @channels: the number of channels
3329 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3330 * @maxbps: the max. bps
3331 * @spdif_ctls: HD-audio SPDIF status bits (0 if irrelevant)
3333 * Calculate the format bitset from the given rate, channels and th PCM format.
3335 * Return zero if invalid.
3337 unsigned int snd_hda_calc_stream_format(struct hda_codec *codec,
3339 unsigned int channels,
3340 unsigned int format,
3341 unsigned int maxbps,
3342 unsigned short spdif_ctls)
3345 unsigned int val = 0;
3347 for (i = 0; rate_bits[i].hz; i++)
3348 if (rate_bits[i].hz == rate) {
3349 val = rate_bits[i].hda_fmt;
3352 if (!rate_bits[i].hz) {
3353 codec_dbg(codec, "invalid rate %d\n", rate);
3357 if (channels == 0 || channels > 8) {
3358 codec_dbg(codec, "invalid channels %d\n", channels);
3361 val |= channels - 1;
3363 switch (snd_pcm_format_width(format)) {
3365 val |= AC_FMT_BITS_8;
3368 val |= AC_FMT_BITS_16;
3373 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3374 val |= AC_FMT_BITS_32;
3375 else if (maxbps >= 24)
3376 val |= AC_FMT_BITS_24;
3378 val |= AC_FMT_BITS_20;
3381 codec_dbg(codec, "invalid format width %d\n",
3382 snd_pcm_format_width(format));
3386 if (spdif_ctls & AC_DIG1_NONAUDIO)
3387 val |= AC_FMT_TYPE_NON_PCM;
3391 EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format);
3393 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3395 unsigned int val = 0;
3396 if (nid != codec->core.afg &&
3397 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3398 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3399 if (!val || val == -1)
3400 val = snd_hda_param_read(codec, codec->core.afg, AC_PAR_PCM);
3401 if (!val || val == -1)
3406 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3408 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3409 if (!streams || streams == -1)
3410 streams = snd_hda_param_read(codec, codec->core.afg, AC_PAR_STREAM);
3411 if (!streams || streams == -1)
3417 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3418 * @codec: the HDA codec
3419 * @nid: NID to query
3420 * @ratesp: the pointer to store the detected rate bitflags
3421 * @formatsp: the pointer to store the detected formats
3422 * @bpsp: the pointer to store the detected format widths
3424 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3425 * or @bsps argument is ignored.
3427 * Returns 0 if successful, otherwise a negative error code.
3429 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3430 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3432 unsigned int i, val, wcaps;
3434 wcaps = get_wcaps(codec, nid);
3435 val = query_pcm_param(codec, nid);
3439 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3441 rates |= rate_bits[i].alsa_bits;
3445 "rates == 0 (nid=0x%x, val=0x%x, ovrd=%i)\n",
3447 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3453 if (formatsp || bpsp) {
3455 unsigned int streams, bps;
3457 streams = query_stream_param(codec, nid);
3462 if (streams & AC_SUPFMT_PCM) {
3463 if (val & AC_SUPPCM_BITS_8) {
3464 formats |= SNDRV_PCM_FMTBIT_U8;
3467 if (val & AC_SUPPCM_BITS_16) {
3468 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3471 if (wcaps & AC_WCAP_DIGITAL) {
3472 if (val & AC_SUPPCM_BITS_32)
3473 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3474 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3475 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3476 if (val & AC_SUPPCM_BITS_24)
3478 else if (val & AC_SUPPCM_BITS_20)
3480 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3481 AC_SUPPCM_BITS_32)) {
3482 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3483 if (val & AC_SUPPCM_BITS_32)
3485 else if (val & AC_SUPPCM_BITS_24)
3487 else if (val & AC_SUPPCM_BITS_20)
3491 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
3492 if (streams & AC_SUPFMT_FLOAT32) {
3493 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3498 if (streams == AC_SUPFMT_AC3) {
3499 /* should be exclusive */
3500 /* temporary hack: we have still no proper support
3501 * for the direct AC3 stream...
3503 formats |= SNDRV_PCM_FMTBIT_U8;
3508 "formats == 0 (nid=0x%x, val=0x%x, ovrd=%i, streams=0x%x)\n",
3510 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3515 *formatsp = formats;
3522 EXPORT_SYMBOL_GPL(snd_hda_query_supported_pcm);
3525 * snd_hda_is_supported_format - Check the validity of the format
3526 * @codec: HD-audio codec
3527 * @nid: NID to check
3528 * @format: the HD-audio format value to check
3530 * Check whether the given node supports the format value.
3532 * Returns 1 if supported, 0 if not.
3534 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3535 unsigned int format)
3538 unsigned int val = 0, rate, stream;
3540 val = query_pcm_param(codec, nid);
3544 rate = format & 0xff00;
3545 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3546 if (rate_bits[i].hda_fmt == rate) {
3551 if (i >= AC_PAR_PCM_RATE_BITS)
3554 stream = query_stream_param(codec, nid);
3558 if (stream & AC_SUPFMT_PCM) {
3559 switch (format & 0xf0) {
3561 if (!(val & AC_SUPPCM_BITS_8))
3565 if (!(val & AC_SUPPCM_BITS_16))
3569 if (!(val & AC_SUPPCM_BITS_20))
3573 if (!(val & AC_SUPPCM_BITS_24))
3577 if (!(val & AC_SUPPCM_BITS_32))
3584 /* FIXME: check for float32 and AC3? */
3589 EXPORT_SYMBOL_GPL(snd_hda_is_supported_format);
3594 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3595 struct hda_codec *codec,
3596 struct snd_pcm_substream *substream)
3601 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3602 struct hda_codec *codec,
3603 unsigned int stream_tag,
3604 unsigned int format,
3605 struct snd_pcm_substream *substream)
3607 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3611 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3612 struct hda_codec *codec,
3613 struct snd_pcm_substream *substream)
3615 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3619 static int set_pcm_default_values(struct hda_codec *codec,
3620 struct hda_pcm_stream *info)
3624 /* query support PCM information from the given NID */
3625 if (info->nid && (!info->rates || !info->formats)) {
3626 err = snd_hda_query_supported_pcm(codec, info->nid,
3627 info->rates ? NULL : &info->rates,
3628 info->formats ? NULL : &info->formats,
3629 info->maxbps ? NULL : &info->maxbps);
3633 if (info->ops.open == NULL)
3634 info->ops.open = hda_pcm_default_open_close;
3635 if (info->ops.close == NULL)
3636 info->ops.close = hda_pcm_default_open_close;
3637 if (info->ops.prepare == NULL) {
3638 if (snd_BUG_ON(!info->nid))
3640 info->ops.prepare = hda_pcm_default_prepare;
3642 if (info->ops.cleanup == NULL) {
3643 if (snd_BUG_ON(!info->nid))
3645 info->ops.cleanup = hda_pcm_default_cleanup;
3651 * codec prepare/cleanup entries
3654 * snd_hda_codec_prepare - Prepare a stream
3655 * @codec: the HDA codec
3656 * @hinfo: PCM information
3657 * @stream: stream tag to assign
3658 * @format: format id to assign
3659 * @substream: PCM substream to assign
3661 * Calls the prepare callback set by the codec with the given arguments.
3662 * Clean up the inactive streams when successful.
3664 int snd_hda_codec_prepare(struct hda_codec *codec,
3665 struct hda_pcm_stream *hinfo,
3666 unsigned int stream,
3667 unsigned int format,
3668 struct snd_pcm_substream *substream)
3671 mutex_lock(&codec->bus->prepare_mutex);
3672 if (hinfo->ops.prepare)
3673 ret = hinfo->ops.prepare(hinfo, codec, stream, format,
3678 purify_inactive_streams(codec);
3679 mutex_unlock(&codec->bus->prepare_mutex);
3682 EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
3685 * snd_hda_codec_cleanup - Prepare a stream
3686 * @codec: the HDA codec
3687 * @hinfo: PCM information
3688 * @substream: PCM substream
3690 * Calls the cleanup callback set by the codec with the given arguments.
3692 void snd_hda_codec_cleanup(struct hda_codec *codec,
3693 struct hda_pcm_stream *hinfo,
3694 struct snd_pcm_substream *substream)
3696 mutex_lock(&codec->bus->prepare_mutex);
3697 if (hinfo->ops.cleanup)
3698 hinfo->ops.cleanup(hinfo, codec, substream);
3699 mutex_unlock(&codec->bus->prepare_mutex);
3701 EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
3704 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3705 "Audio", "SPDIF", "HDMI", "Modem"
3709 * get the empty PCM device number to assign
3711 static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type)
3713 /* audio device indices; not linear to keep compatibility */
3714 /* assigned to static slots up to dev#10; if more needed, assign
3715 * the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y)
3717 static int audio_idx[HDA_PCM_NTYPES][5] = {
3718 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3719 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3720 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
3721 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
3725 if (type >= HDA_PCM_NTYPES) {
3726 dev_err(bus->card->dev, "Invalid PCM type %d\n", type);
3730 for (i = 0; audio_idx[type][i] >= 0; i++) {
3731 #ifndef CONFIG_SND_DYNAMIC_MINORS
3732 if (audio_idx[type][i] >= 8)
3735 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3736 return audio_idx[type][i];
3739 #ifdef CONFIG_SND_DYNAMIC_MINORS
3740 /* non-fixed slots starting from 10 */
3741 for (i = 10; i < 32; i++) {
3742 if (!test_and_set_bit(i, bus->pcm_dev_bits))
3747 dev_warn(bus->card->dev, "Too many %s devices\n",
3748 snd_hda_pcm_type_name[type]);
3749 #ifndef CONFIG_SND_DYNAMIC_MINORS
3750 dev_warn(bus->card->dev,
3751 "Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n");
3756 /* call build_pcms ops of the given codec and set up the default parameters */
3757 int snd_hda_codec_parse_pcms(struct hda_codec *codec)
3759 struct hda_pcm *cpcm;
3762 if (!list_empty(&codec->pcm_list_head))
3763 return 0; /* already parsed */
3765 if (!codec->patch_ops.build_pcms)
3768 err = codec->patch_ops.build_pcms(codec);
3770 codec_err(codec, "cannot build PCMs for #%d (error %d)\n",
3771 codec->core.addr, err);
3775 list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
3778 for (stream = 0; stream < 2; stream++) {
3779 struct hda_pcm_stream *info = &cpcm->stream[stream];
3781 if (!info->substreams)
3783 err = set_pcm_default_values(codec, info);
3786 "fail to setup default for PCM %s\n",
3796 /* assign all PCMs of the given codec */
3797 int snd_hda_codec_build_pcms(struct hda_codec *codec)
3799 struct hda_bus *bus = codec->bus;
3800 struct hda_pcm *cpcm;
3803 if (snd_BUG_ON(!bus->ops.attach_pcm))
3806 err = snd_hda_codec_parse_pcms(codec);
3808 snd_hda_codec_reset(codec);
3812 /* attach a new PCM streams */
3813 list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
3815 continue; /* already attached */
3816 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
3817 continue; /* no substreams assigned */
3819 dev = get_empty_pcm_device(bus, cpcm->pcm_type);
3821 continue; /* no fatal error */
3823 err = bus->ops.attach_pcm(bus, codec, cpcm);
3826 "cannot attach PCM stream %d for codec #%d\n",
3827 dev, codec->core.addr);
3828 continue; /* no fatal error */
3836 * snd_hda_add_new_ctls - create controls from the array
3837 * @codec: the HDA codec
3838 * @knew: the array of struct snd_kcontrol_new
3840 * This helper function creates and add new controls in the given array.
3841 * The array must be terminated with an empty entry as terminator.
3843 * Returns 0 if successful, or a negative error code.
3845 int snd_hda_add_new_ctls(struct hda_codec *codec,
3846 const struct snd_kcontrol_new *knew)
3850 for (; knew->name; knew++) {
3851 struct snd_kcontrol *kctl;
3852 int addr = 0, idx = 0;
3853 if (knew->iface == -1) /* skip this codec private value */
3856 kctl = snd_ctl_new1(knew, codec);
3860 kctl->id.device = addr;
3862 kctl->id.index = idx;
3863 err = snd_hda_ctl_add(codec, 0, kctl);
3866 /* try first with another device index corresponding to
3867 * the codec addr; if it still fails (or it's the
3868 * primary codec), then try another control index
3870 if (!addr && codec->core.addr)
3871 addr = codec->core.addr;
3872 else if (!idx && !knew->index) {
3873 idx = find_empty_mixer_ctl_idx(codec,
3883 EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
3886 static void codec_set_power_save(struct hda_codec *codec, int delay)
3888 struct device *dev = hda_codec_dev(codec);
3891 pm_runtime_set_autosuspend_delay(dev, delay);
3892 pm_runtime_use_autosuspend(dev);
3893 pm_runtime_allow(dev);
3894 if (!pm_runtime_suspended(dev))
3895 pm_runtime_mark_last_busy(dev);
3897 pm_runtime_dont_use_autosuspend(dev);
3898 pm_runtime_forbid(dev);
3903 * snd_hda_set_power_save - reprogram autosuspend for the given delay
3904 * @bus: HD-audio bus
3905 * @delay: autosuspend delay in msec, 0 = off
3907 * Synchronize the runtime PM autosuspend state from the power_save option.
3909 void snd_hda_set_power_save(struct hda_bus *bus, int delay)
3911 struct hda_codec *c;
3913 list_for_each_codec(c, bus)
3914 codec_set_power_save(c, delay);
3916 EXPORT_SYMBOL_GPL(snd_hda_set_power_save);
3919 * snd_hda_check_amp_list_power - Check the amp list and update the power
3920 * @codec: HD-audio codec
3921 * @check: the object containing an AMP list and the status
3922 * @nid: NID to check / update
3924 * Check whether the given NID is in the amp list. If it's in the list,
3925 * check the current AMP status, and update the the power-status according
3926 * to the mute status.
3928 * This function is supposed to be set or called from the check_power_status
3931 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3932 struct hda_loopback_check *check,
3935 const struct hda_amp_list *p;
3938 if (!check->amplist)
3940 for (p = check->amplist; p->nid; p++) {
3945 return 0; /* nothing changed */
3947 for (p = check->amplist; p->nid; p++) {
3948 for (ch = 0; ch < 2; ch++) {
3949 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3951 if (!(v & HDA_AMP_MUTE) && v > 0) {
3952 if (!check->power_on) {
3953 check->power_on = 1;
3954 snd_hda_power_up_pm(codec);
3960 if (check->power_on) {
3961 check->power_on = 0;
3962 snd_hda_power_down_pm(codec);
3966 EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
3974 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
3975 * @imux: imux helper object
3976 * @uinfo: pointer to get/store the data
3978 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3979 struct snd_ctl_elem_info *uinfo)
3983 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3985 uinfo->value.enumerated.items = imux->num_items;
3986 if (!imux->num_items)
3988 index = uinfo->value.enumerated.item;
3989 if (index >= imux->num_items)
3990 index = imux->num_items - 1;
3991 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3994 EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
3997 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
3998 * @codec: the HDA codec
3999 * @imux: imux helper object
4000 * @ucontrol: pointer to get/store the data
4001 * @nid: input mux NID
4002 * @cur_val: pointer to get/store the current imux value
4004 int snd_hda_input_mux_put(struct hda_codec *codec,
4005 const struct hda_input_mux *imux,
4006 struct snd_ctl_elem_value *ucontrol,
4008 unsigned int *cur_val)
4012 if (!imux->num_items)
4014 idx = ucontrol->value.enumerated.item[0];
4015 if (idx >= imux->num_items)
4016 idx = imux->num_items - 1;
4017 if (*cur_val == idx)
4019 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4020 imux->items[idx].index);
4024 EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
4028 * snd_hda_enum_helper_info - Helper for simple enum ctls
4029 * @kcontrol: ctl element
4030 * @uinfo: pointer to get/store the data
4031 * @num_items: number of enum items
4032 * @texts: enum item string array
4034 * process kcontrol info callback of a simple string enum array
4035 * when @num_items is 0 or @texts is NULL, assume a boolean enum array
4037 int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
4038 struct snd_ctl_elem_info *uinfo,
4039 int num_items, const char * const *texts)
4041 static const char * const texts_default[] = {
4042 "Disabled", "Enabled"
4045 if (!texts || !num_items) {
4047 texts = texts_default;
4050 return snd_ctl_enum_info(uinfo, 1, num_items, texts);
4052 EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info);
4055 * Multi-channel / digital-out PCM helper functions
4058 /* setup SPDIF output stream */
4059 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4060 unsigned int stream_tag, unsigned int format)
4062 struct hda_spdif_out *spdif;
4063 unsigned int curr_fmt;
4066 spdif = snd_hda_spdif_out_of_nid(codec, nid);
4067 curr_fmt = snd_hda_codec_read(codec, nid, 0,
4068 AC_VERB_GET_STREAM_FORMAT, 0);
4069 reset = codec->spdif_status_reset &&
4070 (spdif->ctls & AC_DIG1_ENABLE) &&
4073 /* turn off SPDIF if needed; otherwise the IEC958 bits won't be
4076 set_dig_out_convert(codec, nid,
4077 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
4079 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4080 if (codec->slave_dig_outs) {
4082 for (d = codec->slave_dig_outs; *d; d++)
4083 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4086 /* turn on again (if needed) */
4088 set_dig_out_convert(codec, nid,
4089 spdif->ctls & 0xff, -1);
4092 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4094 snd_hda_codec_cleanup_stream(codec, nid);
4095 if (codec->slave_dig_outs) {
4097 for (d = codec->slave_dig_outs; *d; d++)
4098 snd_hda_codec_cleanup_stream(codec, *d);
4103 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4104 * @codec: the HDA codec
4105 * @mout: hda_multi_out object
4107 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4108 struct hda_multi_out *mout)
4110 mutex_lock(&codec->spdif_mutex);
4111 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4112 /* already opened as analog dup; reset it once */
4113 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4114 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4115 mutex_unlock(&codec->spdif_mutex);
4118 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
4121 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4122 * @codec: the HDA codec
4123 * @mout: hda_multi_out object
4124 * @stream_tag: stream tag to assign
4125 * @format: format id to assign
4126 * @substream: PCM substream to assign
4128 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4129 struct hda_multi_out *mout,
4130 unsigned int stream_tag,
4131 unsigned int format,
4132 struct snd_pcm_substream *substream)
4134 mutex_lock(&codec->spdif_mutex);
4135 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4136 mutex_unlock(&codec->spdif_mutex);
4139 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
4142 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4143 * @codec: the HDA codec
4144 * @mout: hda_multi_out object
4146 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4147 struct hda_multi_out *mout)
4149 mutex_lock(&codec->spdif_mutex);
4150 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4151 mutex_unlock(&codec->spdif_mutex);
4154 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
4157 * snd_hda_multi_out_dig_close - release the digital out stream
4158 * @codec: the HDA codec
4159 * @mout: hda_multi_out object
4161 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4162 struct hda_multi_out *mout)
4164 mutex_lock(&codec->spdif_mutex);
4165 mout->dig_out_used = 0;
4166 mutex_unlock(&codec->spdif_mutex);
4169 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
4172 * snd_hda_multi_out_analog_open - open analog outputs
4173 * @codec: the HDA codec
4174 * @mout: hda_multi_out object
4175 * @substream: PCM substream to assign
4176 * @hinfo: PCM information to assign
4178 * Open analog outputs and set up the hw-constraints.
4179 * If the digital outputs can be opened as slave, open the digital
4182 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4183 struct hda_multi_out *mout,
4184 struct snd_pcm_substream *substream,
4185 struct hda_pcm_stream *hinfo)
4187 struct snd_pcm_runtime *runtime = substream->runtime;
4188 runtime->hw.channels_max = mout->max_channels;
4189 if (mout->dig_out_nid) {
4190 if (!mout->analog_rates) {
4191 mout->analog_rates = hinfo->rates;
4192 mout->analog_formats = hinfo->formats;
4193 mout->analog_maxbps = hinfo->maxbps;
4195 runtime->hw.rates = mout->analog_rates;
4196 runtime->hw.formats = mout->analog_formats;
4197 hinfo->maxbps = mout->analog_maxbps;
4199 if (!mout->spdif_rates) {
4200 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4202 &mout->spdif_formats,
4203 &mout->spdif_maxbps);
4205 mutex_lock(&codec->spdif_mutex);
4206 if (mout->share_spdif) {
4207 if ((runtime->hw.rates & mout->spdif_rates) &&
4208 (runtime->hw.formats & mout->spdif_formats)) {
4209 runtime->hw.rates &= mout->spdif_rates;
4210 runtime->hw.formats &= mout->spdif_formats;
4211 if (mout->spdif_maxbps < hinfo->maxbps)
4212 hinfo->maxbps = mout->spdif_maxbps;
4214 mout->share_spdif = 0;
4215 /* FIXME: need notify? */
4218 mutex_unlock(&codec->spdif_mutex);
4220 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4221 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4223 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
4226 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4227 * @codec: the HDA codec
4228 * @mout: hda_multi_out object
4229 * @stream_tag: stream tag to assign
4230 * @format: format id to assign
4231 * @substream: PCM substream to assign
4233 * Set up the i/o for analog out.
4234 * When the digital out is available, copy the front out to digital out, too.
4236 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4237 struct hda_multi_out *mout,
4238 unsigned int stream_tag,
4239 unsigned int format,
4240 struct snd_pcm_substream *substream)
4242 const hda_nid_t *nids = mout->dac_nids;
4243 int chs = substream->runtime->channels;
4244 struct hda_spdif_out *spdif;
4247 mutex_lock(&codec->spdif_mutex);
4248 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
4249 if (mout->dig_out_nid && mout->share_spdif &&
4250 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4252 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4254 !(spdif->status & IEC958_AES0_NONAUDIO)) {
4255 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4256 setup_dig_out_stream(codec, mout->dig_out_nid,
4257 stream_tag, format);
4259 mout->dig_out_used = 0;
4260 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4263 mutex_unlock(&codec->spdif_mutex);
4266 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4268 if (!mout->no_share_stream &&
4269 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4270 /* headphone out will just decode front left/right (stereo) */
4271 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4273 /* extra outputs copied from front */
4274 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4275 if (!mout->no_share_stream && mout->hp_out_nid[i])
4276 snd_hda_codec_setup_stream(codec,
4277 mout->hp_out_nid[i],
4278 stream_tag, 0, format);
4281 for (i = 1; i < mout->num_dacs; i++) {
4282 if (chs >= (i + 1) * 2) /* independent out */
4283 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4285 else if (!mout->no_share_stream) /* copy front */
4286 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4290 /* extra surrounds */
4291 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) {
4293 if (!mout->extra_out_nid[i])
4295 if (chs >= (i + 1) * 2)
4297 else if (!mout->no_share_stream)
4299 snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i],
4300 stream_tag, ch, format);
4305 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
4308 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4309 * @codec: the HDA codec
4310 * @mout: hda_multi_out object
4312 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4313 struct hda_multi_out *mout)
4315 const hda_nid_t *nids = mout->dac_nids;
4318 for (i = 0; i < mout->num_dacs; i++)
4319 snd_hda_codec_cleanup_stream(codec, nids[i]);
4321 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4322 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4323 if (mout->hp_out_nid[i])
4324 snd_hda_codec_cleanup_stream(codec,
4325 mout->hp_out_nid[i]);
4326 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4327 if (mout->extra_out_nid[i])
4328 snd_hda_codec_cleanup_stream(codec,
4329 mout->extra_out_nid[i]);
4330 mutex_lock(&codec->spdif_mutex);
4331 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4332 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4333 mout->dig_out_used = 0;
4335 mutex_unlock(&codec->spdif_mutex);
4338 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
4341 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
4342 * @codec: the HDA codec
4343 * @pin: referred pin NID
4345 * Guess the suitable VREF pin bits to be set as the pin-control value.
4346 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
4348 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
4350 unsigned int pincap;
4351 unsigned int oldval;
4352 oldval = snd_hda_codec_read(codec, pin, 0,
4353 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4354 pincap = snd_hda_query_pin_caps(codec, pin);
4355 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
4356 /* Exception: if the default pin setup is vref50, we give it priority */
4357 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
4358 return AC_PINCTL_VREF_80;
4359 else if (pincap & AC_PINCAP_VREF_50)
4360 return AC_PINCTL_VREF_50;
4361 else if (pincap & AC_PINCAP_VREF_100)
4362 return AC_PINCTL_VREF_100;
4363 else if (pincap & AC_PINCAP_VREF_GRD)
4364 return AC_PINCTL_VREF_GRD;
4365 return AC_PINCTL_VREF_HIZ;
4367 EXPORT_SYMBOL_GPL(snd_hda_get_default_vref);
4370 * snd_hda_correct_pin_ctl - correct the pin ctl value for matching with the pin cap
4371 * @codec: the HDA codec
4372 * @pin: referred pin NID
4373 * @val: pin ctl value to audit
4375 unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
4376 hda_nid_t pin, unsigned int val)
4378 static unsigned int cap_lists[][2] = {
4379 { AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
4380 { AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
4381 { AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
4382 { AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
4388 cap = snd_hda_query_pin_caps(codec, pin);
4390 return val; /* don't know what to do... */
4392 if (val & AC_PINCTL_OUT_EN) {
4393 if (!(cap & AC_PINCAP_OUT))
4394 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
4395 else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
4396 val &= ~AC_PINCTL_HP_EN;
4399 if (val & AC_PINCTL_IN_EN) {
4400 if (!(cap & AC_PINCAP_IN))
4401 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
4403 unsigned int vcap, vref;
4405 vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
4406 vref = val & AC_PINCTL_VREFEN;
4407 for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
4408 if (vref == cap_lists[i][0] &&
4409 !(vcap & cap_lists[i][1])) {
4410 if (i == ARRAY_SIZE(cap_lists) - 1)
4411 vref = AC_PINCTL_VREF_HIZ;
4413 vref = cap_lists[i + 1][0];
4416 val &= ~AC_PINCTL_VREFEN;
4423 EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl);
4426 * _snd_hda_pin_ctl - Helper to set pin ctl value
4427 * @codec: the HDA codec
4428 * @pin: referred pin NID
4429 * @val: pin control value to set
4430 * @cached: access over codec pinctl cache or direct write
4432 * This function is a helper to set a pin ctl value more safely.
4433 * It corrects the pin ctl value via snd_hda_correct_pin_ctl(), stores the
4434 * value in pin target array via snd_hda_codec_set_pin_target(), then
4435 * actually writes the value via either snd_hda_codec_update_cache() or
4436 * snd_hda_codec_write() depending on @cached flag.
4438 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
4439 unsigned int val, bool cached)
4441 val = snd_hda_correct_pin_ctl(codec, pin, val);
4442 snd_hda_codec_set_pin_target(codec, pin, val);
4444 return snd_hda_codec_update_cache(codec, pin, 0,
4445 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4447 return snd_hda_codec_write(codec, pin, 0,
4448 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4450 EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl);
4453 * snd_hda_add_imux_item - Add an item to input_mux
4454 * @codec: the HDA codec
4455 * @imux: imux helper object
4456 * @label: the name of imux item to assign
4457 * @index: index number of imux item to assign
4458 * @type_idx: pointer to store the resultant label index
4460 * When the same label is used already in the existing items, the number
4461 * suffix is appended to the label. This label index number is stored
4462 * to type_idx when non-NULL pointer is given.
4464 int snd_hda_add_imux_item(struct hda_codec *codec,
4465 struct hda_input_mux *imux, const char *label,
4466 int index, int *type_idx)
4468 int i, label_idx = 0;
4469 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
4470 codec_err(codec, "hda_codec: Too many imux items!\n");
4473 for (i = 0; i < imux->num_items; i++) {
4474 if (!strncmp(label, imux->items[i].label, strlen(label)))
4478 *type_idx = label_idx;
4480 snprintf(imux->items[imux->num_items].label,
4481 sizeof(imux->items[imux->num_items].label),
4482 "%s %d", label, label_idx);
4484 strlcpy(imux->items[imux->num_items].label, label,
4485 sizeof(imux->items[imux->num_items].label));
4486 imux->items[imux->num_items].index = index;
4490 EXPORT_SYMBOL_GPL(snd_hda_add_imux_item);
4493 * snd_hda_bus_reset - Reset the bus
4494 * @bus: HD-audio bus
4496 void snd_hda_bus_reset(struct hda_bus *bus)
4498 struct hda_codec *codec;
4500 list_for_each_codec(codec, bus) {
4501 /* FIXME: maybe a better way needed for forced reset */
4502 cancel_delayed_work_sync(&codec->jackpoll_work);
4504 if (hda_codec_is_power_on(codec)) {
4505 hda_call_codec_suspend(codec);
4506 hda_call_codec_resume(codec);
4511 EXPORT_SYMBOL_GPL(snd_hda_bus_reset);
4514 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4515 * @pcm: PCM caps bits
4516 * @buf: the string buffer to write
4517 * @buflen: the max buffer length
4519 * used by hda_proc.c and hda_eld.c
4521 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4523 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
4526 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4527 if (pcm & (AC_SUPPCM_BITS_8 << i))
4528 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
4530 buf[j] = '\0'; /* necessary when j == 0 */
4532 EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
4534 MODULE_DESCRIPTION("HDA codec core");
4535 MODULE_LICENSE("GPL");