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/pci.h>
27 #include <linux/mutex.h>
28 #include <linux/module.h>
29 #include <sound/core.h>
30 #include "hda_codec.h"
31 #include <sound/asoundef.h>
32 #include <sound/tlv.h>
33 #include <sound/initval.h>
34 #include <sound/jack.h>
35 #include "hda_local.h"
38 #include <sound/hda_hwdep.h>
40 #define CREATE_TRACE_POINTS
41 #include "hda_trace.h"
44 * vendor / preset table
47 struct hda_vendor_id {
52 /* codec vendor labels */
53 static struct hda_vendor_id hda_vendor_ids[] = {
55 { 0x1013, "Cirrus Logic" },
56 { 0x1057, "Motorola" },
57 { 0x1095, "Silicon Image" },
59 { 0x10ec, "Realtek" },
60 { 0x1102, "Creative" },
64 { 0x11d4, "Analog Devices" },
65 { 0x13f6, "C-Media" },
66 { 0x14f1, "Conexant" },
67 { 0x17e8, "Chrontel" },
69 { 0x1aec, "Wolfson Microelectronics" },
70 { 0x434d, "C-Media" },
72 { 0x8384, "SigmaTel" },
76 static DEFINE_MUTEX(preset_mutex);
77 static LIST_HEAD(hda_preset_tables);
79 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
81 mutex_lock(&preset_mutex);
82 list_add_tail(&preset->list, &hda_preset_tables);
83 mutex_unlock(&preset_mutex);
86 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
88 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
90 mutex_lock(&preset_mutex);
91 list_del(&preset->list);
92 mutex_unlock(&preset_mutex);
95 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
97 #ifdef CONFIG_SND_HDA_POWER_SAVE
98 static void hda_power_work(struct work_struct *work);
99 static void hda_keep_power_on(struct hda_codec *codec);
100 #define hda_codec_is_power_on(codec) ((codec)->power_on)
102 static inline void hda_keep_power_on(struct hda_codec *codec) {}
103 #define hda_codec_is_power_on(codec) 1
107 * snd_hda_get_jack_location - Give a location string of the jack
108 * @cfg: pin default config value
110 * Parse the pin default config value and returns the string of the
111 * jack location, e.g. "Rear", "Front", etc.
113 const char *snd_hda_get_jack_location(u32 cfg)
115 static char *bases[7] = {
116 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
118 static unsigned char specials_idx[] = {
123 static char *specials[] = {
124 "Rear Panel", "Drive Bar",
125 "Riser", "HDMI", "ATAPI",
126 "Mobile-In", "Mobile-Out"
129 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
130 if ((cfg & 0x0f) < 7)
131 return bases[cfg & 0x0f];
132 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
133 if (cfg == specials_idx[i])
138 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
141 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
142 * @cfg: pin default config value
144 * Parse the pin default config value and returns the string of the
145 * jack connectivity, i.e. external or internal connection.
147 const char *snd_hda_get_jack_connectivity(u32 cfg)
149 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
151 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
153 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
156 * snd_hda_get_jack_type - Give a type string of the jack
157 * @cfg: pin default config value
159 * Parse the pin default config value and returns the string of the
160 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
162 const char *snd_hda_get_jack_type(u32 cfg)
164 static char *jack_types[16] = {
165 "Line Out", "Speaker", "HP Out", "CD",
166 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
167 "Line In", "Aux", "Mic", "Telephony",
168 "SPDIF In", "Digitial In", "Reserved", "Other"
171 return jack_types[(cfg & AC_DEFCFG_DEVICE)
172 >> AC_DEFCFG_DEVICE_SHIFT];
174 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
177 * Compose a 32bit command word to be sent to the HD-audio controller
179 static inline unsigned int
180 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
181 unsigned int verb, unsigned int parm)
185 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
186 (verb & ~0xfff) || (parm & ~0xffff)) {
187 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
188 codec->addr, direct, nid, verb, parm);
192 val = (u32)codec->addr << 28;
193 val |= (u32)direct << 27;
194 val |= (u32)nid << 20;
201 * Send and receive a verb
203 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
206 struct hda_bus *bus = codec->bus;
215 snd_hda_power_up(codec);
216 mutex_lock(&bus->cmd_mutex);
217 trace_hda_send_cmd(codec, cmd);
218 err = bus->ops.command(bus, cmd);
220 *res = bus->ops.get_response(bus, codec->addr);
221 trace_hda_get_response(codec, *res);
223 mutex_unlock(&bus->cmd_mutex);
224 snd_hda_power_down(codec);
225 if (res && *res == -1 && bus->rirb_error) {
226 if (bus->response_reset) {
227 snd_printd("hda_codec: resetting BUS due to "
228 "fatal communication error\n");
229 trace_hda_bus_reset(bus);
230 bus->ops.bus_reset(bus);
234 /* clear reset-flag when the communication gets recovered */
236 bus->response_reset = 0;
241 * snd_hda_codec_read - send a command and get the response
242 * @codec: the HDA codec
243 * @nid: NID to send the command
244 * @direct: direct flag
245 * @verb: the verb to send
246 * @parm: the parameter for the verb
248 * Send a single command and read the corresponding response.
250 * Returns the obtained response value, or -1 for an error.
252 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
254 unsigned int verb, unsigned int parm)
256 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
258 if (codec_exec_verb(codec, cmd, &res))
262 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
265 * snd_hda_codec_write - send a single command without waiting for response
266 * @codec: the HDA codec
267 * @nid: NID to send the command
268 * @direct: direct flag
269 * @verb: the verb to send
270 * @parm: the parameter for the verb
272 * Send a single command without waiting for response.
274 * Returns 0 if successful, or a negative error code.
276 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
277 unsigned int verb, unsigned int parm)
279 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
281 return codec_exec_verb(codec, cmd,
282 codec->bus->sync_write ? &res : NULL);
284 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
287 * snd_hda_sequence_write - sequence writes
288 * @codec: the HDA codec
289 * @seq: VERB array to send
291 * Send the commands sequentially from the given array.
292 * The array must be terminated with NID=0.
294 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
296 for (; seq->nid; seq++)
297 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
299 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
302 * snd_hda_get_sub_nodes - get the range of sub nodes
303 * @codec: the HDA codec
305 * @start_id: the pointer to store the start NID
307 * Parse the NID and store the start NID of its sub-nodes.
308 * Returns the number of sub-nodes.
310 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
315 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
318 *start_id = (parm >> 16) & 0x7fff;
319 return (int)(parm & 0x7fff);
321 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
323 /* look up the cached results */
324 static hda_nid_t *lookup_conn_list(struct snd_array *array, hda_nid_t nid)
327 for (i = 0; i < array->used; ) {
328 hda_nid_t *p = snd_array_elem(array, i);
337 /* read the connection and add to the cache */
338 static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
340 hda_nid_t list[HDA_MAX_CONNECTIONS];
343 len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
346 return snd_hda_override_conn_list(codec, nid, len, list);
350 * snd_hda_get_connections - copy connection list
351 * @codec: the HDA codec
353 * @conn_list: connection list array; when NULL, checks only the size
354 * @max_conns: max. number of connections to store
356 * Parses the connection list of the given widget and stores the list
359 * Returns the number of connections, or a negative error code.
361 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
362 hda_nid_t *conn_list, int max_conns)
364 struct snd_array *array = &codec->conn_lists;
370 mutex_lock(&codec->hash_mutex);
372 /* if the connection-list is already cached, read it */
373 p = lookup_conn_list(array, nid);
376 if (conn_list && len > max_conns) {
377 snd_printk(KERN_ERR "hda_codec: "
378 "Too many connections %d for NID 0x%x\n",
380 mutex_unlock(&codec->hash_mutex);
383 if (conn_list && len)
384 memcpy(conn_list, p + 2, len * sizeof(hda_nid_t));
386 mutex_unlock(&codec->hash_mutex);
389 if (snd_BUG_ON(added))
392 len = read_and_add_raw_conns(codec, nid);
398 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
401 * snd_hda_get_raw_connections - copy connection list without cache
402 * @codec: the HDA codec
404 * @conn_list: connection list array
405 * @max_conns: max. number of connections to store
407 * Like snd_hda_get_connections(), copy the connection list but without
408 * checking through the connection-list cache.
409 * Currently called only from hda_proc.c, so not exported.
411 int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
412 hda_nid_t *conn_list, int max_conns)
415 int i, conn_len, conns;
416 unsigned int shift, num_elems, mask;
420 if (snd_BUG_ON(!conn_list || max_conns <= 0))
423 wcaps = get_wcaps(codec, nid);
424 if (!(wcaps & AC_WCAP_CONN_LIST) &&
425 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
428 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
429 if (parm & AC_CLIST_LONG) {
438 conn_len = parm & AC_CLIST_LENGTH;
439 mask = (1 << (shift-1)) - 1;
442 return 0; /* no connection */
445 /* single connection */
446 parm = snd_hda_codec_read(codec, nid, 0,
447 AC_VERB_GET_CONNECT_LIST, 0);
448 if (parm == -1 && codec->bus->rirb_error)
450 conn_list[0] = parm & mask;
454 /* multi connection */
457 for (i = 0; i < conn_len; i++) {
461 if (i % num_elems == 0) {
462 parm = snd_hda_codec_read(codec, nid, 0,
463 AC_VERB_GET_CONNECT_LIST, i);
464 if (parm == -1 && codec->bus->rirb_error)
467 range_val = !!(parm & (1 << (shift-1))); /* ranges */
470 snd_printk(KERN_WARNING "hda_codec: "
471 "invalid CONNECT_LIST verb %x[%i]:%x\n",
477 /* ranges between the previous and this one */
478 if (!prev_nid || prev_nid >= val) {
479 snd_printk(KERN_WARNING "hda_codec: "
480 "invalid dep_range_val %x:%x\n",
484 for (n = prev_nid + 1; n <= val; n++) {
485 if (conns >= max_conns) {
486 snd_printk(KERN_ERR "hda_codec: "
487 "Too many connections %d for NID 0x%x\n",
491 conn_list[conns++] = n;
494 if (conns >= max_conns) {
495 snd_printk(KERN_ERR "hda_codec: "
496 "Too many connections %d for NID 0x%x\n",
500 conn_list[conns++] = val;
507 static bool add_conn_list(struct snd_array *array, hda_nid_t nid)
509 hda_nid_t *p = snd_array_new(array);
517 * snd_hda_override_conn_list - add/modify the connection-list to cache
518 * @codec: the HDA codec
520 * @len: number of connection list entries
521 * @list: the list of connection entries
523 * Add or modify the given connection-list to the cache. If the corresponding
524 * cache already exists, invalidate it and append a new one.
526 * Returns zero or a negative error code.
528 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
529 const hda_nid_t *list)
531 struct snd_array *array = &codec->conn_lists;
535 mutex_lock(&codec->hash_mutex);
536 p = lookup_conn_list(array, nid);
538 *p = -1; /* invalidate the old entry */
540 old_used = array->used;
541 if (!add_conn_list(array, nid) || !add_conn_list(array, len))
543 for (i = 0; i < len; i++)
544 if (!add_conn_list(array, list[i]))
546 mutex_unlock(&codec->hash_mutex);
550 array->used = old_used;
551 mutex_unlock(&codec->hash_mutex);
554 EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
557 * snd_hda_get_conn_index - get the connection index of the given NID
558 * @codec: the HDA codec
559 * @mux: NID containing the list
560 * @nid: NID to select
561 * @recursive: 1 when searching NID recursively, otherwise 0
563 * Parses the connection list of the widget @mux and checks whether the
564 * widget @nid is present. If it is, return the connection index.
565 * Otherwise it returns -1.
567 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
568 hda_nid_t nid, int recursive)
570 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
573 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
574 for (i = 0; i < nums; i++)
580 snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
584 for (i = 0; i < nums; i++) {
585 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
586 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
588 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
593 EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
596 * snd_hda_queue_unsol_event - add an unsolicited event to queue
598 * @res: unsolicited event (lower 32bit of RIRB entry)
599 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
601 * Adds the given event to the queue. The events are processed in
602 * the workqueue asynchronously. Call this function in the interrupt
603 * hanlder when RIRB receives an unsolicited event.
605 * Returns 0 if successful, or a negative error code.
607 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
609 struct hda_bus_unsolicited *unsol;
612 trace_hda_unsol_event(bus, res, res_ex);
617 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
621 unsol->queue[wp] = res;
622 unsol->queue[wp + 1] = res_ex;
624 queue_work(bus->workq, &unsol->work);
628 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
631 * process queued unsolicited events
633 static void process_unsol_events(struct work_struct *work)
635 struct hda_bus_unsolicited *unsol =
636 container_of(work, struct hda_bus_unsolicited, work);
637 struct hda_bus *bus = unsol->bus;
638 struct hda_codec *codec;
639 unsigned int rp, caddr, res;
641 while (unsol->rp != unsol->wp) {
642 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
645 res = unsol->queue[rp];
646 caddr = unsol->queue[rp + 1];
647 if (!(caddr & (1 << 4))) /* no unsolicited event? */
649 codec = bus->caddr_tbl[caddr & 0x0f];
650 if (codec && codec->patch_ops.unsol_event)
651 codec->patch_ops.unsol_event(codec, res);
656 * initialize unsolicited queue
658 static int init_unsol_queue(struct hda_bus *bus)
660 struct hda_bus_unsolicited *unsol;
662 if (bus->unsol) /* already initialized */
665 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
667 snd_printk(KERN_ERR "hda_codec: "
668 "can't allocate unsolicited queue\n");
671 INIT_WORK(&unsol->work, process_unsol_events);
680 static void snd_hda_codec_free(struct hda_codec *codec);
682 static int snd_hda_bus_free(struct hda_bus *bus)
684 struct hda_codec *codec, *n;
689 flush_workqueue(bus->workq);
692 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
693 snd_hda_codec_free(codec);
695 if (bus->ops.private_free)
696 bus->ops.private_free(bus);
698 destroy_workqueue(bus->workq);
703 static int snd_hda_bus_dev_free(struct snd_device *device)
705 struct hda_bus *bus = device->device_data;
707 return snd_hda_bus_free(bus);
710 #ifdef CONFIG_SND_HDA_HWDEP
711 static int snd_hda_bus_dev_register(struct snd_device *device)
713 struct hda_bus *bus = device->device_data;
714 struct hda_codec *codec;
715 list_for_each_entry(codec, &bus->codec_list, list) {
716 snd_hda_hwdep_add_sysfs(codec);
717 snd_hda_hwdep_add_power_sysfs(codec);
722 #define snd_hda_bus_dev_register NULL
726 * snd_hda_bus_new - create a HDA bus
727 * @card: the card entry
728 * @temp: the template for hda_bus information
729 * @busp: the pointer to store the created bus instance
731 * Returns 0 if successful, or a negative error code.
733 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
734 const struct hda_bus_template *temp,
735 struct hda_bus **busp)
739 static struct snd_device_ops dev_ops = {
740 .dev_register = snd_hda_bus_dev_register,
741 .dev_free = snd_hda_bus_dev_free,
744 if (snd_BUG_ON(!temp))
746 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
752 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
754 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
759 bus->private_data = temp->private_data;
760 bus->pci = temp->pci;
761 bus->modelname = temp->modelname;
762 bus->power_save = temp->power_save;
763 bus->ops = temp->ops;
765 mutex_init(&bus->cmd_mutex);
766 mutex_init(&bus->prepare_mutex);
767 INIT_LIST_HEAD(&bus->codec_list);
769 snprintf(bus->workq_name, sizeof(bus->workq_name),
770 "hd-audio%d", card->number);
771 bus->workq = create_singlethread_workqueue(bus->workq_name);
773 snd_printk(KERN_ERR "cannot create workqueue %s\n",
779 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
781 snd_hda_bus_free(bus);
788 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
790 #ifdef CONFIG_SND_HDA_GENERIC
791 #define is_generic_config(codec) \
792 (codec->modelname && !strcmp(codec->modelname, "generic"))
794 #define is_generic_config(codec) 0
798 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
800 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
804 * find a matching codec preset
806 static const struct hda_codec_preset *
807 find_codec_preset(struct hda_codec *codec)
809 struct hda_codec_preset_list *tbl;
810 const struct hda_codec_preset *preset;
811 int mod_requested = 0;
813 if (is_generic_config(codec))
814 return NULL; /* use the generic parser */
817 mutex_lock(&preset_mutex);
818 list_for_each_entry(tbl, &hda_preset_tables, list) {
819 if (!try_module_get(tbl->owner)) {
820 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
823 for (preset = tbl->preset; preset->id; preset++) {
824 u32 mask = preset->mask;
825 if (preset->afg && preset->afg != codec->afg)
827 if (preset->mfg && preset->mfg != codec->mfg)
831 if (preset->id == (codec->vendor_id & mask) &&
833 preset->rev == codec->revision_id)) {
834 mutex_unlock(&preset_mutex);
835 codec->owner = tbl->owner;
839 module_put(tbl->owner);
841 mutex_unlock(&preset_mutex);
843 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
846 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
849 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
850 (codec->vendor_id >> 16) & 0xffff);
851 request_module(name);
859 * get_codec_name - store the codec name
861 static int get_codec_name(struct hda_codec *codec)
863 const struct hda_vendor_id *c;
864 const char *vendor = NULL;
865 u16 vendor_id = codec->vendor_id >> 16;
868 if (codec->vendor_name)
871 for (c = hda_vendor_ids; c->id; c++) {
872 if (c->id == vendor_id) {
878 sprintf(tmp, "Generic %04x", vendor_id);
881 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
882 if (!codec->vendor_name)
886 if (codec->chip_name)
889 if (codec->preset && codec->preset->name)
890 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
892 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
893 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
895 if (!codec->chip_name)
901 * look for an AFG and MFG nodes
903 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
905 int i, total_nodes, function_id;
908 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
909 for (i = 0; i < total_nodes; i++, nid++) {
910 function_id = snd_hda_param_read(codec, nid,
911 AC_PAR_FUNCTION_TYPE);
912 switch (function_id & 0xff) {
913 case AC_GRP_AUDIO_FUNCTION:
915 codec->afg_function_id = function_id & 0xff;
916 codec->afg_unsol = (function_id >> 8) & 1;
918 case AC_GRP_MODEM_FUNCTION:
920 codec->mfg_function_id = function_id & 0xff;
921 codec->mfg_unsol = (function_id >> 8) & 1;
930 * read widget caps for each widget and store in cache
932 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
937 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
939 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
942 nid = codec->start_nid;
943 for (i = 0; i < codec->num_nodes; i++, nid++)
944 codec->wcaps[i] = snd_hda_param_read(codec, nid,
945 AC_PAR_AUDIO_WIDGET_CAP);
949 /* read all pin default configurations and save codec->init_pins */
950 static int read_pin_defaults(struct hda_codec *codec)
953 hda_nid_t nid = codec->start_nid;
955 for (i = 0; i < codec->num_nodes; i++, nid++) {
956 struct hda_pincfg *pin;
957 unsigned int wcaps = get_wcaps(codec, nid);
958 unsigned int wid_type = get_wcaps_type(wcaps);
959 if (wid_type != AC_WID_PIN)
961 pin = snd_array_new(&codec->init_pins);
965 pin->cfg = snd_hda_codec_read(codec, nid, 0,
966 AC_VERB_GET_CONFIG_DEFAULT, 0);
967 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
968 AC_VERB_GET_PIN_WIDGET_CONTROL,
974 /* look up the given pin config list and return the item matching with NID */
975 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
976 struct snd_array *array,
980 for (i = 0; i < array->used; i++) {
981 struct hda_pincfg *pin = snd_array_elem(array, i);
988 /* write a config value for the given NID */
989 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
993 for (i = 0; i < 4; i++) {
994 snd_hda_codec_write(codec, nid, 0,
995 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1001 /* set the current pin config value for the given NID.
1002 * the value is cached, and read via snd_hda_codec_get_pincfg()
1004 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1005 hda_nid_t nid, unsigned int cfg)
1007 struct hda_pincfg *pin;
1008 unsigned int oldcfg;
1010 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1013 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
1014 pin = look_up_pincfg(codec, list, nid);
1016 pin = snd_array_new(list);
1023 /* change only when needed; e.g. if the pincfg is already present
1024 * in user_pins[], don't write it
1026 cfg = snd_hda_codec_get_pincfg(codec, nid);
1028 set_pincfg(codec, nid, cfg);
1033 * snd_hda_codec_set_pincfg - Override a pin default configuration
1034 * @codec: the HDA codec
1035 * @nid: NID to set the pin config
1036 * @cfg: the pin default config value
1038 * Override a pin default configuration value in the cache.
1039 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1040 * priority than the real hardware value.
1042 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1043 hda_nid_t nid, unsigned int cfg)
1045 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
1047 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
1050 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1051 * @codec: the HDA codec
1052 * @nid: NID to get the pin config
1054 * Get the current pin config value of the given pin NID.
1055 * If the pincfg value is cached or overridden via sysfs or driver,
1056 * returns the cached value.
1058 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1060 struct hda_pincfg *pin;
1062 #ifdef CONFIG_SND_HDA_HWDEP
1063 pin = look_up_pincfg(codec, &codec->user_pins, nid);
1067 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1070 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1075 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
1077 /* restore all current pin configs */
1078 static void restore_pincfgs(struct hda_codec *codec)
1081 for (i = 0; i < codec->init_pins.used; i++) {
1082 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1083 set_pincfg(codec, pin->nid,
1084 snd_hda_codec_get_pincfg(codec, pin->nid));
1089 * snd_hda_shutup_pins - Shut up all pins
1090 * @codec: the HDA codec
1092 * Clear all pin controls to shup up before suspend for avoiding click noise.
1093 * The controls aren't cached so that they can be resumed properly.
1095 void snd_hda_shutup_pins(struct hda_codec *codec)
1098 /* don't shut up pins when unloading the driver; otherwise it breaks
1099 * the default pin setup at the next load of the driver
1101 if (codec->bus->shutdown)
1103 for (i = 0; i < codec->init_pins.used; i++) {
1104 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1105 /* use read here for syncing after issuing each verb */
1106 snd_hda_codec_read(codec, pin->nid, 0,
1107 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1109 codec->pins_shutup = 1;
1111 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
1114 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1115 static void restore_shutup_pins(struct hda_codec *codec)
1118 if (!codec->pins_shutup)
1120 if (codec->bus->shutdown)
1122 for (i = 0; i < codec->init_pins.used; i++) {
1123 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1124 snd_hda_codec_write(codec, pin->nid, 0,
1125 AC_VERB_SET_PIN_WIDGET_CONTROL,
1128 codec->pins_shutup = 0;
1132 static void init_hda_cache(struct hda_cache_rec *cache,
1133 unsigned int record_size);
1134 static void free_hda_cache(struct hda_cache_rec *cache);
1136 /* restore the initial pin cfgs and release all pincfg lists */
1137 static void restore_init_pincfgs(struct hda_codec *codec)
1139 /* first free driver_pins and user_pins, then call restore_pincfg
1140 * so that only the values in init_pins are restored
1142 snd_array_free(&codec->driver_pins);
1143 #ifdef CONFIG_SND_HDA_HWDEP
1144 snd_array_free(&codec->user_pins);
1146 restore_pincfgs(codec);
1147 snd_array_free(&codec->init_pins);
1151 * audio-converter setup caches
1153 struct hda_cvt_setup {
1158 unsigned char active; /* cvt is currently used */
1159 unsigned char dirty; /* setups should be cleared */
1162 /* get or create a cache entry for the given audio converter NID */
1163 static struct hda_cvt_setup *
1164 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1166 struct hda_cvt_setup *p;
1169 for (i = 0; i < codec->cvt_setups.used; i++) {
1170 p = snd_array_elem(&codec->cvt_setups, i);
1174 p = snd_array_new(&codec->cvt_setups);
1183 static void snd_hda_codec_free(struct hda_codec *codec)
1187 snd_hda_jack_tbl_clear(codec);
1188 restore_init_pincfgs(codec);
1189 #ifdef CONFIG_SND_HDA_POWER_SAVE
1190 cancel_delayed_work(&codec->power_work);
1191 flush_workqueue(codec->bus->workq);
1193 list_del(&codec->list);
1194 snd_array_free(&codec->mixers);
1195 snd_array_free(&codec->nids);
1196 snd_array_free(&codec->cvt_setups);
1197 snd_array_free(&codec->conn_lists);
1198 snd_array_free(&codec->spdif_out);
1199 codec->bus->caddr_tbl[codec->addr] = NULL;
1200 if (codec->patch_ops.free)
1201 codec->patch_ops.free(codec);
1202 module_put(codec->owner);
1203 free_hda_cache(&codec->amp_cache);
1204 free_hda_cache(&codec->cmd_cache);
1205 kfree(codec->vendor_name);
1206 kfree(codec->chip_name);
1207 kfree(codec->modelname);
1208 kfree(codec->wcaps);
1212 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1213 unsigned int power_state);
1216 * snd_hda_codec_new - create a HDA codec
1217 * @bus: the bus to assign
1218 * @codec_addr: the codec address
1219 * @codecp: the pointer to store the generated codec
1221 * Returns 0 if successful, or a negative error code.
1223 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
1224 unsigned int codec_addr,
1225 struct hda_codec **codecp)
1227 struct hda_codec *codec;
1231 if (snd_BUG_ON(!bus))
1233 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1236 if (bus->caddr_tbl[codec_addr]) {
1237 snd_printk(KERN_ERR "hda_codec: "
1238 "address 0x%x is already occupied\n", codec_addr);
1242 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1243 if (codec == NULL) {
1244 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1249 codec->addr = codec_addr;
1250 mutex_init(&codec->spdif_mutex);
1251 mutex_init(&codec->control_mutex);
1252 mutex_init(&codec->hash_mutex);
1253 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1254 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1255 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1256 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1257 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1258 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1259 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1260 snd_array_init(&codec->conn_lists, sizeof(hda_nid_t), 64);
1261 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1263 #ifdef CONFIG_SND_HDA_POWER_SAVE
1264 spin_lock_init(&codec->power_lock);
1265 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1266 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1267 * the caller has to power down appropriatley after initialization
1270 hda_keep_power_on(codec);
1273 if (codec->bus->modelname) {
1274 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1275 if (!codec->modelname) {
1276 snd_hda_codec_free(codec);
1281 list_add_tail(&codec->list, &bus->codec_list);
1282 bus->caddr_tbl[codec_addr] = codec;
1284 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1286 if (codec->vendor_id == -1)
1287 /* read again, hopefully the access method was corrected
1288 * in the last read...
1290 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1292 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1293 AC_PAR_SUBSYSTEM_ID);
1294 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1297 setup_fg_nodes(codec);
1298 if (!codec->afg && !codec->mfg) {
1299 snd_printdd("hda_codec: no AFG or MFG node found\n");
1304 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1306 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1309 err = read_pin_defaults(codec);
1313 if (!codec->subsystem_id) {
1314 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
1315 codec->subsystem_id =
1316 snd_hda_codec_read(codec, nid, 0,
1317 AC_VERB_GET_SUBSYSTEM_ID, 0);
1320 /* power-up all before initialization */
1321 hda_set_power_state(codec,
1322 codec->afg ? codec->afg : codec->mfg,
1325 snd_hda_codec_proc_new(codec);
1327 snd_hda_create_hwdep(codec);
1329 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1330 codec->subsystem_id, codec->revision_id);
1331 snd_component_add(codec->bus->card, component);
1338 snd_hda_codec_free(codec);
1341 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1344 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1345 * @codec: the HDA codec
1347 * Start parsing of the given codec tree and (re-)initialize the whole
1350 * Returns 0 if successful or a negative error code.
1352 int snd_hda_codec_configure(struct hda_codec *codec)
1356 codec->preset = find_codec_preset(codec);
1357 if (!codec->vendor_name || !codec->chip_name) {
1358 err = get_codec_name(codec);
1363 if (is_generic_config(codec)) {
1364 err = snd_hda_parse_generic_codec(codec);
1367 if (codec->preset && codec->preset->patch) {
1368 err = codec->preset->patch(codec);
1372 /* call the default parser */
1373 err = snd_hda_parse_generic_codec(codec);
1375 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1378 if (!err && codec->patch_ops.unsol_event)
1379 err = init_unsol_queue(codec->bus);
1380 /* audio codec should override the mixer name */
1381 if (!err && (codec->afg || !*codec->bus->card->mixername))
1382 snprintf(codec->bus->card->mixername,
1383 sizeof(codec->bus->card->mixername),
1384 "%s %s", codec->vendor_name, codec->chip_name);
1387 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1390 * snd_hda_codec_setup_stream - set up the codec for streaming
1391 * @codec: the CODEC to set up
1392 * @nid: the NID to set up
1393 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1394 * @channel_id: channel id to pass, zero based.
1395 * @format: stream format.
1397 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1399 int channel_id, int format)
1401 struct hda_codec *c;
1402 struct hda_cvt_setup *p;
1403 unsigned int oldval, newval;
1410 snd_printdd("hda_codec_setup_stream: "
1411 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1412 nid, stream_tag, channel_id, format);
1413 p = get_hda_cvt_setup(codec, nid);
1416 /* update the stream-id if changed */
1417 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1418 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1419 newval = (stream_tag << 4) | channel_id;
1420 if (oldval != newval)
1421 snd_hda_codec_write(codec, nid, 0,
1422 AC_VERB_SET_CHANNEL_STREAMID,
1424 p->stream_tag = stream_tag;
1425 p->channel_id = channel_id;
1427 /* update the format-id if changed */
1428 if (p->format_id != format) {
1429 oldval = snd_hda_codec_read(codec, nid, 0,
1430 AC_VERB_GET_STREAM_FORMAT, 0);
1431 if (oldval != format) {
1433 snd_hda_codec_write(codec, nid, 0,
1434 AC_VERB_SET_STREAM_FORMAT,
1437 p->format_id = format;
1442 /* make other inactive cvts with the same stream-tag dirty */
1443 type = get_wcaps_type(get_wcaps(codec, nid));
1444 list_for_each_entry(c, &codec->bus->codec_list, list) {
1445 for (i = 0; i < c->cvt_setups.used; i++) {
1446 p = snd_array_elem(&c->cvt_setups, i);
1447 if (!p->active && p->stream_tag == stream_tag &&
1448 get_wcaps_type(get_wcaps(c, p->nid)) == type)
1453 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1455 static void really_cleanup_stream(struct hda_codec *codec,
1456 struct hda_cvt_setup *q);
1459 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1460 * @codec: the CODEC to clean up
1461 * @nid: the NID to clean up
1462 * @do_now: really clean up the stream instead of clearing the active flag
1464 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1467 struct hda_cvt_setup *p;
1472 if (codec->no_sticky_stream)
1475 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1476 p = get_hda_cvt_setup(codec, nid);
1478 /* here we just clear the active flag when do_now isn't set;
1479 * actual clean-ups will be done later in
1480 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1483 really_cleanup_stream(codec, p);
1488 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1490 static void really_cleanup_stream(struct hda_codec *codec,
1491 struct hda_cvt_setup *q)
1493 hda_nid_t nid = q->nid;
1494 if (q->stream_tag || q->channel_id)
1495 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1497 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1499 memset(q, 0, sizeof(*q));
1503 /* clean up the all conflicting obsolete streams */
1504 static void purify_inactive_streams(struct hda_codec *codec)
1506 struct hda_codec *c;
1509 list_for_each_entry(c, &codec->bus->codec_list, list) {
1510 for (i = 0; i < c->cvt_setups.used; i++) {
1511 struct hda_cvt_setup *p;
1512 p = snd_array_elem(&c->cvt_setups, i);
1514 really_cleanup_stream(c, p);
1520 /* clean up all streams; called from suspend */
1521 static void hda_cleanup_all_streams(struct hda_codec *codec)
1525 for (i = 0; i < codec->cvt_setups.used; i++) {
1526 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1528 really_cleanup_stream(codec, p);
1534 * amp access functions
1537 /* FIXME: more better hash key? */
1538 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1539 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1540 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1541 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1542 #define INFO_AMP_CAPS (1<<0)
1543 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1545 /* initialize the hash table */
1546 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1547 unsigned int record_size)
1549 memset(cache, 0, sizeof(*cache));
1550 memset(cache->hash, 0xff, sizeof(cache->hash));
1551 snd_array_init(&cache->buf, record_size, 64);
1554 static void free_hda_cache(struct hda_cache_rec *cache)
1556 snd_array_free(&cache->buf);
1559 /* query the hash. allocate an entry if not found. */
1560 static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1562 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1563 u16 cur = cache->hash[idx];
1564 struct hda_cache_head *info;
1566 while (cur != 0xffff) {
1567 info = snd_array_elem(&cache->buf, cur);
1568 if (info->key == key)
1575 /* query the hash. allocate an entry if not found. */
1576 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1579 struct hda_cache_head *info = get_hash(cache, key);
1582 /* add a new hash entry */
1583 info = snd_array_new(&cache->buf);
1586 cur = snd_array_index(&cache->buf, info);
1589 idx = key % (u16)ARRAY_SIZE(cache->hash);
1590 info->next = cache->hash[idx];
1591 cache->hash[idx] = cur;
1596 /* query and allocate an amp hash entry */
1597 static inline struct hda_amp_info *
1598 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1600 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1603 /* overwrite the value with the key in the caps hash */
1604 static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1606 struct hda_amp_info *info;
1608 mutex_lock(&codec->hash_mutex);
1609 info = get_alloc_amp_hash(codec, key);
1611 mutex_unlock(&codec->hash_mutex);
1614 info->amp_caps = val;
1615 info->head.val |= INFO_AMP_CAPS;
1616 mutex_unlock(&codec->hash_mutex);
1620 /* query the value from the caps hash; if not found, fetch the current
1621 * value from the given function and store in the hash
1624 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1625 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1627 struct hda_amp_info *info;
1630 mutex_lock(&codec->hash_mutex);
1631 info = get_alloc_amp_hash(codec, key);
1633 mutex_unlock(&codec->hash_mutex);
1636 if (!(info->head.val & INFO_AMP_CAPS)) {
1637 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1638 val = func(codec, nid, dir);
1639 write_caps_hash(codec, key, val);
1641 val = info->amp_caps;
1642 mutex_unlock(&codec->hash_mutex);
1647 static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1650 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1652 return snd_hda_param_read(codec, nid,
1653 direction == HDA_OUTPUT ?
1654 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1658 * query_amp_caps - query AMP capabilities
1659 * @codec: the HD-auio codec
1660 * @nid: the NID to query
1661 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1663 * Query AMP capabilities for the given widget and direction.
1664 * Returns the obtained capability bits.
1666 * When cap bits have been already read, this doesn't read again but
1667 * returns the cached value.
1669 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1671 return query_caps_hash(codec, nid, direction,
1672 HDA_HASH_KEY(nid, direction, 0),
1675 EXPORT_SYMBOL_HDA(query_amp_caps);
1678 * snd_hda_override_amp_caps - Override the AMP capabilities
1679 * @codec: the CODEC to clean up
1680 * @nid: the NID to clean up
1681 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1682 * @caps: the capability bits to set
1684 * Override the cached AMP caps bits value by the given one.
1685 * This function is useful if the driver needs to adjust the AMP ranges,
1686 * e.g. limit to 0dB, etc.
1688 * Returns zero if successful or a negative error code.
1690 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1693 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
1695 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1697 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1700 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1704 * snd_hda_query_pin_caps - Query PIN capabilities
1705 * @codec: the HD-auio codec
1706 * @nid: the NID to query
1708 * Query PIN capabilities for the given widget.
1709 * Returns the obtained capability bits.
1711 * When cap bits have been already read, this doesn't read again but
1712 * returns the cached value.
1714 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1716 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
1719 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1722 * snd_hda_override_pin_caps - Override the pin capabilities
1724 * @nid: the NID to override
1725 * @caps: the capability bits to set
1727 * Override the cached PIN capabilitiy bits value by the given one.
1729 * Returns zero if successful or a negative error code.
1731 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1734 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
1736 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1738 /* read or sync the hash value with the current value;
1739 * call within hash_mutex
1741 static struct hda_amp_info *
1742 update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
1743 int direction, int index)
1745 struct hda_amp_info *info;
1746 unsigned int parm, val = 0;
1747 bool val_read = false;
1750 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1753 if (!(info->head.val & INFO_AMP_VOL(ch))) {
1755 mutex_unlock(&codec->hash_mutex);
1756 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1757 parm |= direction == HDA_OUTPUT ?
1758 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1760 val = snd_hda_codec_read(codec, nid, 0,
1761 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1764 mutex_lock(&codec->hash_mutex);
1767 info->vol[ch] = val;
1768 info->head.val |= INFO_AMP_VOL(ch);
1774 * write the current volume in info to the h/w
1776 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1777 hda_nid_t nid, int ch, int direction, int index,
1782 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1783 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1784 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1785 if ((val & HDA_AMP_MUTE) && !(info->amp_caps & AC_AMPCAP_MUTE) &&
1786 (info->amp_caps & AC_AMPCAP_MIN_MUTE))
1787 ; /* set the zero value as a fake mute */
1790 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1794 * snd_hda_codec_amp_read - Read AMP value
1795 * @codec: HD-audio codec
1796 * @nid: NID to read the AMP value
1797 * @ch: channel (left=0 or right=1)
1798 * @direction: #HDA_INPUT or #HDA_OUTPUT
1799 * @index: the index value (only for input direction)
1801 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1803 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1804 int direction, int index)
1806 struct hda_amp_info *info;
1807 unsigned int val = 0;
1809 mutex_lock(&codec->hash_mutex);
1810 info = update_amp_hash(codec, nid, ch, direction, index);
1812 val = info->vol[ch];
1813 mutex_unlock(&codec->hash_mutex);
1816 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1819 * snd_hda_codec_amp_update - update the AMP value
1820 * @codec: HD-audio codec
1821 * @nid: NID to read the AMP value
1822 * @ch: channel (left=0 or right=1)
1823 * @direction: #HDA_INPUT or #HDA_OUTPUT
1824 * @idx: the index value (only for input direction)
1825 * @mask: bit mask to set
1826 * @val: the bits value to set
1828 * Update the AMP value with a bit mask.
1829 * Returns 0 if the value is unchanged, 1 if changed.
1831 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1832 int direction, int idx, int mask, int val)
1834 struct hda_amp_info *info;
1836 if (snd_BUG_ON(mask & ~0xff))
1840 mutex_lock(&codec->hash_mutex);
1841 info = update_amp_hash(codec, nid, ch, direction, idx);
1843 mutex_unlock(&codec->hash_mutex);
1846 val |= info->vol[ch] & ~mask;
1847 if (info->vol[ch] == val) {
1848 mutex_unlock(&codec->hash_mutex);
1851 info->vol[ch] = val;
1852 mutex_unlock(&codec->hash_mutex);
1853 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1856 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1859 * snd_hda_codec_amp_stereo - update the AMP stereo values
1860 * @codec: HD-audio codec
1861 * @nid: NID to read the AMP value
1862 * @direction: #HDA_INPUT or #HDA_OUTPUT
1863 * @idx: the index value (only for input direction)
1864 * @mask: bit mask to set
1865 * @val: the bits value to set
1867 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1868 * stereo widget with the same mask and value.
1870 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1871 int direction, int idx, int mask, int val)
1875 if (snd_BUG_ON(mask & ~0xff))
1877 for (ch = 0; ch < 2; ch++)
1878 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1882 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1886 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1887 * @codec: HD-audio codec
1889 * Resume the all amp commands from the cache.
1891 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1893 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1896 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1897 u32 key = buffer->head.key;
1899 unsigned int idx, dir, ch;
1903 idx = (key >> 16) & 0xff;
1904 dir = (key >> 24) & 0xff;
1905 for (ch = 0; ch < 2; ch++) {
1906 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1908 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1913 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1914 #endif /* CONFIG_PM */
1916 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1919 u32 caps = query_amp_caps(codec, nid, dir);
1921 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1928 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1930 * The control element is supposed to have the private_value field
1931 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1933 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1934 struct snd_ctl_elem_info *uinfo)
1936 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1937 u16 nid = get_amp_nid(kcontrol);
1938 u8 chs = get_amp_channels(kcontrol);
1939 int dir = get_amp_direction(kcontrol);
1940 unsigned int ofs = get_amp_offset(kcontrol);
1942 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1943 uinfo->count = chs == 3 ? 2 : 1;
1944 uinfo->value.integer.min = 0;
1945 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1946 if (!uinfo->value.integer.max) {
1947 printk(KERN_WARNING "hda_codec: "
1948 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1954 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1957 static inline unsigned int
1958 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1959 int ch, int dir, int idx, unsigned int ofs)
1962 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1963 val &= HDA_AMP_VOLMASK;
1972 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1973 int ch, int dir, int idx, unsigned int ofs,
1976 unsigned int maxval;
1980 /* ofs = 0: raw max value */
1981 maxval = get_amp_max_value(codec, nid, dir, 0);
1984 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1985 HDA_AMP_VOLMASK, val);
1989 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1991 * The control element is supposed to have the private_value field
1992 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1994 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1995 struct snd_ctl_elem_value *ucontrol)
1997 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1998 hda_nid_t nid = get_amp_nid(kcontrol);
1999 int chs = get_amp_channels(kcontrol);
2000 int dir = get_amp_direction(kcontrol);
2001 int idx = get_amp_index(kcontrol);
2002 unsigned int ofs = get_amp_offset(kcontrol);
2003 long *valp = ucontrol->value.integer.value;
2006 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
2008 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
2011 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
2014 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2016 * The control element is supposed to have the private_value field
2017 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2019 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2020 struct snd_ctl_elem_value *ucontrol)
2022 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2023 hda_nid_t nid = get_amp_nid(kcontrol);
2024 int chs = get_amp_channels(kcontrol);
2025 int dir = get_amp_direction(kcontrol);
2026 int idx = get_amp_index(kcontrol);
2027 unsigned int ofs = get_amp_offset(kcontrol);
2028 long *valp = ucontrol->value.integer.value;
2031 snd_hda_power_up(codec);
2033 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2037 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2038 snd_hda_power_down(codec);
2041 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
2044 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2046 * The control element is supposed to have the private_value field
2047 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2049 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2050 unsigned int size, unsigned int __user *_tlv)
2052 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2053 hda_nid_t nid = get_amp_nid(kcontrol);
2054 int dir = get_amp_direction(kcontrol);
2055 unsigned int ofs = get_amp_offset(kcontrol);
2056 bool min_mute = get_amp_min_mute(kcontrol);
2057 u32 caps, val1, val2;
2059 if (size < 4 * sizeof(unsigned int))
2061 caps = query_amp_caps(codec, nid, dir);
2062 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2063 val2 = (val2 + 1) * 25;
2064 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2066 val1 = ((int)val1) * ((int)val2);
2067 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
2068 val2 |= TLV_DB_SCALE_MUTE;
2069 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2071 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2073 if (put_user(val1, _tlv + 2))
2075 if (put_user(val2, _tlv + 3))
2079 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
2082 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2083 * @codec: HD-audio codec
2084 * @nid: NID of a reference widget
2085 * @dir: #HDA_INPUT or #HDA_OUTPUT
2086 * @tlv: TLV data to be stored, at least 4 elements
2088 * Set (static) TLV data for a virtual master volume using the AMP caps
2089 * obtained from the reference NID.
2090 * The volume range is recalculated as if the max volume is 0dB.
2092 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2098 caps = query_amp_caps(codec, nid, dir);
2099 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2100 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2101 step = (step + 1) * 25;
2102 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2103 tlv[1] = 2 * sizeof(unsigned int);
2104 tlv[2] = -nums * step;
2107 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2109 /* find a mixer control element with the given name */
2110 static struct snd_kcontrol *
2111 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
2112 const char *name, int idx)
2114 struct snd_ctl_elem_id id;
2115 memset(&id, 0, sizeof(id));
2116 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2118 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2120 strcpy(id.name, name);
2121 return snd_ctl_find_id(codec->bus->card, &id);
2125 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2126 * @codec: HD-audio codec
2127 * @name: ctl id name string
2129 * Get the control element with the given id string and IFACE_MIXER.
2131 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2134 return _snd_hda_find_mixer_ctl(codec, name, 0);
2136 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
2138 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name)
2141 for (idx = 0; idx < 16; idx++) { /* 16 ctlrs should be large enough */
2142 if (!_snd_hda_find_mixer_ctl(codec, name, idx))
2149 * snd_hda_ctl_add - Add a control element and assign to the codec
2150 * @codec: HD-audio codec
2151 * @nid: corresponding NID (optional)
2152 * @kctl: the control element to assign
2154 * Add the given control element to an array inside the codec instance.
2155 * All control elements belonging to a codec are supposed to be added
2156 * by this function so that a proper clean-up works at the free or
2157 * reconfiguration time.
2159 * If non-zero @nid is passed, the NID is assigned to the control element.
2160 * The assignment is shown in the codec proc file.
2162 * snd_hda_ctl_add() checks the control subdev id field whether
2163 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2164 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2165 * specifies if kctl->private_value is a HDA amplifier value.
2167 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2168 struct snd_kcontrol *kctl)
2171 unsigned short flags = 0;
2172 struct hda_nid_item *item;
2174 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2175 flags |= HDA_NID_ITEM_AMP;
2177 nid = get_amp_nid_(kctl->private_value);
2179 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2180 nid = kctl->id.subdevice & 0xffff;
2181 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2182 kctl->id.subdevice = 0;
2183 err = snd_ctl_add(codec->bus->card, kctl);
2186 item = snd_array_new(&codec->mixers);
2191 item->flags = flags;
2194 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
2197 * snd_hda_add_nid - Assign a NID to a control element
2198 * @codec: HD-audio codec
2199 * @nid: corresponding NID (optional)
2200 * @kctl: the control element to assign
2201 * @index: index to kctl
2203 * Add the given control element to an array inside the codec instance.
2204 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2205 * NID:KCTL mapping - for example "Capture Source" selector.
2207 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2208 unsigned int index, hda_nid_t nid)
2210 struct hda_nid_item *item;
2213 item = snd_array_new(&codec->nids);
2217 item->index = index;
2221 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2222 kctl->id.name, kctl->id.index, index);
2225 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2228 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2229 * @codec: HD-audio codec
2231 void snd_hda_ctls_clear(struct hda_codec *codec)
2234 struct hda_nid_item *items = codec->mixers.list;
2235 for (i = 0; i < codec->mixers.used; i++)
2236 snd_ctl_remove(codec->bus->card, items[i].kctl);
2237 snd_array_free(&codec->mixers);
2238 snd_array_free(&codec->nids);
2241 /* pseudo device locking
2242 * toggle card->shutdown to allow/disallow the device access (as a hack)
2244 int snd_hda_lock_devices(struct hda_bus *bus)
2246 struct snd_card *card = bus->card;
2247 struct hda_codec *codec;
2249 spin_lock(&card->files_lock);
2253 if (!list_empty(&card->ctl_files))
2256 list_for_each_entry(codec, &bus->codec_list, list) {
2258 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2259 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2262 if (cpcm->pcm->streams[0].substream_opened ||
2263 cpcm->pcm->streams[1].substream_opened)
2267 spin_unlock(&card->files_lock);
2273 spin_unlock(&card->files_lock);
2276 EXPORT_SYMBOL_HDA(snd_hda_lock_devices);
2278 void snd_hda_unlock_devices(struct hda_bus *bus)
2280 struct snd_card *card = bus->card;
2283 spin_lock(&card->files_lock);
2285 spin_unlock(&card->files_lock);
2287 EXPORT_SYMBOL_HDA(snd_hda_unlock_devices);
2290 * snd_hda_codec_reset - Clear all objects assigned to the codec
2291 * @codec: HD-audio codec
2293 * This frees the all PCM and control elements assigned to the codec, and
2294 * clears the caches and restores the pin default configurations.
2296 * When a device is being used, it returns -EBSY. If successfully freed,
2299 int snd_hda_codec_reset(struct hda_codec *codec)
2301 struct hda_bus *bus = codec->bus;
2302 struct snd_card *card = bus->card;
2305 if (snd_hda_lock_devices(bus) < 0)
2308 /* OK, let it free */
2310 #ifdef CONFIG_SND_HDA_POWER_SAVE
2311 cancel_delayed_work_sync(&codec->power_work);
2312 codec->power_on = 0;
2313 codec->power_transition = 0;
2314 codec->power_jiffies = jiffies;
2315 flush_workqueue(bus->workq);
2317 snd_hda_ctls_clear(codec);
2319 for (i = 0; i < codec->num_pcms; i++) {
2320 if (codec->pcm_info[i].pcm) {
2321 snd_device_free(card, codec->pcm_info[i].pcm);
2322 clear_bit(codec->pcm_info[i].device,
2326 if (codec->patch_ops.free)
2327 codec->patch_ops.free(codec);
2328 snd_hda_jack_tbl_clear(codec);
2329 codec->proc_widget_hook = NULL;
2331 free_hda_cache(&codec->amp_cache);
2332 free_hda_cache(&codec->cmd_cache);
2333 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2334 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2335 /* free only driver_pins so that init_pins + user_pins are restored */
2336 snd_array_free(&codec->driver_pins);
2337 restore_pincfgs(codec);
2338 snd_array_free(&codec->cvt_setups);
2339 snd_array_free(&codec->spdif_out);
2340 codec->num_pcms = 0;
2341 codec->pcm_info = NULL;
2342 codec->preset = NULL;
2343 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2344 codec->slave_dig_outs = NULL;
2345 codec->spdif_status_reset = 0;
2346 module_put(codec->owner);
2347 codec->owner = NULL;
2349 /* allow device access again */
2350 snd_hda_unlock_devices(bus);
2354 typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2356 /* apply the function to all matching slave ctls in the mixer list */
2357 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2358 const char *suffix, map_slave_func_t func, void *data)
2360 struct hda_nid_item *items;
2361 const char * const *s;
2364 items = codec->mixers.list;
2365 for (i = 0; i < codec->mixers.used; i++) {
2366 struct snd_kcontrol *sctl = items[i].kctl;
2367 if (!sctl || !sctl->id.name ||
2368 sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2370 for (s = slaves; *s; s++) {
2371 char tmpname[sizeof(sctl->id.name)];
2372 const char *name = *s;
2374 snprintf(tmpname, sizeof(tmpname), "%s %s",
2378 if (!strcmp(sctl->id.name, name)) {
2379 err = func(data, sctl);
2389 static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2394 /* guess the value corresponding to 0dB */
2395 static int get_kctl_0dB_offset(struct snd_kcontrol *kctl)
2398 const int *tlv = NULL;
2401 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2402 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2403 mm_segment_t fs = get_fs();
2405 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2408 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2410 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE)
2411 val = -tlv[2] / tlv[3];
2415 /* call kctl->put with the given value(s) */
2416 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2418 struct snd_ctl_elem_value *ucontrol;
2419 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2422 ucontrol->value.integer.value[0] = val;
2423 ucontrol->value.integer.value[1] = val;
2424 kctl->put(kctl, ucontrol);
2429 /* initialize the slave volume with 0dB */
2430 static int init_slave_0dB(void *data, struct snd_kcontrol *slave)
2432 int offset = get_kctl_0dB_offset(slave);
2434 put_kctl_with_value(slave, offset);
2438 /* unmute the slave */
2439 static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2441 return put_kctl_with_value(slave, 1);
2445 * snd_hda_add_vmaster - create a virtual master control and add slaves
2446 * @codec: HD-audio codec
2447 * @name: vmaster control name
2448 * @tlv: TLV data (optional)
2449 * @slaves: slave control names (optional)
2450 * @suffix: suffix string to each slave name (optional)
2451 * @init_slave_vol: initialize slaves to unmute/0dB
2452 * @ctl_ret: store the vmaster kcontrol in return
2454 * Create a virtual master control with the given name. The TLV data
2455 * must be either NULL or a valid data.
2457 * @slaves is a NULL-terminated array of strings, each of which is a
2458 * slave control name. All controls with these names are assigned to
2459 * the new virtual master control.
2461 * This function returns zero if successful or a negative error code.
2463 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2464 unsigned int *tlv, const char * const *slaves,
2465 const char *suffix, bool init_slave_vol,
2466 struct snd_kcontrol **ctl_ret)
2468 struct snd_kcontrol *kctl;
2474 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2476 snd_printdd("No slave found for %s\n", name);
2479 kctl = snd_ctl_make_virtual_master(name, tlv);
2482 err = snd_hda_ctl_add(codec, 0, kctl);
2486 err = map_slaves(codec, slaves, suffix,
2487 (map_slave_func_t)snd_ctl_add_slave, kctl);
2491 /* init with master mute & zero volume */
2492 put_kctl_with_value(kctl, 0);
2494 map_slaves(codec, slaves, suffix,
2495 tlv ? init_slave_0dB : init_slave_unmute, kctl);
2501 EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
2504 * mute-LED control using vmaster
2506 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2507 struct snd_ctl_elem_info *uinfo)
2509 static const char * const texts[] = {
2510 "Off", "On", "Follow Master"
2514 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2516 uinfo->value.enumerated.items = 3;
2517 index = uinfo->value.enumerated.item;
2520 strcpy(uinfo->value.enumerated.name, texts[index]);
2524 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2525 struct snd_ctl_elem_value *ucontrol)
2527 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2528 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2532 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2533 struct snd_ctl_elem_value *ucontrol)
2535 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2536 unsigned int old_mode = hook->mute_mode;
2538 hook->mute_mode = ucontrol->value.enumerated.item[0];
2539 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2540 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2541 if (old_mode == hook->mute_mode)
2543 snd_hda_sync_vmaster_hook(hook);
2547 static struct snd_kcontrol_new vmaster_mute_mode = {
2548 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2549 .name = "Mute-LED Mode",
2550 .info = vmaster_mute_mode_info,
2551 .get = vmaster_mute_mode_get,
2552 .put = vmaster_mute_mode_put,
2556 * Add a mute-LED hook with the given vmaster switch kctl
2557 * "Mute-LED Mode" control is automatically created and associated with
2560 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2561 struct hda_vmaster_mute_hook *hook,
2562 bool expose_enum_ctl)
2564 struct snd_kcontrol *kctl;
2566 if (!hook->hook || !hook->sw_kctl)
2568 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2569 hook->codec = codec;
2570 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2571 if (!expose_enum_ctl)
2573 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2576 return snd_hda_ctl_add(codec, 0, kctl);
2578 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
2581 * Call the hook with the current value for synchronization
2582 * Should be called in init callback
2584 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2586 if (!hook->hook || !hook->codec)
2588 switch (hook->mute_mode) {
2589 case HDA_VMUTE_FOLLOW_MASTER:
2590 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2593 hook->hook(hook->codec, hook->mute_mode);
2597 EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
2601 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2603 * The control element is supposed to have the private_value field
2604 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2606 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2607 struct snd_ctl_elem_info *uinfo)
2609 int chs = get_amp_channels(kcontrol);
2611 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2612 uinfo->count = chs == 3 ? 2 : 1;
2613 uinfo->value.integer.min = 0;
2614 uinfo->value.integer.max = 1;
2617 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2620 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2622 * The control element is supposed to have the private_value field
2623 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2625 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2626 struct snd_ctl_elem_value *ucontrol)
2628 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2629 hda_nid_t nid = get_amp_nid(kcontrol);
2630 int chs = get_amp_channels(kcontrol);
2631 int dir = get_amp_direction(kcontrol);
2632 int idx = get_amp_index(kcontrol);
2633 long *valp = ucontrol->value.integer.value;
2636 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2637 HDA_AMP_MUTE) ? 0 : 1;
2639 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2640 HDA_AMP_MUTE) ? 0 : 1;
2643 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2646 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2648 * The control element is supposed to have the private_value field
2649 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2651 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2652 struct snd_ctl_elem_value *ucontrol)
2654 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2655 hda_nid_t nid = get_amp_nid(kcontrol);
2656 int chs = get_amp_channels(kcontrol);
2657 int dir = get_amp_direction(kcontrol);
2658 int idx = get_amp_index(kcontrol);
2659 long *valp = ucontrol->value.integer.value;
2662 snd_hda_power_up(codec);
2664 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2666 *valp ? 0 : HDA_AMP_MUTE);
2670 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2672 *valp ? 0 : HDA_AMP_MUTE);
2673 hda_call_check_power_status(codec, nid);
2674 snd_hda_power_down(codec);
2677 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2680 * bound volume controls
2682 * bind multiple volumes (# indices, from 0)
2685 #define AMP_VAL_IDX_SHIFT 19
2686 #define AMP_VAL_IDX_MASK (0x0f<<19)
2689 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2691 * The control element is supposed to have the private_value field
2692 * set up via HDA_BIND_MUTE*() macros.
2694 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2695 struct snd_ctl_elem_value *ucontrol)
2697 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2701 mutex_lock(&codec->control_mutex);
2702 pval = kcontrol->private_value;
2703 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2704 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2705 kcontrol->private_value = pval;
2706 mutex_unlock(&codec->control_mutex);
2709 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2712 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2714 * The control element is supposed to have the private_value field
2715 * set up via HDA_BIND_MUTE*() macros.
2717 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2718 struct snd_ctl_elem_value *ucontrol)
2720 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2722 int i, indices, err = 0, change = 0;
2724 mutex_lock(&codec->control_mutex);
2725 pval = kcontrol->private_value;
2726 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2727 for (i = 0; i < indices; i++) {
2728 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2729 (i << AMP_VAL_IDX_SHIFT);
2730 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2735 kcontrol->private_value = pval;
2736 mutex_unlock(&codec->control_mutex);
2737 return err < 0 ? err : change;
2739 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2742 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2744 * The control element is supposed to have the private_value field
2745 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2747 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2748 struct snd_ctl_elem_info *uinfo)
2750 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2751 struct hda_bind_ctls *c;
2754 mutex_lock(&codec->control_mutex);
2755 c = (struct hda_bind_ctls *)kcontrol->private_value;
2756 kcontrol->private_value = *c->values;
2757 err = c->ops->info(kcontrol, uinfo);
2758 kcontrol->private_value = (long)c;
2759 mutex_unlock(&codec->control_mutex);
2762 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2765 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2767 * The control element is supposed to have the private_value field
2768 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2770 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2771 struct snd_ctl_elem_value *ucontrol)
2773 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2774 struct hda_bind_ctls *c;
2777 mutex_lock(&codec->control_mutex);
2778 c = (struct hda_bind_ctls *)kcontrol->private_value;
2779 kcontrol->private_value = *c->values;
2780 err = c->ops->get(kcontrol, ucontrol);
2781 kcontrol->private_value = (long)c;
2782 mutex_unlock(&codec->control_mutex);
2785 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2788 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2790 * The control element is supposed to have the private_value field
2791 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2793 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2794 struct snd_ctl_elem_value *ucontrol)
2796 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2797 struct hda_bind_ctls *c;
2798 unsigned long *vals;
2799 int err = 0, change = 0;
2801 mutex_lock(&codec->control_mutex);
2802 c = (struct hda_bind_ctls *)kcontrol->private_value;
2803 for (vals = c->values; *vals; vals++) {
2804 kcontrol->private_value = *vals;
2805 err = c->ops->put(kcontrol, ucontrol);
2810 kcontrol->private_value = (long)c;
2811 mutex_unlock(&codec->control_mutex);
2812 return err < 0 ? err : change;
2814 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2817 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2819 * The control element is supposed to have the private_value field
2820 * set up via HDA_BIND_VOL() macro.
2822 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2823 unsigned int size, unsigned int __user *tlv)
2825 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2826 struct hda_bind_ctls *c;
2829 mutex_lock(&codec->control_mutex);
2830 c = (struct hda_bind_ctls *)kcontrol->private_value;
2831 kcontrol->private_value = *c->values;
2832 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2833 kcontrol->private_value = (long)c;
2834 mutex_unlock(&codec->control_mutex);
2837 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2839 struct hda_ctl_ops snd_hda_bind_vol = {
2840 .info = snd_hda_mixer_amp_volume_info,
2841 .get = snd_hda_mixer_amp_volume_get,
2842 .put = snd_hda_mixer_amp_volume_put,
2843 .tlv = snd_hda_mixer_amp_tlv
2845 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2847 struct hda_ctl_ops snd_hda_bind_sw = {
2848 .info = snd_hda_mixer_amp_switch_info,
2849 .get = snd_hda_mixer_amp_switch_get,
2850 .put = snd_hda_mixer_amp_switch_put,
2851 .tlv = snd_hda_mixer_amp_tlv
2853 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2856 * SPDIF out controls
2859 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2860 struct snd_ctl_elem_info *uinfo)
2862 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2867 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2868 struct snd_ctl_elem_value *ucontrol)
2870 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2871 IEC958_AES0_NONAUDIO |
2872 IEC958_AES0_CON_EMPHASIS_5015 |
2873 IEC958_AES0_CON_NOT_COPYRIGHT;
2874 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2875 IEC958_AES1_CON_ORIGINAL;
2879 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2880 struct snd_ctl_elem_value *ucontrol)
2882 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2883 IEC958_AES0_NONAUDIO |
2884 IEC958_AES0_PRO_EMPHASIS_5015;
2888 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2889 struct snd_ctl_elem_value *ucontrol)
2891 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2892 int idx = kcontrol->private_value;
2893 struct hda_spdif_out *spdif;
2895 mutex_lock(&codec->spdif_mutex);
2896 spdif = snd_array_elem(&codec->spdif_out, idx);
2897 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2898 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2899 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2900 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2901 mutex_unlock(&codec->spdif_mutex);
2906 /* convert from SPDIF status bits to HDA SPDIF bits
2907 * bit 0 (DigEn) is always set zero (to be filled later)
2909 static unsigned short convert_from_spdif_status(unsigned int sbits)
2911 unsigned short val = 0;
2913 if (sbits & IEC958_AES0_PROFESSIONAL)
2914 val |= AC_DIG1_PROFESSIONAL;
2915 if (sbits & IEC958_AES0_NONAUDIO)
2916 val |= AC_DIG1_NONAUDIO;
2917 if (sbits & IEC958_AES0_PROFESSIONAL) {
2918 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2919 IEC958_AES0_PRO_EMPHASIS_5015)
2920 val |= AC_DIG1_EMPHASIS;
2922 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2923 IEC958_AES0_CON_EMPHASIS_5015)
2924 val |= AC_DIG1_EMPHASIS;
2925 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2926 val |= AC_DIG1_COPYRIGHT;
2927 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2928 val |= AC_DIG1_LEVEL;
2929 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2934 /* convert to SPDIF status bits from HDA SPDIF bits
2936 static unsigned int convert_to_spdif_status(unsigned short val)
2938 unsigned int sbits = 0;
2940 if (val & AC_DIG1_NONAUDIO)
2941 sbits |= IEC958_AES0_NONAUDIO;
2942 if (val & AC_DIG1_PROFESSIONAL)
2943 sbits |= IEC958_AES0_PROFESSIONAL;
2944 if (sbits & IEC958_AES0_PROFESSIONAL) {
2945 if (sbits & AC_DIG1_EMPHASIS)
2946 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2948 if (val & AC_DIG1_EMPHASIS)
2949 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2950 if (!(val & AC_DIG1_COPYRIGHT))
2951 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2952 if (val & AC_DIG1_LEVEL)
2953 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2954 sbits |= val & (0x7f << 8);
2959 /* set digital convert verbs both for the given NID and its slaves */
2960 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2965 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2966 d = codec->slave_dig_outs;
2970 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2973 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2977 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2979 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2982 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2983 struct snd_ctl_elem_value *ucontrol)
2985 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2986 int idx = kcontrol->private_value;
2987 struct hda_spdif_out *spdif;
2992 mutex_lock(&codec->spdif_mutex);
2993 spdif = snd_array_elem(&codec->spdif_out, idx);
2995 spdif->status = ucontrol->value.iec958.status[0] |
2996 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2997 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2998 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2999 val = convert_from_spdif_status(spdif->status);
3000 val |= spdif->ctls & 1;
3001 change = spdif->ctls != val;
3003 if (change && nid != (u16)-1)
3004 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
3005 mutex_unlock(&codec->spdif_mutex);
3009 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
3011 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3012 struct snd_ctl_elem_value *ucontrol)
3014 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3015 int idx = kcontrol->private_value;
3016 struct hda_spdif_out *spdif;
3018 mutex_lock(&codec->spdif_mutex);
3019 spdif = snd_array_elem(&codec->spdif_out, idx);
3020 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
3021 mutex_unlock(&codec->spdif_mutex);
3025 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3028 set_dig_out_convert(codec, nid, dig1, dig2);
3029 /* unmute amp switch (if any) */
3030 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3031 (dig1 & AC_DIG1_ENABLE))
3032 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3036 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3037 struct snd_ctl_elem_value *ucontrol)
3039 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3040 int idx = kcontrol->private_value;
3041 struct hda_spdif_out *spdif;
3046 mutex_lock(&codec->spdif_mutex);
3047 spdif = snd_array_elem(&codec->spdif_out, idx);
3049 val = spdif->ctls & ~AC_DIG1_ENABLE;
3050 if (ucontrol->value.integer.value[0])
3051 val |= AC_DIG1_ENABLE;
3052 change = spdif->ctls != val;
3054 if (change && nid != (u16)-1)
3055 set_spdif_ctls(codec, nid, val & 0xff, -1);
3056 mutex_unlock(&codec->spdif_mutex);
3060 static struct snd_kcontrol_new dig_mixes[] = {
3062 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3063 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3064 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3065 .info = snd_hda_spdif_mask_info,
3066 .get = snd_hda_spdif_cmask_get,
3069 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3070 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3071 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3072 .info = snd_hda_spdif_mask_info,
3073 .get = snd_hda_spdif_pmask_get,
3076 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3077 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3078 .info = snd_hda_spdif_mask_info,
3079 .get = snd_hda_spdif_default_get,
3080 .put = snd_hda_spdif_default_put,
3083 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3084 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3085 .info = snd_hda_spdif_out_switch_info,
3086 .get = snd_hda_spdif_out_switch_get,
3087 .put = snd_hda_spdif_out_switch_put,
3093 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
3094 * @codec: the HDA codec
3095 * @nid: audio out widget NID
3097 * Creates controls related with the SPDIF output.
3098 * Called from each patch supporting the SPDIF out.
3100 * Returns 0 if successful, or a negative error code.
3102 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
3103 hda_nid_t associated_nid,
3107 struct snd_kcontrol *kctl;
3108 struct snd_kcontrol_new *dig_mix;
3110 struct hda_spdif_out *spdif;
3112 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
3114 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3117 spdif = snd_array_new(&codec->spdif_out);
3118 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3119 kctl = snd_ctl_new1(dig_mix, codec);
3122 kctl->id.index = idx;
3123 kctl->private_value = codec->spdif_out.used - 1;
3124 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3128 spdif->nid = cvt_nid;
3129 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3130 AC_VERB_GET_DIGI_CONVERT_1, 0);
3131 spdif->status = convert_to_spdif_status(spdif->ctls);
3134 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
3136 /* get the hda_spdif_out entry from the given NID
3137 * call within spdif_mutex lock
3139 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3143 for (i = 0; i < codec->spdif_out.used; i++) {
3144 struct hda_spdif_out *spdif =
3145 snd_array_elem(&codec->spdif_out, i);
3146 if (spdif->nid == nid)
3151 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3153 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3155 struct hda_spdif_out *spdif;
3157 mutex_lock(&codec->spdif_mutex);
3158 spdif = snd_array_elem(&codec->spdif_out, idx);
3159 spdif->nid = (u16)-1;
3160 mutex_unlock(&codec->spdif_mutex);
3162 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3164 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3166 struct hda_spdif_out *spdif;
3169 mutex_lock(&codec->spdif_mutex);
3170 spdif = snd_array_elem(&codec->spdif_out, idx);
3171 if (spdif->nid != nid) {
3174 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3176 mutex_unlock(&codec->spdif_mutex);
3178 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3181 * SPDIF sharing with analog output
3183 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3184 struct snd_ctl_elem_value *ucontrol)
3186 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3187 ucontrol->value.integer.value[0] = mout->share_spdif;
3191 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3192 struct snd_ctl_elem_value *ucontrol)
3194 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3195 mout->share_spdif = !!ucontrol->value.integer.value[0];
3199 static struct snd_kcontrol_new spdif_share_sw = {
3200 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3201 .name = "IEC958 Default PCM Playback Switch",
3202 .info = snd_ctl_boolean_mono_info,
3203 .get = spdif_share_sw_get,
3204 .put = spdif_share_sw_put,
3208 * snd_hda_create_spdif_share_sw - create Default PCM switch
3209 * @codec: the HDA codec
3210 * @mout: multi-out instance
3212 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3213 struct hda_multi_out *mout)
3215 if (!mout->dig_out_nid)
3217 /* ATTENTION: here mout is passed as private_data, instead of codec */
3218 return snd_hda_ctl_add(codec, mout->dig_out_nid,
3219 snd_ctl_new1(&spdif_share_sw, mout));
3221 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3227 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3229 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3230 struct snd_ctl_elem_value *ucontrol)
3232 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3234 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3238 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3239 struct snd_ctl_elem_value *ucontrol)
3241 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3242 hda_nid_t nid = kcontrol->private_value;
3243 unsigned int val = !!ucontrol->value.integer.value[0];
3246 mutex_lock(&codec->spdif_mutex);
3247 change = codec->spdif_in_enable != val;
3249 codec->spdif_in_enable = val;
3250 snd_hda_codec_write_cache(codec, nid, 0,
3251 AC_VERB_SET_DIGI_CONVERT_1, val);
3253 mutex_unlock(&codec->spdif_mutex);
3257 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3258 struct snd_ctl_elem_value *ucontrol)
3260 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3261 hda_nid_t nid = kcontrol->private_value;
3265 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3266 sbits = convert_to_spdif_status(val);
3267 ucontrol->value.iec958.status[0] = sbits;
3268 ucontrol->value.iec958.status[1] = sbits >> 8;
3269 ucontrol->value.iec958.status[2] = sbits >> 16;
3270 ucontrol->value.iec958.status[3] = sbits >> 24;
3274 static struct snd_kcontrol_new dig_in_ctls[] = {
3276 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3277 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3278 .info = snd_hda_spdif_in_switch_info,
3279 .get = snd_hda_spdif_in_switch_get,
3280 .put = snd_hda_spdif_in_switch_put,
3283 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3284 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3285 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3286 .info = snd_hda_spdif_mask_info,
3287 .get = snd_hda_spdif_in_status_get,
3293 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3294 * @codec: the HDA codec
3295 * @nid: audio in widget NID
3297 * Creates controls related with the SPDIF input.
3298 * Called from each patch supporting the SPDIF in.
3300 * Returns 0 if successful, or a negative error code.
3302 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3305 struct snd_kcontrol *kctl;
3306 struct snd_kcontrol_new *dig_mix;
3309 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3311 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3314 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3315 kctl = snd_ctl_new1(dig_mix, codec);
3318 kctl->private_value = nid;
3319 err = snd_hda_ctl_add(codec, nid, kctl);
3323 codec->spdif_in_enable =
3324 snd_hda_codec_read(codec, nid, 0,
3325 AC_VERB_GET_DIGI_CONVERT_1, 0) &
3329 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3336 /* build a 32bit cache key with the widget id and the command parameter */
3337 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3338 #define get_cmd_cache_nid(key) ((key) & 0xff)
3339 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3342 * snd_hda_codec_write_cache - send a single command with caching
3343 * @codec: the HDA codec
3344 * @nid: NID to send the command
3345 * @direct: direct flag
3346 * @verb: the verb to send
3347 * @parm: the parameter for the verb
3349 * Send a single command without waiting for response.
3351 * Returns 0 if successful, or a negative error code.
3353 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3354 int direct, unsigned int verb, unsigned int parm)
3356 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3357 struct hda_cache_head *c;
3362 /* parm may contain the verb stuff for get/set amp */
3363 verb = verb | (parm >> 8);
3365 key = build_cmd_cache_key(nid, verb);
3366 mutex_lock(&codec->bus->cmd_mutex);
3367 c = get_alloc_hash(&codec->cmd_cache, key);
3370 mutex_unlock(&codec->bus->cmd_mutex);
3373 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3376 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3377 * @codec: the HDA codec
3378 * @nid: NID to send the command
3379 * @direct: direct flag
3380 * @verb: the verb to send
3381 * @parm: the parameter for the verb
3383 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3384 * command if the parameter is already identical with the cached value.
3385 * If not, it sends the command and refreshes the cache.
3387 * Returns 0 if successful, or a negative error code.
3389 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3390 int direct, unsigned int verb, unsigned int parm)
3392 struct hda_cache_head *c;
3395 /* parm may contain the verb stuff for get/set amp */
3396 verb = verb | (parm >> 8);
3398 key = build_cmd_cache_key(nid, verb);
3399 mutex_lock(&codec->bus->cmd_mutex);
3400 c = get_hash(&codec->cmd_cache, key);
3401 if (c && c->val == parm) {
3402 mutex_unlock(&codec->bus->cmd_mutex);
3405 mutex_unlock(&codec->bus->cmd_mutex);
3406 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3408 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3411 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3412 * @codec: HD-audio codec
3414 * Execute all verbs recorded in the command caches to resume.
3416 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3418 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
3421 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
3422 u32 key = buffer->key;
3425 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3426 get_cmd_cache_cmd(key), buffer->val);
3429 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3432 * snd_hda_sequence_write_cache - sequence writes with caching
3433 * @codec: the HDA codec
3434 * @seq: VERB array to send
3436 * Send the commands sequentially from the given array.
3437 * Thte commands are recorded on cache for power-save and resume.
3438 * The array must be terminated with NID=0.
3440 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3441 const struct hda_verb *seq)
3443 for (; seq->nid; seq++)
3444 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3447 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3448 #endif /* CONFIG_PM */
3450 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3451 unsigned int power_state,
3452 bool eapd_workaround)
3454 hda_nid_t nid = codec->start_nid;
3457 for (i = 0; i < codec->num_nodes; i++, nid++) {
3458 unsigned int wcaps = get_wcaps(codec, nid);
3459 if (!(wcaps & AC_WCAP_POWER))
3461 /* don't power down the widget if it controls eapd and
3462 * EAPD_BTLENABLE is set.
3464 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3465 get_wcaps_type(wcaps) == AC_WID_PIN &&
3466 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3467 int eapd = snd_hda_codec_read(codec, nid, 0,
3468 AC_VERB_GET_EAPD_BTLENABLE, 0);
3472 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3476 if (power_state == AC_PWRST_D0) {
3477 unsigned long end_time;
3479 /* wait until the codec reachs to D0 */
3480 end_time = jiffies + msecs_to_jiffies(500);
3482 state = snd_hda_codec_read(codec, fg, 0,
3483 AC_VERB_GET_POWER_STATE, 0);
3484 if (state == power_state)
3487 } while (time_after_eq(end_time, jiffies));
3490 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3493 * supported power states check
3495 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
3496 unsigned int power_state)
3498 int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
3502 if (sup & power_state)
3509 * set power state of the codec
3511 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3512 unsigned int power_state)
3517 if (codec->patch_ops.set_power_state) {
3518 codec->patch_ops.set_power_state(codec, fg, power_state);
3522 /* this delay seems necessary to avoid click noise at power-down */
3523 if (power_state == AC_PWRST_D3) {
3524 /* transition time less than 10ms for power down */
3525 bool epss = snd_hda_codec_get_supported_ps(codec, fg, AC_PWRST_EPSS);
3526 msleep(epss ? 10 : 100);
3529 /* repeat power states setting at most 10 times*/
3530 for (count = 0; count < 10; count++) {
3531 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3533 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3534 state = snd_hda_codec_read(codec, fg, 0,
3535 AC_VERB_GET_POWER_STATE, 0);
3536 if (!(state & AC_PWRST_ERROR))
3541 #ifdef CONFIG_SND_HDA_HWDEP
3542 /* execute additional init verbs */
3543 static void hda_exec_init_verbs(struct hda_codec *codec)
3545 if (codec->init_verbs.list)
3546 snd_hda_sequence_write(codec, codec->init_verbs.list);
3549 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3554 * call suspend and power-down; used both from PM and power-save
3556 static void hda_call_codec_suspend(struct hda_codec *codec)
3558 if (codec->patch_ops.suspend)
3559 codec->patch_ops.suspend(codec);
3560 hda_cleanup_all_streams(codec);
3561 hda_set_power_state(codec,
3562 codec->afg ? codec->afg : codec->mfg,
3564 #ifdef CONFIG_SND_HDA_POWER_SAVE
3565 cancel_delayed_work(&codec->power_work);
3566 spin_lock(&codec->power_lock);
3567 snd_hda_update_power_acct(codec);
3568 trace_hda_power_down(codec);
3569 codec->power_on = 0;
3570 codec->power_transition = 0;
3571 codec->power_jiffies = jiffies;
3572 spin_unlock(&codec->power_lock);
3577 * kick up codec; used both from PM and power-save
3579 static void hda_call_codec_resume(struct hda_codec *codec)
3581 /* set as if powered on for avoiding re-entering the resume
3582 * in the resume / power-save sequence
3584 hda_keep_power_on(codec);
3585 hda_set_power_state(codec,
3586 codec->afg ? codec->afg : codec->mfg,
3588 restore_pincfgs(codec); /* restore all current pin configs */
3589 restore_shutup_pins(codec);
3590 hda_exec_init_verbs(codec);
3591 snd_hda_jack_set_dirty_all(codec);
3592 if (codec->patch_ops.resume)
3593 codec->patch_ops.resume(codec);
3595 if (codec->patch_ops.init)
3596 codec->patch_ops.init(codec);
3597 snd_hda_codec_resume_amp(codec);
3598 snd_hda_codec_resume_cache(codec);
3600 snd_hda_power_down(codec); /* flag down before returning */
3602 #endif /* CONFIG_PM */
3606 * snd_hda_build_controls - build mixer controls
3609 * Creates mixer controls for each codec included in the bus.
3611 * Returns 0 if successful, otherwise a negative error code.
3613 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
3615 struct hda_codec *codec;
3617 list_for_each_entry(codec, &bus->codec_list, list) {
3618 int err = snd_hda_codec_build_controls(codec);
3620 printk(KERN_ERR "hda_codec: cannot build controls "
3621 "for #%d (error %d)\n", codec->addr, err);
3622 err = snd_hda_codec_reset(codec);
3625 "hda_codec: cannot revert codec\n");
3632 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3634 int snd_hda_codec_build_controls(struct hda_codec *codec)
3637 hda_exec_init_verbs(codec);
3638 /* continue to initialize... */
3639 if (codec->patch_ops.init)
3640 err = codec->patch_ops.init(codec);
3641 if (!err && codec->patch_ops.build_controls)
3642 err = codec->patch_ops.build_controls(codec);
3651 struct hda_rate_tbl {
3653 unsigned int alsa_bits;
3654 unsigned int hda_fmt;
3657 /* rate = base * mult / div */
3658 #define HDA_RATE(base, mult, div) \
3659 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3660 (((div) - 1) << AC_FMT_DIV_SHIFT))
3662 static struct hda_rate_tbl rate_bits[] = {
3663 /* rate in Hz, ALSA rate bitmask, HDA format value */
3665 /* autodetected value used in snd_hda_query_supported_pcm */
3666 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3667 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3668 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3669 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3670 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3671 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3672 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3673 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3674 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3675 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3676 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3677 #define AC_PAR_PCM_RATE_BITS 11
3678 /* up to bits 10, 384kHZ isn't supported properly */
3680 /* not autodetected value */
3681 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3683 { 0 } /* terminator */
3687 * snd_hda_calc_stream_format - calculate format bitset
3688 * @rate: the sample rate
3689 * @channels: the number of channels
3690 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3691 * @maxbps: the max. bps
3693 * Calculate the format bitset from the given rate, channels and th PCM format.
3695 * Return zero if invalid.
3697 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3698 unsigned int channels,
3699 unsigned int format,
3700 unsigned int maxbps,
3701 unsigned short spdif_ctls)
3704 unsigned int val = 0;
3706 for (i = 0; rate_bits[i].hz; i++)
3707 if (rate_bits[i].hz == rate) {
3708 val = rate_bits[i].hda_fmt;
3711 if (!rate_bits[i].hz) {
3712 snd_printdd("invalid rate %d\n", rate);
3716 if (channels == 0 || channels > 8) {
3717 snd_printdd("invalid channels %d\n", channels);
3720 val |= channels - 1;
3722 switch (snd_pcm_format_width(format)) {
3724 val |= AC_FMT_BITS_8;
3727 val |= AC_FMT_BITS_16;
3732 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3733 val |= AC_FMT_BITS_32;
3734 else if (maxbps >= 24)
3735 val |= AC_FMT_BITS_24;
3737 val |= AC_FMT_BITS_20;
3740 snd_printdd("invalid format width %d\n",
3741 snd_pcm_format_width(format));
3745 if (spdif_ctls & AC_DIG1_NONAUDIO)
3746 val |= AC_FMT_TYPE_NON_PCM;
3750 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3752 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
3755 unsigned int val = 0;
3756 if (nid != codec->afg &&
3757 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3758 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3759 if (!val || val == -1)
3760 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3761 if (!val || val == -1)
3766 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3768 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
3772 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
3775 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3776 if (!streams || streams == -1)
3777 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3778 if (!streams || streams == -1)
3783 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3785 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
3790 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3791 * @codec: the HDA codec
3792 * @nid: NID to query
3793 * @ratesp: the pointer to store the detected rate bitflags
3794 * @formatsp: the pointer to store the detected formats
3795 * @bpsp: the pointer to store the detected format widths
3797 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3798 * or @bsps argument is ignored.
3800 * Returns 0 if successful, otherwise a negative error code.
3802 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3803 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3805 unsigned int i, val, wcaps;
3807 wcaps = get_wcaps(codec, nid);
3808 val = query_pcm_param(codec, nid);
3812 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3814 rates |= rate_bits[i].alsa_bits;
3817 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3818 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3820 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3826 if (formatsp || bpsp) {
3828 unsigned int streams, bps;
3830 streams = query_stream_param(codec, nid);
3835 if (streams & AC_SUPFMT_PCM) {
3836 if (val & AC_SUPPCM_BITS_8) {
3837 formats |= SNDRV_PCM_FMTBIT_U8;
3840 if (val & AC_SUPPCM_BITS_16) {
3841 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3844 if (wcaps & AC_WCAP_DIGITAL) {
3845 if (val & AC_SUPPCM_BITS_32)
3846 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3847 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3848 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3849 if (val & AC_SUPPCM_BITS_24)
3851 else if (val & AC_SUPPCM_BITS_20)
3853 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3854 AC_SUPPCM_BITS_32)) {
3855 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3856 if (val & AC_SUPPCM_BITS_32)
3858 else if (val & AC_SUPPCM_BITS_24)
3860 else if (val & AC_SUPPCM_BITS_20)
3864 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
3865 if (streams & AC_SUPFMT_FLOAT32) {
3866 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3871 if (streams == AC_SUPFMT_AC3) {
3872 /* should be exclusive */
3873 /* temporary hack: we have still no proper support
3874 * for the direct AC3 stream...
3876 formats |= SNDRV_PCM_FMTBIT_U8;
3880 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3881 "(nid=0x%x, val=0x%x, ovrd=%i, "
3884 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3889 *formatsp = formats;
3896 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
3899 * snd_hda_is_supported_format - Check the validity of the format
3900 * @codec: HD-audio codec
3901 * @nid: NID to check
3902 * @format: the HD-audio format value to check
3904 * Check whether the given node supports the format value.
3906 * Returns 1 if supported, 0 if not.
3908 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3909 unsigned int format)
3912 unsigned int val = 0, rate, stream;
3914 val = query_pcm_param(codec, nid);
3918 rate = format & 0xff00;
3919 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3920 if (rate_bits[i].hda_fmt == rate) {
3925 if (i >= AC_PAR_PCM_RATE_BITS)
3928 stream = query_stream_param(codec, nid);
3932 if (stream & AC_SUPFMT_PCM) {
3933 switch (format & 0xf0) {
3935 if (!(val & AC_SUPPCM_BITS_8))
3939 if (!(val & AC_SUPPCM_BITS_16))
3943 if (!(val & AC_SUPPCM_BITS_20))
3947 if (!(val & AC_SUPPCM_BITS_24))
3951 if (!(val & AC_SUPPCM_BITS_32))
3958 /* FIXME: check for float32 and AC3? */
3963 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3968 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3969 struct hda_codec *codec,
3970 struct snd_pcm_substream *substream)
3975 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3976 struct hda_codec *codec,
3977 unsigned int stream_tag,
3978 unsigned int format,
3979 struct snd_pcm_substream *substream)
3981 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3985 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3986 struct hda_codec *codec,
3987 struct snd_pcm_substream *substream)
3989 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3993 static int set_pcm_default_values(struct hda_codec *codec,
3994 struct hda_pcm_stream *info)
3998 /* query support PCM information from the given NID */
3999 if (info->nid && (!info->rates || !info->formats)) {
4000 err = snd_hda_query_supported_pcm(codec, info->nid,
4001 info->rates ? NULL : &info->rates,
4002 info->formats ? NULL : &info->formats,
4003 info->maxbps ? NULL : &info->maxbps);
4007 if (info->ops.open == NULL)
4008 info->ops.open = hda_pcm_default_open_close;
4009 if (info->ops.close == NULL)
4010 info->ops.close = hda_pcm_default_open_close;
4011 if (info->ops.prepare == NULL) {
4012 if (snd_BUG_ON(!info->nid))
4014 info->ops.prepare = hda_pcm_default_prepare;
4016 if (info->ops.cleanup == NULL) {
4017 if (snd_BUG_ON(!info->nid))
4019 info->ops.cleanup = hda_pcm_default_cleanup;
4025 * codec prepare/cleanup entries
4027 int snd_hda_codec_prepare(struct hda_codec *codec,
4028 struct hda_pcm_stream *hinfo,
4029 unsigned int stream,
4030 unsigned int format,
4031 struct snd_pcm_substream *substream)
4034 mutex_lock(&codec->bus->prepare_mutex);
4035 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4037 purify_inactive_streams(codec);
4038 mutex_unlock(&codec->bus->prepare_mutex);
4041 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
4043 void snd_hda_codec_cleanup(struct hda_codec *codec,
4044 struct hda_pcm_stream *hinfo,
4045 struct snd_pcm_substream *substream)
4047 mutex_lock(&codec->bus->prepare_mutex);
4048 hinfo->ops.cleanup(hinfo, codec, substream);
4049 mutex_unlock(&codec->bus->prepare_mutex);
4051 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
4054 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4055 "Audio", "SPDIF", "HDMI", "Modem"
4059 * get the empty PCM device number to assign
4061 * note the max device number is limited by HDA_MAX_PCMS, currently 10
4063 static int get_empty_pcm_device(struct hda_bus *bus, int type)
4065 /* audio device indices; not linear to keep compatibility */
4066 static int audio_idx[HDA_PCM_NTYPES][5] = {
4067 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4068 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
4069 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
4070 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
4074 if (type >= HDA_PCM_NTYPES) {
4075 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4079 for (i = 0; audio_idx[type][i] >= 0 ; i++)
4080 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4081 return audio_idx[type][i];
4083 /* non-fixed slots starting from 10 */
4084 for (i = 10; i < 32; i++) {
4085 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4089 snd_printk(KERN_WARNING "Too many %s devices\n",
4090 snd_hda_pcm_type_name[type]);
4095 * attach a new PCM stream
4097 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4099 struct hda_bus *bus = codec->bus;
4100 struct hda_pcm_stream *info;
4103 if (snd_BUG_ON(!pcm->name))
4105 for (stream = 0; stream < 2; stream++) {
4106 info = &pcm->stream[stream];
4107 if (info->substreams) {
4108 err = set_pcm_default_values(codec, info);
4113 return bus->ops.attach_pcm(bus, codec, pcm);
4116 /* assign all PCMs of the given codec */
4117 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4122 if (!codec->num_pcms) {
4123 if (!codec->patch_ops.build_pcms)
4125 err = codec->patch_ops.build_pcms(codec);
4127 printk(KERN_ERR "hda_codec: cannot build PCMs"
4128 "for #%d (error %d)\n", codec->addr, err);
4129 err = snd_hda_codec_reset(codec);
4132 "hda_codec: cannot revert codec\n");
4137 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4138 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4141 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4142 continue; /* no substreams assigned */
4145 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4147 continue; /* no fatal error */
4149 err = snd_hda_attach_pcm(codec, cpcm);
4151 printk(KERN_ERR "hda_codec: cannot attach "
4152 "PCM stream %d for codec #%d\n",
4154 continue; /* no fatal error */
4162 * snd_hda_build_pcms - build PCM information
4165 * Create PCM information for each codec included in the bus.
4167 * The build_pcms codec patch is requested to set up codec->num_pcms and
4168 * codec->pcm_info properly. The array is referred by the top-level driver
4169 * to create its PCM instances.
4170 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4173 * At least, substreams, channels_min and channels_max must be filled for
4174 * each stream. substreams = 0 indicates that the stream doesn't exist.
4175 * When rates and/or formats are zero, the supported values are queried
4176 * from the given nid. The nid is used also by the default ops.prepare
4177 * and ops.cleanup callbacks.
4179 * The driver needs to call ops.open in its open callback. Similarly,
4180 * ops.close is supposed to be called in the close callback.
4181 * ops.prepare should be called in the prepare or hw_params callback
4182 * with the proper parameters for set up.
4183 * ops.cleanup should be called in hw_free for clean up of streams.
4185 * This function returns 0 if successful, or a negative error code.
4187 int snd_hda_build_pcms(struct hda_bus *bus)
4189 struct hda_codec *codec;
4191 list_for_each_entry(codec, &bus->codec_list, list) {
4192 int err = snd_hda_codec_build_pcms(codec);
4198 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
4201 * snd_hda_check_board_config - compare the current codec with the config table
4202 * @codec: the HDA codec
4203 * @num_configs: number of config enums
4204 * @models: array of model name strings
4205 * @tbl: configuration table, terminated by null entries
4207 * Compares the modelname or PCI subsystem id of the current codec with the
4208 * given configuration table. If a matching entry is found, returns its
4209 * config value (supposed to be 0 or positive).
4211 * If no entries are matching, the function returns a negative value.
4213 int snd_hda_check_board_config(struct hda_codec *codec,
4214 int num_configs, const char * const *models,
4215 const struct snd_pci_quirk *tbl)
4217 if (codec->modelname && models) {
4219 for (i = 0; i < num_configs; i++) {
4221 !strcmp(codec->modelname, models[i])) {
4222 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4223 "selected\n", models[i]);
4229 if (!codec->bus->pci || !tbl)
4232 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4235 if (tbl->value >= 0 && tbl->value < num_configs) {
4236 #ifdef CONFIG_SND_DEBUG_VERBOSE
4238 const char *model = NULL;
4240 model = models[tbl->value];
4242 sprintf(tmp, "#%d", tbl->value);
4245 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4246 "for config %x:%x (%s)\n",
4247 model, tbl->subvendor, tbl->subdevice,
4248 (tbl->name ? tbl->name : "Unknown device"));
4254 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
4257 * snd_hda_check_board_codec_sid_config - compare the current codec
4258 subsystem ID with the
4261 This is important for Gateway notebooks with SB450 HDA Audio
4262 where the vendor ID of the PCI device is:
4263 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4264 and the vendor/subvendor are found only at the codec.
4266 * @codec: the HDA codec
4267 * @num_configs: number of config enums
4268 * @models: array of model name strings
4269 * @tbl: configuration table, terminated by null entries
4271 * Compares the modelname or PCI subsystem id of the current codec with the
4272 * given configuration table. If a matching entry is found, returns its
4273 * config value (supposed to be 0 or positive).
4275 * If no entries are matching, the function returns a negative value.
4277 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4278 int num_configs, const char * const *models,
4279 const struct snd_pci_quirk *tbl)
4281 const struct snd_pci_quirk *q;
4283 /* Search for codec ID */
4284 for (q = tbl; q->subvendor; q++) {
4285 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4286 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4287 if ((codec->subsystem_id & mask) == id)
4296 if (tbl->value >= 0 && tbl->value < num_configs) {
4297 #ifdef CONFIG_SND_DEBUG_VERBOSE
4299 const char *model = NULL;
4301 model = models[tbl->value];
4303 sprintf(tmp, "#%d", tbl->value);
4306 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4307 "for config %x:%x (%s)\n",
4308 model, tbl->subvendor, tbl->subdevice,
4309 (tbl->name ? tbl->name : "Unknown device"));
4315 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4318 * snd_hda_add_new_ctls - create controls from the array
4319 * @codec: the HDA codec
4320 * @knew: the array of struct snd_kcontrol_new
4322 * This helper function creates and add new controls in the given array.
4323 * The array must be terminated with an empty entry as terminator.
4325 * Returns 0 if successful, or a negative error code.
4327 int snd_hda_add_new_ctls(struct hda_codec *codec,
4328 const struct snd_kcontrol_new *knew)
4332 for (; knew->name; knew++) {
4333 struct snd_kcontrol *kctl;
4334 int addr = 0, idx = 0;
4335 if (knew->iface == -1) /* skip this codec private value */
4338 kctl = snd_ctl_new1(knew, codec);
4342 kctl->id.device = addr;
4344 kctl->id.index = idx;
4345 err = snd_hda_ctl_add(codec, 0, kctl);
4348 /* try first with another device index corresponding to
4349 * the codec addr; if it still fails (or it's the
4350 * primary codec), then try another control index
4352 if (!addr && codec->addr)
4354 else if (!idx && !knew->index) {
4355 idx = find_empty_mixer_ctl_idx(codec,
4365 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4367 #ifdef CONFIG_SND_HDA_POWER_SAVE
4368 static void hda_power_work(struct work_struct *work)
4370 struct hda_codec *codec =
4371 container_of(work, struct hda_codec, power_work.work);
4372 struct hda_bus *bus = codec->bus;
4374 spin_lock(&codec->power_lock);
4375 if (codec->power_transition > 0) { /* during power-up sequence? */
4376 spin_unlock(&codec->power_lock);
4379 if (!codec->power_on || codec->power_count) {
4380 codec->power_transition = 0;
4381 spin_unlock(&codec->power_lock);
4384 spin_unlock(&codec->power_lock);
4386 hda_call_codec_suspend(codec);
4387 if (bus->ops.pm_notify)
4388 bus->ops.pm_notify(bus);
4391 static void hda_keep_power_on(struct hda_codec *codec)
4393 spin_lock(&codec->power_lock);
4394 codec->power_count++;
4395 codec->power_on = 1;
4396 codec->power_jiffies = jiffies;
4397 spin_unlock(&codec->power_lock);
4400 /* update the power on/off account with the current jiffies */
4401 void snd_hda_update_power_acct(struct hda_codec *codec)
4403 unsigned long delta = jiffies - codec->power_jiffies;
4404 if (codec->power_on)
4405 codec->power_on_acct += delta;
4407 codec->power_off_acct += delta;
4408 codec->power_jiffies += delta;
4411 /* Transition to powered up, if wait_power_down then wait for a pending
4412 * transition to D3 to complete. A pending D3 transition is indicated
4413 * with power_transition == -1. */
4414 /* call this with codec->power_lock held! */
4415 static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
4417 struct hda_bus *bus = codec->bus;
4419 /* Return if power_on or transitioning to power_on, unless currently
4421 if ((codec->power_on || codec->power_transition > 0) &&
4422 !(wait_power_down && codec->power_transition < 0))
4424 spin_unlock(&codec->power_lock);
4426 cancel_delayed_work_sync(&codec->power_work);
4428 spin_lock(&codec->power_lock);
4429 /* If the power down delayed work was cancelled above before starting,
4430 * then there is no need to go through power up here.
4432 if (codec->power_on)
4435 trace_hda_power_up(codec);
4436 snd_hda_update_power_acct(codec);
4437 codec->power_on = 1;
4438 codec->power_jiffies = jiffies;
4439 codec->power_transition = 1; /* avoid reentrance */
4440 spin_unlock(&codec->power_lock);
4442 if (bus->ops.pm_notify)
4443 bus->ops.pm_notify(bus);
4444 hda_call_codec_resume(codec);
4446 spin_lock(&codec->power_lock);
4447 codec->power_transition = 0;
4450 #define power_save(codec) \
4451 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4453 /* Transition to powered down */
4454 static void __snd_hda_power_down(struct hda_codec *codec)
4456 if (!codec->power_on || codec->power_count || codec->power_transition)
4459 if (power_save(codec)) {
4460 codec->power_transition = -1; /* avoid reentrance */
4461 queue_delayed_work(codec->bus->workq, &codec->power_work,
4462 msecs_to_jiffies(power_save(codec) * 1000));
4467 * snd_hda_power_save - Power-up/down/sync the codec
4468 * @codec: HD-audio codec
4469 * @delta: the counter delta to change
4471 * Change the power-up counter via @delta, and power up or down the hardware
4472 * appropriately. For the power-down, queue to the delayed action.
4473 * Passing zero to @delta means to synchronize the power state.
4475 void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait)
4477 spin_lock(&codec->power_lock);
4478 codec->power_count += delta;
4479 trace_hda_power_count(codec);
4481 __snd_hda_power_up(codec, d3wait);
4483 __snd_hda_power_down(codec);
4484 spin_unlock(&codec->power_lock);
4486 EXPORT_SYMBOL_HDA(snd_hda_power_save);
4489 * snd_hda_check_amp_list_power - Check the amp list and update the power
4490 * @codec: HD-audio codec
4491 * @check: the object containing an AMP list and the status
4492 * @nid: NID to check / update
4494 * Check whether the given NID is in the amp list. If it's in the list,
4495 * check the current AMP status, and update the the power-status according
4496 * to the mute status.
4498 * This function is supposed to be set or called from the check_power_status
4501 int snd_hda_check_amp_list_power(struct hda_codec *codec,
4502 struct hda_loopback_check *check,
4505 const struct hda_amp_list *p;
4508 if (!check->amplist)
4510 for (p = check->amplist; p->nid; p++) {
4515 return 0; /* nothing changed */
4517 for (p = check->amplist; p->nid; p++) {
4518 for (ch = 0; ch < 2; ch++) {
4519 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4521 if (!(v & HDA_AMP_MUTE) && v > 0) {
4522 if (!check->power_on) {
4523 check->power_on = 1;
4524 snd_hda_power_up(codec);
4530 if (check->power_on) {
4531 check->power_on = 0;
4532 snd_hda_power_down(codec);
4536 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
4540 * Channel mode helper
4544 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4546 int snd_hda_ch_mode_info(struct hda_codec *codec,
4547 struct snd_ctl_elem_info *uinfo,
4548 const struct hda_channel_mode *chmode,
4551 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4553 uinfo->value.enumerated.items = num_chmodes;
4554 if (uinfo->value.enumerated.item >= num_chmodes)
4555 uinfo->value.enumerated.item = num_chmodes - 1;
4556 sprintf(uinfo->value.enumerated.name, "%dch",
4557 chmode[uinfo->value.enumerated.item].channels);
4560 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4563 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4565 int snd_hda_ch_mode_get(struct hda_codec *codec,
4566 struct snd_ctl_elem_value *ucontrol,
4567 const struct hda_channel_mode *chmode,
4573 for (i = 0; i < num_chmodes; i++) {
4574 if (max_channels == chmode[i].channels) {
4575 ucontrol->value.enumerated.item[0] = i;
4581 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4584 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4586 int snd_hda_ch_mode_put(struct hda_codec *codec,
4587 struct snd_ctl_elem_value *ucontrol,
4588 const struct hda_channel_mode *chmode,
4594 mode = ucontrol->value.enumerated.item[0];
4595 if (mode >= num_chmodes)
4597 if (*max_channelsp == chmode[mode].channels)
4599 /* change the current channel setting */
4600 *max_channelsp = chmode[mode].channels;
4601 if (chmode[mode].sequence)
4602 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4605 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4612 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4614 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4615 struct snd_ctl_elem_info *uinfo)
4619 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4621 uinfo->value.enumerated.items = imux->num_items;
4622 if (!imux->num_items)
4624 index = uinfo->value.enumerated.item;
4625 if (index >= imux->num_items)
4626 index = imux->num_items - 1;
4627 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4630 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4633 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4635 int snd_hda_input_mux_put(struct hda_codec *codec,
4636 const struct hda_input_mux *imux,
4637 struct snd_ctl_elem_value *ucontrol,
4639 unsigned int *cur_val)
4643 if (!imux->num_items)
4645 idx = ucontrol->value.enumerated.item[0];
4646 if (idx >= imux->num_items)
4647 idx = imux->num_items - 1;
4648 if (*cur_val == idx)
4650 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4651 imux->items[idx].index);
4655 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4659 * Multi-channel / digital-out PCM helper functions
4662 /* setup SPDIF output stream */
4663 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4664 unsigned int stream_tag, unsigned int format)
4666 struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4668 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4669 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4670 set_dig_out_convert(codec, nid,
4671 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
4673 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4674 if (codec->slave_dig_outs) {
4676 for (d = codec->slave_dig_outs; *d; d++)
4677 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4680 /* turn on again (if needed) */
4681 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4682 set_dig_out_convert(codec, nid,
4683 spdif->ctls & 0xff, -1);
4686 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4688 snd_hda_codec_cleanup_stream(codec, nid);
4689 if (codec->slave_dig_outs) {
4691 for (d = codec->slave_dig_outs; *d; d++)
4692 snd_hda_codec_cleanup_stream(codec, *d);
4697 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4698 * @bus: HD-audio bus
4700 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4702 struct hda_codec *codec;
4706 list_for_each_entry(codec, &bus->codec_list, list) {
4707 if (hda_codec_is_power_on(codec) &&
4708 codec->patch_ops.reboot_notify)
4709 codec->patch_ops.reboot_notify(codec);
4712 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
4715 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4717 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4718 struct hda_multi_out *mout)
4720 mutex_lock(&codec->spdif_mutex);
4721 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4722 /* already opened as analog dup; reset it once */
4723 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4724 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4725 mutex_unlock(&codec->spdif_mutex);
4728 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
4731 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4733 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4734 struct hda_multi_out *mout,
4735 unsigned int stream_tag,
4736 unsigned int format,
4737 struct snd_pcm_substream *substream)
4739 mutex_lock(&codec->spdif_mutex);
4740 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4741 mutex_unlock(&codec->spdif_mutex);
4744 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
4747 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4749 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4750 struct hda_multi_out *mout)
4752 mutex_lock(&codec->spdif_mutex);
4753 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4754 mutex_unlock(&codec->spdif_mutex);
4757 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4760 * snd_hda_multi_out_dig_close - release the digital out stream
4762 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4763 struct hda_multi_out *mout)
4765 mutex_lock(&codec->spdif_mutex);
4766 mout->dig_out_used = 0;
4767 mutex_unlock(&codec->spdif_mutex);
4770 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
4773 * snd_hda_multi_out_analog_open - open analog outputs
4775 * Open analog outputs and set up the hw-constraints.
4776 * If the digital outputs can be opened as slave, open the digital
4779 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4780 struct hda_multi_out *mout,
4781 struct snd_pcm_substream *substream,
4782 struct hda_pcm_stream *hinfo)
4784 struct snd_pcm_runtime *runtime = substream->runtime;
4785 runtime->hw.channels_max = mout->max_channels;
4786 if (mout->dig_out_nid) {
4787 if (!mout->analog_rates) {
4788 mout->analog_rates = hinfo->rates;
4789 mout->analog_formats = hinfo->formats;
4790 mout->analog_maxbps = hinfo->maxbps;
4792 runtime->hw.rates = mout->analog_rates;
4793 runtime->hw.formats = mout->analog_formats;
4794 hinfo->maxbps = mout->analog_maxbps;
4796 if (!mout->spdif_rates) {
4797 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4799 &mout->spdif_formats,
4800 &mout->spdif_maxbps);
4802 mutex_lock(&codec->spdif_mutex);
4803 if (mout->share_spdif) {
4804 if ((runtime->hw.rates & mout->spdif_rates) &&
4805 (runtime->hw.formats & mout->spdif_formats)) {
4806 runtime->hw.rates &= mout->spdif_rates;
4807 runtime->hw.formats &= mout->spdif_formats;
4808 if (mout->spdif_maxbps < hinfo->maxbps)
4809 hinfo->maxbps = mout->spdif_maxbps;
4811 mout->share_spdif = 0;
4812 /* FIXME: need notify? */
4815 mutex_unlock(&codec->spdif_mutex);
4817 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4818 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4820 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
4823 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4825 * Set up the i/o for analog out.
4826 * When the digital out is available, copy the front out to digital out, too.
4828 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4829 struct hda_multi_out *mout,
4830 unsigned int stream_tag,
4831 unsigned int format,
4832 struct snd_pcm_substream *substream)
4834 const hda_nid_t *nids = mout->dac_nids;
4835 int chs = substream->runtime->channels;
4836 struct hda_spdif_out *spdif;
4839 mutex_lock(&codec->spdif_mutex);
4840 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
4841 if (mout->dig_out_nid && mout->share_spdif &&
4842 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4844 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4846 !(spdif->status & IEC958_AES0_NONAUDIO)) {
4847 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4848 setup_dig_out_stream(codec, mout->dig_out_nid,
4849 stream_tag, format);
4851 mout->dig_out_used = 0;
4852 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4855 mutex_unlock(&codec->spdif_mutex);
4858 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4860 if (!mout->no_share_stream &&
4861 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4862 /* headphone out will just decode front left/right (stereo) */
4863 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4865 /* extra outputs copied from front */
4866 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4867 if (!mout->no_share_stream && mout->hp_out_nid[i])
4868 snd_hda_codec_setup_stream(codec,
4869 mout->hp_out_nid[i],
4870 stream_tag, 0, format);
4871 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4872 if (!mout->no_share_stream && mout->extra_out_nid[i])
4873 snd_hda_codec_setup_stream(codec,
4874 mout->extra_out_nid[i],
4875 stream_tag, 0, format);
4878 for (i = 1; i < mout->num_dacs; i++) {
4879 if (chs >= (i + 1) * 2) /* independent out */
4880 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4882 else if (!mout->no_share_stream) /* copy front */
4883 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4888 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
4891 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4893 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4894 struct hda_multi_out *mout)
4896 const hda_nid_t *nids = mout->dac_nids;
4899 for (i = 0; i < mout->num_dacs; i++)
4900 snd_hda_codec_cleanup_stream(codec, nids[i]);
4902 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4903 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4904 if (mout->hp_out_nid[i])
4905 snd_hda_codec_cleanup_stream(codec,
4906 mout->hp_out_nid[i]);
4907 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4908 if (mout->extra_out_nid[i])
4909 snd_hda_codec_cleanup_stream(codec,
4910 mout->extra_out_nid[i]);
4911 mutex_lock(&codec->spdif_mutex);
4912 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4913 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4914 mout->dig_out_used = 0;
4916 mutex_unlock(&codec->spdif_mutex);
4919 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4922 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
4924 * Guess the suitable VREF pin bits to be set as the pin-control value.
4925 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
4927 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
4929 unsigned int pincap;
4930 unsigned int oldval;
4931 oldval = snd_hda_codec_read(codec, pin, 0,
4932 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4933 pincap = snd_hda_query_pin_caps(codec, pin);
4934 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
4935 /* Exception: if the default pin setup is vref50, we give it priority */
4936 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
4937 return AC_PINCTL_VREF_80;
4938 else if (pincap & AC_PINCAP_VREF_50)
4939 return AC_PINCTL_VREF_50;
4940 else if (pincap & AC_PINCAP_VREF_100)
4941 return AC_PINCTL_VREF_100;
4942 else if (pincap & AC_PINCAP_VREF_GRD)
4943 return AC_PINCTL_VREF_GRD;
4944 return AC_PINCTL_VREF_HIZ;
4946 EXPORT_SYMBOL_HDA(snd_hda_get_default_vref);
4948 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
4949 unsigned int val, bool cached)
4952 unsigned int cap = snd_hda_query_pin_caps(codec, pin);
4953 if (cap && (val & AC_PINCTL_OUT_EN)) {
4954 if (!(cap & AC_PINCAP_OUT))
4955 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
4956 else if ((val & AC_PINCTL_HP_EN) &&
4957 !(cap & AC_PINCAP_HP_DRV))
4958 val &= ~AC_PINCTL_HP_EN;
4960 if (cap && (val & AC_PINCTL_IN_EN)) {
4961 if (!(cap & AC_PINCAP_IN))
4962 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
4966 return snd_hda_codec_update_cache(codec, pin, 0,
4967 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4969 return snd_hda_codec_write(codec, pin, 0,
4970 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4972 EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl);
4975 * snd_hda_add_imux_item - Add an item to input_mux
4977 * When the same label is used already in the existing items, the number
4978 * suffix is appended to the label. This label index number is stored
4979 * to type_idx when non-NULL pointer is given.
4981 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
4982 int index, int *type_idx)
4984 int i, label_idx = 0;
4985 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
4986 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
4989 for (i = 0; i < imux->num_items; i++) {
4990 if (!strncmp(label, imux->items[i].label, strlen(label)))
4994 *type_idx = label_idx;
4996 snprintf(imux->items[imux->num_items].label,
4997 sizeof(imux->items[imux->num_items].label),
4998 "%s %d", label, label_idx);
5000 strlcpy(imux->items[imux->num_items].label, label,
5001 sizeof(imux->items[imux->num_items].label));
5002 imux->items[imux->num_items].index = index;
5006 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5015 * snd_hda_suspend - suspend the codecs
5018 * Returns 0 if successful.
5020 int snd_hda_suspend(struct hda_bus *bus)
5022 struct hda_codec *codec;
5024 list_for_each_entry(codec, &bus->codec_list, list) {
5025 if (hda_codec_is_power_on(codec))
5026 hda_call_codec_suspend(codec);
5030 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5033 * snd_hda_resume - resume the codecs
5036 * Returns 0 if successful.
5038 * This function is defined only when POWER_SAVE isn't set.
5039 * In the power-save mode, the codec is resumed dynamically.
5041 int snd_hda_resume(struct hda_bus *bus)
5043 struct hda_codec *codec;
5045 list_for_each_entry(codec, &bus->codec_list, list) {
5046 hda_call_codec_resume(codec);
5050 EXPORT_SYMBOL_HDA(snd_hda_resume);
5051 #endif /* CONFIG_PM */
5058 * snd_array_new - get a new element from the given array
5059 * @array: the array object
5061 * Get a new element from the given array. If it exceeds the
5062 * pre-allocated array size, re-allocate the array.
5064 * Returns NULL if allocation failed.
5066 void *snd_array_new(struct snd_array *array)
5068 if (array->used >= array->alloced) {
5069 int num = array->alloced + array->alloc_align;
5070 int size = (num + 1) * array->elem_size;
5071 int oldsize = array->alloced * array->elem_size;
5073 if (snd_BUG_ON(num >= 4096))
5075 nlist = krealloc(array->list, size, GFP_KERNEL);
5078 memset(nlist + oldsize, 0, size - oldsize);
5079 array->list = nlist;
5080 array->alloced = num;
5082 return snd_array_elem(array, array->used++);
5084 EXPORT_SYMBOL_HDA(snd_array_new);
5087 * snd_array_free - free the given array elements
5088 * @array: the array object
5090 void snd_array_free(struct snd_array *array)
5097 EXPORT_SYMBOL_HDA(snd_array_free);
5100 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5101 * @pcm: PCM caps bits
5102 * @buf: the string buffer to write
5103 * @buflen: the max buffer length
5105 * used by hda_proc.c and hda_eld.c
5107 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5109 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5112 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5113 if (pcm & (AC_SUPPCM_BITS_8 << i))
5114 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5116 buf[j] = '\0'; /* necessary when j == 0 */
5118 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5120 MODULE_DESCRIPTION("HDA codec core");
5121 MODULE_LICENSE("GPL");