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
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/pci.h>
26 #include <linux/mutex.h>
27 #include <sound/core.h>
28 #include "hda_codec.h"
29 #include <sound/asoundef.h>
30 #include <sound/tlv.h>
31 #include <sound/initval.h>
32 #include "hda_local.h"
33 #include <sound/hda_hwdep.h>
34 #include "hda_patch.h" /* codec presets */
36 #ifdef CONFIG_SND_HDA_POWER_SAVE
37 /* define this option here to hide as static */
38 static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT;
39 module_param(power_save, int, 0644);
40 MODULE_PARM_DESC(power_save, "Automatic power-saving timeout "
41 "(in second, 0 = disable).");
45 * vendor / preset table
48 struct hda_vendor_id {
53 /* codec vendor labels */
54 static struct hda_vendor_id hda_vendor_ids[] = {
56 { 0x1057, "Motorola" },
57 { 0x1095, "Silicon Image" },
58 { 0x10ec, "Realtek" },
62 { 0x11d4, "Analog Devices" },
63 { 0x13f6, "C-Media" },
64 { 0x14f1, "Conexant" },
65 { 0x17e8, "Chrontel" },
67 { 0x1aec, "Wolfson Microelectronics" },
68 { 0x434d, "C-Media" },
69 { 0x8384, "SigmaTel" },
73 static const struct hda_codec_preset *hda_preset_tables[] = {
74 #ifdef CONFIG_SND_HDA_CODEC_REALTEK
75 snd_hda_preset_realtek,
77 #ifdef CONFIG_SND_HDA_CODEC_CMEDIA
78 snd_hda_preset_cmedia,
80 #ifdef CONFIG_SND_HDA_CODEC_ANALOG
81 snd_hda_preset_analog,
83 #ifdef CONFIG_SND_HDA_CODEC_SIGMATEL
84 snd_hda_preset_sigmatel,
86 #ifdef CONFIG_SND_HDA_CODEC_SI3054
87 snd_hda_preset_si3054,
89 #ifdef CONFIG_SND_HDA_CODEC_ATIHDMI
90 snd_hda_preset_atihdmi,
92 #ifdef CONFIG_SND_HDA_CODEC_CONEXANT
93 snd_hda_preset_conexant,
95 #ifdef CONFIG_SND_HDA_CODEC_VIA
98 #ifdef CONFIG_SND_HDA_CODEC_NVHDMI
99 snd_hda_preset_nvhdmi,
101 #ifdef CONFIG_SND_HDA_CODEC_INTELHDMI
102 snd_hda_preset_intelhdmi,
107 #ifdef CONFIG_SND_HDA_POWER_SAVE
108 static void hda_power_work(struct work_struct *work);
109 static void hda_keep_power_on(struct hda_codec *codec);
111 static inline void hda_keep_power_on(struct hda_codec *codec) {}
114 const char *snd_hda_get_jack_location(u32 cfg)
116 static char *bases[7] = {
117 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
119 static unsigned char specials_idx[] = {
124 static char *specials[] = {
125 "Rear Panel", "Drive Bar",
126 "Riser", "HDMI", "ATAPI",
127 "Mobile-In", "Mobile-Out"
130 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
131 if ((cfg & 0x0f) < 7)
132 return bases[cfg & 0x0f];
133 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
134 if (cfg == specials_idx[i])
140 const char *snd_hda_get_jack_connectivity(u32 cfg)
142 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
144 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
147 const char *snd_hda_get_jack_type(u32 cfg)
149 static char *jack_types[16] = {
150 "Line Out", "Speaker", "HP Out", "CD",
151 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
152 "Line In", "Aux", "Mic", "Telephony",
153 "SPDIF In", "Digitial In", "Reserved", "Other"
156 return jack_types[(cfg & AC_DEFCFG_DEVICE)
157 >> AC_DEFCFG_DEVICE_SHIFT];
161 * Compose a 32bit command word to be sent to the HD-audio controller
163 static inline unsigned int
164 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
165 unsigned int verb, unsigned int parm)
169 val = (u32)(codec->addr & 0x0f) << 28;
170 val |= (u32)direct << 27;
171 val |= (u32)nid << 20;
178 * snd_hda_codec_read - send a command and get the response
179 * @codec: the HDA codec
180 * @nid: NID to send the command
181 * @direct: direct flag
182 * @verb: the verb to send
183 * @parm: the parameter for the verb
185 * Send a single command and read the corresponding response.
187 * Returns the obtained response value, or -1 for an error.
189 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
191 unsigned int verb, unsigned int parm)
193 struct hda_bus *bus = codec->bus;
196 res = make_codec_cmd(codec, nid, direct, verb, parm);
197 snd_hda_power_up(codec);
198 mutex_lock(&bus->cmd_mutex);
199 if (!bus->ops.command(bus, res))
200 res = bus->ops.get_response(bus);
202 res = (unsigned int)-1;
203 mutex_unlock(&bus->cmd_mutex);
204 snd_hda_power_down(codec);
209 * snd_hda_codec_write - send a single command without waiting for response
210 * @codec: the HDA codec
211 * @nid: NID to send the command
212 * @direct: direct flag
213 * @verb: the verb to send
214 * @parm: the parameter for the verb
216 * Send a single command without waiting for response.
218 * Returns 0 if successful, or a negative error code.
220 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
221 unsigned int verb, unsigned int parm)
223 struct hda_bus *bus = codec->bus;
227 res = make_codec_cmd(codec, nid, direct, verb, parm);
228 snd_hda_power_up(codec);
229 mutex_lock(&bus->cmd_mutex);
230 err = bus->ops.command(bus, res);
231 mutex_unlock(&bus->cmd_mutex);
232 snd_hda_power_down(codec);
237 * snd_hda_sequence_write - sequence writes
238 * @codec: the HDA codec
239 * @seq: VERB array to send
241 * Send the commands sequentially from the given array.
242 * The array must be terminated with NID=0.
244 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
246 for (; seq->nid; seq++)
247 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
251 * snd_hda_get_sub_nodes - get the range of sub nodes
252 * @codec: the HDA codec
254 * @start_id: the pointer to store the start NID
256 * Parse the NID and store the start NID of its sub-nodes.
257 * Returns the number of sub-nodes.
259 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
264 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
267 *start_id = (parm >> 16) & 0x7fff;
268 return (int)(parm & 0x7fff);
272 * snd_hda_get_connections - get connection list
273 * @codec: the HDA codec
275 * @conn_list: connection list array
276 * @max_conns: max. number of connections to store
278 * Parses the connection list of the given widget and stores the list
281 * Returns the number of connections, or a negative error code.
283 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
284 hda_nid_t *conn_list, int max_conns)
287 int i, conn_len, conns;
288 unsigned int shift, num_elems, mask;
291 if (snd_BUG_ON(!conn_list || max_conns <= 0))
294 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
295 if (parm & AC_CLIST_LONG) {
304 conn_len = parm & AC_CLIST_LENGTH;
305 mask = (1 << (shift-1)) - 1;
308 return 0; /* no connection */
311 /* single connection */
312 parm = snd_hda_codec_read(codec, nid, 0,
313 AC_VERB_GET_CONNECT_LIST, 0);
314 conn_list[0] = parm & mask;
318 /* multi connection */
321 for (i = 0; i < conn_len; i++) {
325 if (i % num_elems == 0)
326 parm = snd_hda_codec_read(codec, nid, 0,
327 AC_VERB_GET_CONNECT_LIST, i);
328 range_val = !!(parm & (1 << (shift-1))); /* ranges */
332 /* ranges between the previous and this one */
333 if (!prev_nid || prev_nid >= val) {
334 snd_printk(KERN_WARNING "hda_codec: "
335 "invalid dep_range_val %x:%x\n",
339 for (n = prev_nid + 1; n <= val; n++) {
340 if (conns >= max_conns) {
342 "Too many connections\n");
345 conn_list[conns++] = n;
348 if (conns >= max_conns) {
349 snd_printk(KERN_ERR "Too many connections\n");
352 conn_list[conns++] = val;
361 * snd_hda_queue_unsol_event - add an unsolicited event to queue
363 * @res: unsolicited event (lower 32bit of RIRB entry)
364 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
366 * Adds the given event to the queue. The events are processed in
367 * the workqueue asynchronously. Call this function in the interrupt
368 * hanlder when RIRB receives an unsolicited event.
370 * Returns 0 if successful, or a negative error code.
372 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
374 struct hda_bus_unsolicited *unsol;
381 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
385 unsol->queue[wp] = res;
386 unsol->queue[wp + 1] = res_ex;
388 schedule_work(&unsol->work);
394 * process queued unsolicited events
396 static void process_unsol_events(struct work_struct *work)
398 struct hda_bus_unsolicited *unsol =
399 container_of(work, struct hda_bus_unsolicited, work);
400 struct hda_bus *bus = unsol->bus;
401 struct hda_codec *codec;
402 unsigned int rp, caddr, res;
404 while (unsol->rp != unsol->wp) {
405 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
408 res = unsol->queue[rp];
409 caddr = unsol->queue[rp + 1];
410 if (!(caddr & (1 << 4))) /* no unsolicited event? */
412 codec = bus->caddr_tbl[caddr & 0x0f];
413 if (codec && codec->patch_ops.unsol_event)
414 codec->patch_ops.unsol_event(codec, res);
419 * initialize unsolicited queue
421 static int init_unsol_queue(struct hda_bus *bus)
423 struct hda_bus_unsolicited *unsol;
425 if (bus->unsol) /* already initialized */
428 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
430 snd_printk(KERN_ERR "hda_codec: "
431 "can't allocate unsolicited queue\n");
434 INIT_WORK(&unsol->work, process_unsol_events);
443 static void snd_hda_codec_free(struct hda_codec *codec);
445 static int snd_hda_bus_free(struct hda_bus *bus)
447 struct hda_codec *codec, *n;
452 flush_scheduled_work();
455 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
456 snd_hda_codec_free(codec);
458 if (bus->ops.private_free)
459 bus->ops.private_free(bus);
464 static int snd_hda_bus_dev_free(struct snd_device *device)
466 struct hda_bus *bus = device->device_data;
468 return snd_hda_bus_free(bus);
471 #ifdef CONFIG_SND_HDA_HWDEP
472 static int snd_hda_bus_dev_register(struct snd_device *device)
474 struct hda_bus *bus = device->device_data;
475 struct hda_codec *codec;
476 list_for_each_entry(codec, &bus->codec_list, list) {
477 snd_hda_hwdep_add_sysfs(codec);
482 #define snd_hda_bus_dev_register NULL
486 * snd_hda_bus_new - create a HDA bus
487 * @card: the card entry
488 * @temp: the template for hda_bus information
489 * @busp: the pointer to store the created bus instance
491 * Returns 0 if successful, or a negative error code.
493 int __devinit snd_hda_bus_new(struct snd_card *card,
494 const struct hda_bus_template *temp,
495 struct hda_bus **busp)
499 static struct snd_device_ops dev_ops = {
500 .dev_register = snd_hda_bus_dev_register,
501 .dev_free = snd_hda_bus_dev_free,
504 if (snd_BUG_ON(!temp))
506 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
512 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
514 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
519 bus->private_data = temp->private_data;
520 bus->pci = temp->pci;
521 bus->modelname = temp->modelname;
522 bus->ops = temp->ops;
524 mutex_init(&bus->cmd_mutex);
525 INIT_LIST_HEAD(&bus->codec_list);
527 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
529 snd_hda_bus_free(bus);
537 #ifdef CONFIG_SND_HDA_GENERIC
538 #define is_generic_config(codec) \
539 (codec->modelname && !strcmp(codec->modelname, "generic"))
541 #define is_generic_config(codec) 0
545 * find a matching codec preset
547 static const struct hda_codec_preset *
548 find_codec_preset(struct hda_codec *codec)
550 const struct hda_codec_preset **tbl, *preset;
552 if (is_generic_config(codec))
553 return NULL; /* use the generic parser */
555 for (tbl = hda_preset_tables; *tbl; tbl++) {
556 for (preset = *tbl; preset->id; preset++) {
557 u32 mask = preset->mask;
558 if (preset->afg && preset->afg != codec->afg)
560 if (preset->mfg && preset->mfg != codec->mfg)
564 if (preset->id == (codec->vendor_id & mask) &&
566 preset->rev == codec->revision_id))
574 * get_codec_name - store the codec name
576 static int get_codec_name(struct hda_codec *codec)
578 const struct hda_vendor_id *c;
579 const char *vendor = NULL;
580 u16 vendor_id = codec->vendor_id >> 16;
581 char tmp[16], name[32];
583 for (c = hda_vendor_ids; c->id; c++) {
584 if (c->id == vendor_id) {
590 sprintf(tmp, "Generic %04x", vendor_id);
593 if (codec->preset && codec->preset->name)
594 snprintf(name, sizeof(name), "%s %s", vendor,
595 codec->preset->name);
597 snprintf(name, sizeof(name), "%s ID %x", vendor,
598 codec->vendor_id & 0xffff);
599 codec->name = kstrdup(name, GFP_KERNEL);
606 * look for an AFG and MFG nodes
608 static void __devinit setup_fg_nodes(struct hda_codec *codec)
613 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
614 for (i = 0; i < total_nodes; i++, nid++) {
616 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
617 switch (func & 0xff) {
618 case AC_GRP_AUDIO_FUNCTION:
621 case AC_GRP_MODEM_FUNCTION:
631 * read widget caps for each widget and store in cache
633 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
638 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
640 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
643 nid = codec->start_nid;
644 for (i = 0; i < codec->num_nodes; i++, nid++)
645 codec->wcaps[i] = snd_hda_param_read(codec, nid,
646 AC_PAR_AUDIO_WIDGET_CAP);
651 static void init_hda_cache(struct hda_cache_rec *cache,
652 unsigned int record_size);
653 static void free_hda_cache(struct hda_cache_rec *cache);
658 static void snd_hda_codec_free(struct hda_codec *codec)
662 #ifdef CONFIG_SND_HDA_POWER_SAVE
663 cancel_delayed_work(&codec->power_work);
664 flush_scheduled_work();
666 list_del(&codec->list);
667 snd_array_free(&codec->mixers);
668 codec->bus->caddr_tbl[codec->addr] = NULL;
669 if (codec->patch_ops.free)
670 codec->patch_ops.free(codec);
671 free_hda_cache(&codec->amp_cache);
672 free_hda_cache(&codec->cmd_cache);
674 kfree(codec->modelname);
680 * snd_hda_codec_new - create a HDA codec
681 * @bus: the bus to assign
682 * @codec_addr: the codec address
683 * @codecp: the pointer to store the generated codec
685 * Returns 0 if successful, or a negative error code.
687 int __devinit snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
688 struct hda_codec **codecp)
690 struct hda_codec *codec;
694 if (snd_BUG_ON(!bus))
696 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
699 if (bus->caddr_tbl[codec_addr]) {
700 snd_printk(KERN_ERR "hda_codec: "
701 "address 0x%x is already occupied\n", codec_addr);
705 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
707 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
712 codec->addr = codec_addr;
713 mutex_init(&codec->spdif_mutex);
714 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
715 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
716 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
717 if (codec->bus->modelname) {
718 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
719 if (!codec->modelname) {
720 snd_hda_codec_free(codec);
725 #ifdef CONFIG_SND_HDA_POWER_SAVE
726 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
727 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
728 * the caller has to power down appropriatley after initialization
731 hda_keep_power_on(codec);
734 list_add_tail(&codec->list, &bus->codec_list);
735 bus->caddr_tbl[codec_addr] = codec;
737 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
739 if (codec->vendor_id == -1)
740 /* read again, hopefully the access method was corrected
741 * in the last read...
743 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
745 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
746 AC_PAR_SUBSYSTEM_ID);
747 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
750 setup_fg_nodes(codec);
751 if (!codec->afg && !codec->mfg) {
752 snd_printdd("hda_codec: no AFG or MFG node found\n");
753 snd_hda_codec_free(codec);
757 if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) {
758 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
759 snd_hda_codec_free(codec);
763 if (!codec->subsystem_id) {
764 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
765 codec->subsystem_id =
766 snd_hda_codec_read(codec, nid, 0,
767 AC_VERB_GET_SUBSYSTEM_ID, 0);
770 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
772 err = snd_hda_codec_configure(codec);
774 snd_hda_codec_free(codec);
777 snd_hda_codec_proc_new(codec);
779 snd_hda_create_hwdep(codec);
781 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
782 codec->subsystem_id, codec->revision_id);
783 snd_component_add(codec->bus->card, component);
790 int snd_hda_codec_configure(struct hda_codec *codec)
794 codec->preset = find_codec_preset(codec);
796 err = get_codec_name(codec);
800 /* audio codec should override the mixer name */
801 if (codec->afg || !*codec->bus->card->mixername)
802 strlcpy(codec->bus->card->mixername, codec->name,
803 sizeof(codec->bus->card->mixername));
805 if (is_generic_config(codec)) {
806 err = snd_hda_parse_generic_codec(codec);
809 if (codec->preset && codec->preset->patch) {
810 err = codec->preset->patch(codec);
814 /* call the default parser */
815 err = snd_hda_parse_generic_codec(codec);
817 printk(KERN_ERR "hda-codec: No codec parser is available\n");
820 if (!err && codec->patch_ops.unsol_event)
821 err = init_unsol_queue(codec->bus);
826 * snd_hda_codec_setup_stream - set up the codec for streaming
827 * @codec: the CODEC to set up
828 * @nid: the NID to set up
829 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
830 * @channel_id: channel id to pass, zero based.
831 * @format: stream format.
833 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
835 int channel_id, int format)
840 snd_printdd("hda_codec_setup_stream: "
841 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
842 nid, stream_tag, channel_id, format);
843 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
844 (stream_tag << 4) | channel_id);
846 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
849 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
854 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
855 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
856 #if 0 /* keep the format */
858 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
863 * amp access functions
866 /* FIXME: more better hash key? */
867 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
868 #define INFO_AMP_CAPS (1<<0)
869 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
871 /* initialize the hash table */
872 static void __devinit init_hda_cache(struct hda_cache_rec *cache,
873 unsigned int record_size)
875 memset(cache, 0, sizeof(*cache));
876 memset(cache->hash, 0xff, sizeof(cache->hash));
877 snd_array_init(&cache->buf, record_size, 64);
880 static void free_hda_cache(struct hda_cache_rec *cache)
882 snd_array_free(&cache->buf);
885 /* query the hash. allocate an entry if not found. */
886 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
889 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
890 u16 cur = cache->hash[idx];
891 struct hda_cache_head *info;
893 while (cur != 0xffff) {
894 info = snd_array_elem(&cache->buf, cur);
895 if (info->key == key)
900 /* add a new hash entry */
901 info = snd_array_new(&cache->buf);
904 cur = snd_array_index(&cache->buf, info);
907 info->next = cache->hash[idx];
908 cache->hash[idx] = cur;
913 /* query and allocate an amp hash entry */
914 static inline struct hda_amp_info *
915 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
917 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
921 * query AMP capabilities for the given widget and direction
923 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
925 struct hda_amp_info *info;
927 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
930 if (!(info->head.val & INFO_AMP_CAPS)) {
931 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
933 info->amp_caps = snd_hda_param_read(codec, nid,
934 direction == HDA_OUTPUT ?
938 info->head.val |= INFO_AMP_CAPS;
940 return info->amp_caps;
943 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
946 struct hda_amp_info *info;
948 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
951 info->amp_caps = caps;
952 info->head.val |= INFO_AMP_CAPS;
957 * read the current volume to info
958 * if the cache exists, read the cache value.
960 static unsigned int get_vol_mute(struct hda_codec *codec,
961 struct hda_amp_info *info, hda_nid_t nid,
962 int ch, int direction, int index)
966 if (info->head.val & INFO_AMP_VOL(ch))
967 return info->vol[ch];
969 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
970 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
972 val = snd_hda_codec_read(codec, nid, 0,
973 AC_VERB_GET_AMP_GAIN_MUTE, parm);
974 info->vol[ch] = val & 0xff;
975 info->head.val |= INFO_AMP_VOL(ch);
976 return info->vol[ch];
980 * write the current volume in info to the h/w and update the cache
982 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
983 hda_nid_t nid, int ch, int direction, int index,
988 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
989 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
990 parm |= index << AC_AMP_SET_INDEX_SHIFT;
992 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
997 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
999 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1000 int direction, int index)
1002 struct hda_amp_info *info;
1003 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1006 return get_vol_mute(codec, info, nid, ch, direction, index);
1010 * update the AMP value, mask = bit mask to set, val = the value
1012 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1013 int direction, int idx, int mask, int val)
1015 struct hda_amp_info *info;
1017 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1021 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1022 if (info->vol[ch] == val)
1024 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1029 * update the AMP stereo with the same mask and value
1031 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1032 int direction, int idx, int mask, int val)
1035 for (ch = 0; ch < 2; ch++)
1036 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1041 #ifdef SND_HDA_NEEDS_RESUME
1042 /* resume the all amp commands from the cache */
1043 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1045 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1048 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1049 u32 key = buffer->head.key;
1051 unsigned int idx, dir, ch;
1055 idx = (key >> 16) & 0xff;
1056 dir = (key >> 24) & 0xff;
1057 for (ch = 0; ch < 2; ch++) {
1058 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1060 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1065 #endif /* SND_HDA_NEEDS_RESUME */
1068 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1069 struct snd_ctl_elem_info *uinfo)
1071 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1072 u16 nid = get_amp_nid(kcontrol);
1073 u8 chs = get_amp_channels(kcontrol);
1074 int dir = get_amp_direction(kcontrol);
1077 caps = query_amp_caps(codec, nid, dir);
1079 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1081 printk(KERN_WARNING "hda_codec: "
1082 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1086 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1087 uinfo->count = chs == 3 ? 2 : 1;
1088 uinfo->value.integer.min = 0;
1089 uinfo->value.integer.max = caps;
1093 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1094 struct snd_ctl_elem_value *ucontrol)
1096 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1097 hda_nid_t nid = get_amp_nid(kcontrol);
1098 int chs = get_amp_channels(kcontrol);
1099 int dir = get_amp_direction(kcontrol);
1100 int idx = get_amp_index(kcontrol);
1101 long *valp = ucontrol->value.integer.value;
1104 *valp++ = snd_hda_codec_amp_read(codec, nid, 0, dir, idx)
1107 *valp = snd_hda_codec_amp_read(codec, nid, 1, dir, idx)
1112 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1113 struct snd_ctl_elem_value *ucontrol)
1115 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1116 hda_nid_t nid = get_amp_nid(kcontrol);
1117 int chs = get_amp_channels(kcontrol);
1118 int dir = get_amp_direction(kcontrol);
1119 int idx = get_amp_index(kcontrol);
1120 long *valp = ucontrol->value.integer.value;
1123 snd_hda_power_up(codec);
1125 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1130 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1132 snd_hda_power_down(codec);
1136 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1137 unsigned int size, unsigned int __user *_tlv)
1139 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1140 hda_nid_t nid = get_amp_nid(kcontrol);
1141 int dir = get_amp_direction(kcontrol);
1142 u32 caps, val1, val2;
1144 if (size < 4 * sizeof(unsigned int))
1146 caps = query_amp_caps(codec, nid, dir);
1147 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1148 val2 = (val2 + 1) * 25;
1149 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1150 val1 = ((int)val1) * ((int)val2);
1151 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1153 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1155 if (put_user(val1, _tlv + 2))
1157 if (put_user(val2, _tlv + 3))
1163 * set (static) TLV for virtual master volume; recalculated as max 0dB
1165 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1171 caps = query_amp_caps(codec, nid, dir);
1172 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1173 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1174 step = (step + 1) * 25;
1175 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1176 tlv[1] = 2 * sizeof(unsigned int);
1177 tlv[2] = -nums * step;
1181 /* find a mixer control element with the given name */
1182 static struct snd_kcontrol *
1183 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1184 const char *name, int idx)
1186 struct snd_ctl_elem_id id;
1187 memset(&id, 0, sizeof(id));
1188 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1190 strcpy(id.name, name);
1191 return snd_ctl_find_id(codec->bus->card, &id);
1194 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1197 return _snd_hda_find_mixer_ctl(codec, name, 0);
1200 /* Add a control element and assign to the codec */
1201 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1204 struct snd_kcontrol **knewp;
1206 err = snd_ctl_add(codec->bus->card, kctl);
1209 knewp = snd_array_new(&codec->mixers);
1216 /* Clear all controls assigned to the given codec */
1217 void snd_hda_ctls_clear(struct hda_codec *codec)
1220 struct snd_kcontrol **kctls = codec->mixers.list;
1221 for (i = 0; i < codec->mixers.used; i++)
1222 snd_ctl_remove(codec->bus->card, kctls[i]);
1223 snd_array_free(&codec->mixers);
1226 void snd_hda_codec_reset(struct hda_codec *codec)
1230 #ifdef CONFIG_SND_HDA_POWER_SAVE
1231 cancel_delayed_work(&codec->power_work);
1232 flush_scheduled_work();
1234 snd_hda_ctls_clear(codec);
1236 for (i = 0; i < codec->num_pcms; i++) {
1237 if (codec->pcm_info[i].pcm)
1238 snd_device_free(codec->bus->card,
1239 codec->pcm_info[i].pcm);
1241 if (codec->patch_ops.free)
1242 codec->patch_ops.free(codec);
1244 free_hda_cache(&codec->amp_cache);
1245 free_hda_cache(&codec->cmd_cache);
1246 codec->num_pcms = 0;
1247 codec->pcm_info = NULL;
1248 codec->preset = NULL;
1251 /* create a virtual master control and add slaves */
1252 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1253 unsigned int *tlv, const char **slaves)
1255 struct snd_kcontrol *kctl;
1259 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1262 snd_printdd("No slave found for %s\n", name);
1265 kctl = snd_ctl_make_virtual_master(name, tlv);
1268 err = snd_hda_ctl_add(codec, kctl);
1272 for (s = slaves; *s; s++) {
1273 struct snd_kcontrol *sctl;
1275 sctl = snd_hda_find_mixer_ctl(codec, *s);
1277 snd_printdd("Cannot find slave %s, skipped\n", *s);
1280 err = snd_ctl_add_slave(kctl, sctl);
1288 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1289 struct snd_ctl_elem_info *uinfo)
1291 int chs = get_amp_channels(kcontrol);
1293 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1294 uinfo->count = chs == 3 ? 2 : 1;
1295 uinfo->value.integer.min = 0;
1296 uinfo->value.integer.max = 1;
1300 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1301 struct snd_ctl_elem_value *ucontrol)
1303 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1304 hda_nid_t nid = get_amp_nid(kcontrol);
1305 int chs = get_amp_channels(kcontrol);
1306 int dir = get_amp_direction(kcontrol);
1307 int idx = get_amp_index(kcontrol);
1308 long *valp = ucontrol->value.integer.value;
1311 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1312 HDA_AMP_MUTE) ? 0 : 1;
1314 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1315 HDA_AMP_MUTE) ? 0 : 1;
1319 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1320 struct snd_ctl_elem_value *ucontrol)
1322 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1323 hda_nid_t nid = get_amp_nid(kcontrol);
1324 int chs = get_amp_channels(kcontrol);
1325 int dir = get_amp_direction(kcontrol);
1326 int idx = get_amp_index(kcontrol);
1327 long *valp = ucontrol->value.integer.value;
1330 snd_hda_power_up(codec);
1332 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1334 *valp ? 0 : HDA_AMP_MUTE);
1338 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1340 *valp ? 0 : HDA_AMP_MUTE);
1341 #ifdef CONFIG_SND_HDA_POWER_SAVE
1342 if (codec->patch_ops.check_power_status)
1343 codec->patch_ops.check_power_status(codec, nid);
1345 snd_hda_power_down(codec);
1350 * bound volume controls
1352 * bind multiple volumes (# indices, from 0)
1355 #define AMP_VAL_IDX_SHIFT 19
1356 #define AMP_VAL_IDX_MASK (0x0f<<19)
1358 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1359 struct snd_ctl_elem_value *ucontrol)
1361 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1365 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1366 pval = kcontrol->private_value;
1367 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1368 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1369 kcontrol->private_value = pval;
1370 mutex_unlock(&codec->spdif_mutex);
1374 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1375 struct snd_ctl_elem_value *ucontrol)
1377 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1379 int i, indices, err = 0, change = 0;
1381 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1382 pval = kcontrol->private_value;
1383 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1384 for (i = 0; i < indices; i++) {
1385 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1386 (i << AMP_VAL_IDX_SHIFT);
1387 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1392 kcontrol->private_value = pval;
1393 mutex_unlock(&codec->spdif_mutex);
1394 return err < 0 ? err : change;
1398 * generic bound volume/swtich controls
1400 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1401 struct snd_ctl_elem_info *uinfo)
1403 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1404 struct hda_bind_ctls *c;
1407 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1408 c = (struct hda_bind_ctls *)kcontrol->private_value;
1409 kcontrol->private_value = *c->values;
1410 err = c->ops->info(kcontrol, uinfo);
1411 kcontrol->private_value = (long)c;
1412 mutex_unlock(&codec->spdif_mutex);
1416 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1417 struct snd_ctl_elem_value *ucontrol)
1419 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1420 struct hda_bind_ctls *c;
1423 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1424 c = (struct hda_bind_ctls *)kcontrol->private_value;
1425 kcontrol->private_value = *c->values;
1426 err = c->ops->get(kcontrol, ucontrol);
1427 kcontrol->private_value = (long)c;
1428 mutex_unlock(&codec->spdif_mutex);
1432 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1433 struct snd_ctl_elem_value *ucontrol)
1435 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1436 struct hda_bind_ctls *c;
1437 unsigned long *vals;
1438 int err = 0, change = 0;
1440 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1441 c = (struct hda_bind_ctls *)kcontrol->private_value;
1442 for (vals = c->values; *vals; vals++) {
1443 kcontrol->private_value = *vals;
1444 err = c->ops->put(kcontrol, ucontrol);
1449 kcontrol->private_value = (long)c;
1450 mutex_unlock(&codec->spdif_mutex);
1451 return err < 0 ? err : change;
1454 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1455 unsigned int size, unsigned int __user *tlv)
1457 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1458 struct hda_bind_ctls *c;
1461 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1462 c = (struct hda_bind_ctls *)kcontrol->private_value;
1463 kcontrol->private_value = *c->values;
1464 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1465 kcontrol->private_value = (long)c;
1466 mutex_unlock(&codec->spdif_mutex);
1470 struct hda_ctl_ops snd_hda_bind_vol = {
1471 .info = snd_hda_mixer_amp_volume_info,
1472 .get = snd_hda_mixer_amp_volume_get,
1473 .put = snd_hda_mixer_amp_volume_put,
1474 .tlv = snd_hda_mixer_amp_tlv
1477 struct hda_ctl_ops snd_hda_bind_sw = {
1478 .info = snd_hda_mixer_amp_switch_info,
1479 .get = snd_hda_mixer_amp_switch_get,
1480 .put = snd_hda_mixer_amp_switch_put,
1481 .tlv = snd_hda_mixer_amp_tlv
1485 * SPDIF out controls
1488 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1489 struct snd_ctl_elem_info *uinfo)
1491 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1496 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1497 struct snd_ctl_elem_value *ucontrol)
1499 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1500 IEC958_AES0_NONAUDIO |
1501 IEC958_AES0_CON_EMPHASIS_5015 |
1502 IEC958_AES0_CON_NOT_COPYRIGHT;
1503 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1504 IEC958_AES1_CON_ORIGINAL;
1508 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1509 struct snd_ctl_elem_value *ucontrol)
1511 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1512 IEC958_AES0_NONAUDIO |
1513 IEC958_AES0_PRO_EMPHASIS_5015;
1517 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1518 struct snd_ctl_elem_value *ucontrol)
1520 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1522 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1523 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1524 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1525 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1530 /* convert from SPDIF status bits to HDA SPDIF bits
1531 * bit 0 (DigEn) is always set zero (to be filled later)
1533 static unsigned short convert_from_spdif_status(unsigned int sbits)
1535 unsigned short val = 0;
1537 if (sbits & IEC958_AES0_PROFESSIONAL)
1538 val |= AC_DIG1_PROFESSIONAL;
1539 if (sbits & IEC958_AES0_NONAUDIO)
1540 val |= AC_DIG1_NONAUDIO;
1541 if (sbits & IEC958_AES0_PROFESSIONAL) {
1542 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1543 IEC958_AES0_PRO_EMPHASIS_5015)
1544 val |= AC_DIG1_EMPHASIS;
1546 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1547 IEC958_AES0_CON_EMPHASIS_5015)
1548 val |= AC_DIG1_EMPHASIS;
1549 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1550 val |= AC_DIG1_COPYRIGHT;
1551 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1552 val |= AC_DIG1_LEVEL;
1553 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1558 /* convert to SPDIF status bits from HDA SPDIF bits
1560 static unsigned int convert_to_spdif_status(unsigned short val)
1562 unsigned int sbits = 0;
1564 if (val & AC_DIG1_NONAUDIO)
1565 sbits |= IEC958_AES0_NONAUDIO;
1566 if (val & AC_DIG1_PROFESSIONAL)
1567 sbits |= IEC958_AES0_PROFESSIONAL;
1568 if (sbits & IEC958_AES0_PROFESSIONAL) {
1569 if (sbits & AC_DIG1_EMPHASIS)
1570 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1572 if (val & AC_DIG1_EMPHASIS)
1573 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1574 if (!(val & AC_DIG1_COPYRIGHT))
1575 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1576 if (val & AC_DIG1_LEVEL)
1577 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1578 sbits |= val & (0x7f << 8);
1583 /* set digital convert verbs both for the given NID and its slaves */
1584 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1589 snd_hda_codec_write(codec, nid, 0, verb, val);
1590 d = codec->slave_dig_outs;
1594 snd_hda_codec_write(codec, *d, 0, verb, val);
1597 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1601 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1603 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1606 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1607 struct snd_ctl_elem_value *ucontrol)
1609 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1610 hda_nid_t nid = kcontrol->private_value;
1614 mutex_lock(&codec->spdif_mutex);
1615 codec->spdif_status = ucontrol->value.iec958.status[0] |
1616 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1617 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1618 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1619 val = convert_from_spdif_status(codec->spdif_status);
1620 val |= codec->spdif_ctls & 1;
1621 change = codec->spdif_ctls != val;
1622 codec->spdif_ctls = val;
1625 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1627 mutex_unlock(&codec->spdif_mutex);
1631 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1633 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1634 struct snd_ctl_elem_value *ucontrol)
1636 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1638 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1642 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1643 struct snd_ctl_elem_value *ucontrol)
1645 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1646 hda_nid_t nid = kcontrol->private_value;
1650 mutex_lock(&codec->spdif_mutex);
1651 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1652 if (ucontrol->value.integer.value[0])
1653 val |= AC_DIG1_ENABLE;
1654 change = codec->spdif_ctls != val;
1656 codec->spdif_ctls = val;
1657 set_dig_out_convert(codec, nid, val & 0xff, -1);
1658 /* unmute amp switch (if any) */
1659 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1660 (val & AC_DIG1_ENABLE))
1661 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1664 mutex_unlock(&codec->spdif_mutex);
1668 static struct snd_kcontrol_new dig_mixes[] = {
1670 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1671 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1672 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1673 .info = snd_hda_spdif_mask_info,
1674 .get = snd_hda_spdif_cmask_get,
1677 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1678 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1679 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1680 .info = snd_hda_spdif_mask_info,
1681 .get = snd_hda_spdif_pmask_get,
1684 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1685 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1686 .info = snd_hda_spdif_mask_info,
1687 .get = snd_hda_spdif_default_get,
1688 .put = snd_hda_spdif_default_put,
1691 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1692 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1693 .info = snd_hda_spdif_out_switch_info,
1694 .get = snd_hda_spdif_out_switch_get,
1695 .put = snd_hda_spdif_out_switch_put,
1700 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1703 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1704 * @codec: the HDA codec
1705 * @nid: audio out widget NID
1707 * Creates controls related with the SPDIF output.
1708 * Called from each patch supporting the SPDIF out.
1710 * Returns 0 if successful, or a negative error code.
1712 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1715 struct snd_kcontrol *kctl;
1716 struct snd_kcontrol_new *dig_mix;
1719 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1720 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1724 if (idx >= SPDIF_MAX_IDX) {
1725 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1728 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1729 kctl = snd_ctl_new1(dig_mix, codec);
1732 kctl->id.index = idx;
1733 kctl->private_value = nid;
1734 err = snd_hda_ctl_add(codec, kctl);
1739 snd_hda_codec_read(codec, nid, 0,
1740 AC_VERB_GET_DIGI_CONVERT_1, 0);
1741 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1746 * SPDIF sharing with analog output
1748 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1749 struct snd_ctl_elem_value *ucontrol)
1751 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1752 ucontrol->value.integer.value[0] = mout->share_spdif;
1756 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1757 struct snd_ctl_elem_value *ucontrol)
1759 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1760 mout->share_spdif = !!ucontrol->value.integer.value[0];
1764 static struct snd_kcontrol_new spdif_share_sw = {
1765 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1766 .name = "IEC958 Default PCM Playback Switch",
1767 .info = snd_ctl_boolean_mono_info,
1768 .get = spdif_share_sw_get,
1769 .put = spdif_share_sw_put,
1772 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
1773 struct hda_multi_out *mout)
1775 if (!mout->dig_out_nid)
1777 /* ATTENTION: here mout is passed as private_data, instead of codec */
1778 return snd_hda_ctl_add(codec,
1779 snd_ctl_new1(&spdif_share_sw, mout));
1786 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
1788 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
1789 struct snd_ctl_elem_value *ucontrol)
1791 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1793 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
1797 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
1798 struct snd_ctl_elem_value *ucontrol)
1800 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1801 hda_nid_t nid = kcontrol->private_value;
1802 unsigned int val = !!ucontrol->value.integer.value[0];
1805 mutex_lock(&codec->spdif_mutex);
1806 change = codec->spdif_in_enable != val;
1808 codec->spdif_in_enable = val;
1809 snd_hda_codec_write_cache(codec, nid, 0,
1810 AC_VERB_SET_DIGI_CONVERT_1, val);
1812 mutex_unlock(&codec->spdif_mutex);
1816 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
1817 struct snd_ctl_elem_value *ucontrol)
1819 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1820 hda_nid_t nid = kcontrol->private_value;
1824 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1825 sbits = convert_to_spdif_status(val);
1826 ucontrol->value.iec958.status[0] = sbits;
1827 ucontrol->value.iec958.status[1] = sbits >> 8;
1828 ucontrol->value.iec958.status[2] = sbits >> 16;
1829 ucontrol->value.iec958.status[3] = sbits >> 24;
1833 static struct snd_kcontrol_new dig_in_ctls[] = {
1835 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1836 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
1837 .info = snd_hda_spdif_in_switch_info,
1838 .get = snd_hda_spdif_in_switch_get,
1839 .put = snd_hda_spdif_in_switch_put,
1842 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1843 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1844 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1845 .info = snd_hda_spdif_mask_info,
1846 .get = snd_hda_spdif_in_status_get,
1852 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1853 * @codec: the HDA codec
1854 * @nid: audio in widget NID
1856 * Creates controls related with the SPDIF input.
1857 * Called from each patch supporting the SPDIF in.
1859 * Returns 0 if successful, or a negative error code.
1861 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1864 struct snd_kcontrol *kctl;
1865 struct snd_kcontrol_new *dig_mix;
1868 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1869 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
1873 if (idx >= SPDIF_MAX_IDX) {
1874 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
1877 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
1878 kctl = snd_ctl_new1(dig_mix, codec);
1879 kctl->private_value = nid;
1880 err = snd_hda_ctl_add(codec, kctl);
1884 codec->spdif_in_enable =
1885 snd_hda_codec_read(codec, nid, 0,
1886 AC_VERB_GET_DIGI_CONVERT_1, 0) &
1891 #ifdef SND_HDA_NEEDS_RESUME
1896 /* build a 32bit cache key with the widget id and the command parameter */
1897 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
1898 #define get_cmd_cache_nid(key) ((key) & 0xff)
1899 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
1902 * snd_hda_codec_write_cache - send a single command with caching
1903 * @codec: the HDA codec
1904 * @nid: NID to send the command
1905 * @direct: direct flag
1906 * @verb: the verb to send
1907 * @parm: the parameter for the verb
1909 * Send a single command without waiting for response.
1911 * Returns 0 if successful, or a negative error code.
1913 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
1914 int direct, unsigned int verb, unsigned int parm)
1916 struct hda_bus *bus = codec->bus;
1920 res = make_codec_cmd(codec, nid, direct, verb, parm);
1921 snd_hda_power_up(codec);
1922 mutex_lock(&bus->cmd_mutex);
1923 err = bus->ops.command(bus, res);
1925 struct hda_cache_head *c;
1926 u32 key = build_cmd_cache_key(nid, verb);
1927 c = get_alloc_hash(&codec->cmd_cache, key);
1931 mutex_unlock(&bus->cmd_mutex);
1932 snd_hda_power_down(codec);
1936 /* resume the all commands from the cache */
1937 void snd_hda_codec_resume_cache(struct hda_codec *codec)
1939 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
1942 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
1943 u32 key = buffer->key;
1946 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
1947 get_cmd_cache_cmd(key), buffer->val);
1952 * snd_hda_sequence_write_cache - sequence writes with caching
1953 * @codec: the HDA codec
1954 * @seq: VERB array to send
1956 * Send the commands sequentially from the given array.
1957 * Thte commands are recorded on cache for power-save and resume.
1958 * The array must be terminated with NID=0.
1960 void snd_hda_sequence_write_cache(struct hda_codec *codec,
1961 const struct hda_verb *seq)
1963 for (; seq->nid; seq++)
1964 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
1967 #endif /* SND_HDA_NEEDS_RESUME */
1970 * set power state of the codec
1972 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1973 unsigned int power_state)
1978 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
1980 msleep(10); /* partial workaround for "azx_get_response timeout" */
1982 nid = codec->start_nid;
1983 for (i = 0; i < codec->num_nodes; i++, nid++) {
1984 unsigned int wcaps = get_wcaps(codec, nid);
1985 if (wcaps & AC_WCAP_POWER) {
1986 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
1988 if (wid_type == AC_WID_PIN) {
1989 unsigned int pincap;
1991 * don't power down the widget if it controls
1992 * eapd and EAPD_BTLENABLE is set.
1994 pincap = snd_hda_param_read(codec, nid,
1996 if (pincap & AC_PINCAP_EAPD) {
1997 int eapd = snd_hda_codec_read(codec,
1999 AC_VERB_GET_EAPD_BTLENABLE, 0);
2001 if (power_state == AC_PWRST_D3 && eapd)
2005 snd_hda_codec_write(codec, nid, 0,
2006 AC_VERB_SET_POWER_STATE,
2011 if (power_state == AC_PWRST_D0) {
2012 unsigned long end_time;
2015 /* wait until the codec reachs to D0 */
2016 end_time = jiffies + msecs_to_jiffies(500);
2018 state = snd_hda_codec_read(codec, fg, 0,
2019 AC_VERB_GET_POWER_STATE, 0);
2020 if (state == power_state)
2023 } while (time_after_eq(end_time, jiffies));
2027 #ifdef CONFIG_SND_HDA_HWDEP
2028 /* execute additional init verbs */
2029 static void hda_exec_init_verbs(struct hda_codec *codec)
2031 if (codec->init_verbs.list)
2032 snd_hda_sequence_write(codec, codec->init_verbs.list);
2035 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2038 #ifdef SND_HDA_NEEDS_RESUME
2040 * call suspend and power-down; used both from PM and power-save
2042 static void hda_call_codec_suspend(struct hda_codec *codec)
2044 if (codec->patch_ops.suspend)
2045 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2046 hda_set_power_state(codec,
2047 codec->afg ? codec->afg : codec->mfg,
2049 #ifdef CONFIG_SND_HDA_POWER_SAVE
2050 cancel_delayed_work(&codec->power_work);
2051 codec->power_on = 0;
2052 codec->power_transition = 0;
2057 * kick up codec; used both from PM and power-save
2059 static void hda_call_codec_resume(struct hda_codec *codec)
2061 hda_set_power_state(codec,
2062 codec->afg ? codec->afg : codec->mfg,
2064 hda_exec_init_verbs(codec);
2065 if (codec->patch_ops.resume)
2066 codec->patch_ops.resume(codec);
2068 if (codec->patch_ops.init)
2069 codec->patch_ops.init(codec);
2070 snd_hda_codec_resume_amp(codec);
2071 snd_hda_codec_resume_cache(codec);
2074 #endif /* SND_HDA_NEEDS_RESUME */
2078 * snd_hda_build_controls - build mixer controls
2081 * Creates mixer controls for each codec included in the bus.
2083 * Returns 0 if successful, otherwise a negative error code.
2085 int __devinit snd_hda_build_controls(struct hda_bus *bus)
2087 struct hda_codec *codec;
2089 list_for_each_entry(codec, &bus->codec_list, list) {
2090 int err = snd_hda_codec_build_controls(codec);
2097 int snd_hda_codec_build_controls(struct hda_codec *codec)
2100 /* fake as if already powered-on */
2101 hda_keep_power_on(codec);
2103 hda_set_power_state(codec,
2104 codec->afg ? codec->afg : codec->mfg,
2106 hda_exec_init_verbs(codec);
2107 /* continue to initialize... */
2108 if (codec->patch_ops.init)
2109 err = codec->patch_ops.init(codec);
2110 if (!err && codec->patch_ops.build_controls)
2111 err = codec->patch_ops.build_controls(codec);
2112 snd_hda_power_down(codec);
2121 struct hda_rate_tbl {
2123 unsigned int alsa_bits;
2124 unsigned int hda_fmt;
2127 static struct hda_rate_tbl rate_bits[] = {
2128 /* rate in Hz, ALSA rate bitmask, HDA format value */
2130 /* autodetected value used in snd_hda_query_supported_pcm */
2131 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2132 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2133 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2134 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2135 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2136 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2137 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2138 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2139 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2140 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2141 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2142 #define AC_PAR_PCM_RATE_BITS 11
2143 /* up to bits 10, 384kHZ isn't supported properly */
2145 /* not autodetected value */
2146 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2148 { 0 } /* terminator */
2152 * snd_hda_calc_stream_format - calculate format bitset
2153 * @rate: the sample rate
2154 * @channels: the number of channels
2155 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2156 * @maxbps: the max. bps
2158 * Calculate the format bitset from the given rate, channels and th PCM format.
2160 * Return zero if invalid.
2162 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2163 unsigned int channels,
2164 unsigned int format,
2165 unsigned int maxbps)
2168 unsigned int val = 0;
2170 for (i = 0; rate_bits[i].hz; i++)
2171 if (rate_bits[i].hz == rate) {
2172 val = rate_bits[i].hda_fmt;
2175 if (!rate_bits[i].hz) {
2176 snd_printdd("invalid rate %d\n", rate);
2180 if (channels == 0 || channels > 8) {
2181 snd_printdd("invalid channels %d\n", channels);
2184 val |= channels - 1;
2186 switch (snd_pcm_format_width(format)) {
2187 case 8: val |= 0x00; break;
2188 case 16: val |= 0x10; break;
2194 else if (maxbps >= 24)
2200 snd_printdd("invalid format width %d\n",
2201 snd_pcm_format_width(format));
2209 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2210 * @codec: the HDA codec
2211 * @nid: NID to query
2212 * @ratesp: the pointer to store the detected rate bitflags
2213 * @formatsp: the pointer to store the detected formats
2214 * @bpsp: the pointer to store the detected format widths
2216 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2217 * or @bsps argument is ignored.
2219 * Returns 0 if successful, otherwise a negative error code.
2221 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2222 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2225 unsigned int val, streams;
2228 if (nid != codec->afg &&
2229 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2230 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2235 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2239 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2241 rates |= rate_bits[i].alsa_bits;
2246 if (formatsp || bpsp) {
2251 wcaps = get_wcaps(codec, nid);
2252 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2256 streams = snd_hda_param_read(codec, codec->afg,
2263 if (streams & AC_SUPFMT_PCM) {
2264 if (val & AC_SUPPCM_BITS_8) {
2265 formats |= SNDRV_PCM_FMTBIT_U8;
2268 if (val & AC_SUPPCM_BITS_16) {
2269 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2272 if (wcaps & AC_WCAP_DIGITAL) {
2273 if (val & AC_SUPPCM_BITS_32)
2274 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2275 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2276 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2277 if (val & AC_SUPPCM_BITS_24)
2279 else if (val & AC_SUPPCM_BITS_20)
2281 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2282 AC_SUPPCM_BITS_32)) {
2283 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2284 if (val & AC_SUPPCM_BITS_32)
2286 else if (val & AC_SUPPCM_BITS_24)
2288 else if (val & AC_SUPPCM_BITS_20)
2292 else if (streams == AC_SUPFMT_FLOAT32) {
2293 /* should be exclusive */
2294 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2296 } else if (streams == AC_SUPFMT_AC3) {
2297 /* should be exclusive */
2298 /* temporary hack: we have still no proper support
2299 * for the direct AC3 stream...
2301 formats |= SNDRV_PCM_FMTBIT_U8;
2305 *formatsp = formats;
2314 * snd_hda_is_supported_format - check whether the given node supports
2317 * Returns 1 if supported, 0 if not.
2319 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2320 unsigned int format)
2323 unsigned int val = 0, rate, stream;
2325 if (nid != codec->afg &&
2326 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2327 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2332 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2337 rate = format & 0xff00;
2338 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2339 if (rate_bits[i].hda_fmt == rate) {
2344 if (i >= AC_PAR_PCM_RATE_BITS)
2347 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2350 if (!stream && nid != codec->afg)
2351 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2352 if (!stream || stream == -1)
2355 if (stream & AC_SUPFMT_PCM) {
2356 switch (format & 0xf0) {
2358 if (!(val & AC_SUPPCM_BITS_8))
2362 if (!(val & AC_SUPPCM_BITS_16))
2366 if (!(val & AC_SUPPCM_BITS_20))
2370 if (!(val & AC_SUPPCM_BITS_24))
2374 if (!(val & AC_SUPPCM_BITS_32))
2381 /* FIXME: check for float32 and AC3? */
2390 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2391 struct hda_codec *codec,
2392 struct snd_pcm_substream *substream)
2397 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2398 struct hda_codec *codec,
2399 unsigned int stream_tag,
2400 unsigned int format,
2401 struct snd_pcm_substream *substream)
2403 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2407 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2408 struct hda_codec *codec,
2409 struct snd_pcm_substream *substream)
2411 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2415 static int set_pcm_default_values(struct hda_codec *codec,
2416 struct hda_pcm_stream *info)
2418 /* query support PCM information from the given NID */
2419 if (info->nid && (!info->rates || !info->formats)) {
2420 snd_hda_query_supported_pcm(codec, info->nid,
2421 info->rates ? NULL : &info->rates,
2422 info->formats ? NULL : &info->formats,
2423 info->maxbps ? NULL : &info->maxbps);
2425 if (info->ops.open == NULL)
2426 info->ops.open = hda_pcm_default_open_close;
2427 if (info->ops.close == NULL)
2428 info->ops.close = hda_pcm_default_open_close;
2429 if (info->ops.prepare == NULL) {
2430 if (snd_BUG_ON(!info->nid))
2432 info->ops.prepare = hda_pcm_default_prepare;
2434 if (info->ops.cleanup == NULL) {
2435 if (snd_BUG_ON(!info->nid))
2437 info->ops.cleanup = hda_pcm_default_cleanup;
2443 * attach a new PCM stream
2445 static int __devinit
2446 snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2448 struct hda_bus *bus = codec->bus;
2449 struct hda_pcm_stream *info;
2452 if (snd_BUG_ON(!pcm->name))
2454 for (stream = 0; stream < 2; stream++) {
2455 info = &pcm->stream[stream];
2456 if (info->substreams) {
2457 err = set_pcm_default_values(codec, info);
2462 return bus->ops.attach_pcm(bus, codec, pcm);
2466 * snd_hda_build_pcms - build PCM information
2469 * Create PCM information for each codec included in the bus.
2471 * The build_pcms codec patch is requested to set up codec->num_pcms and
2472 * codec->pcm_info properly. The array is referred by the top-level driver
2473 * to create its PCM instances.
2474 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2477 * At least, substreams, channels_min and channels_max must be filled for
2478 * each stream. substreams = 0 indicates that the stream doesn't exist.
2479 * When rates and/or formats are zero, the supported values are queried
2480 * from the given nid. The nid is used also by the default ops.prepare
2481 * and ops.cleanup callbacks.
2483 * The driver needs to call ops.open in its open callback. Similarly,
2484 * ops.close is supposed to be called in the close callback.
2485 * ops.prepare should be called in the prepare or hw_params callback
2486 * with the proper parameters for set up.
2487 * ops.cleanup should be called in hw_free for clean up of streams.
2489 * This function returns 0 if successfull, or a negative error code.
2491 int snd_hda_build_pcms(struct hda_bus *bus)
2493 static const char *dev_name[HDA_PCM_NTYPES] = {
2494 "Audio", "SPDIF", "HDMI", "Modem"
2496 /* starting device index for each PCM type */
2497 static int dev_idx[HDA_PCM_NTYPES] = {
2498 [HDA_PCM_TYPE_AUDIO] = 0,
2499 [HDA_PCM_TYPE_SPDIF] = 1,
2500 [HDA_PCM_TYPE_HDMI] = 3,
2501 [HDA_PCM_TYPE_MODEM] = 6
2503 /* normal audio device indices; not linear to keep compatibility */
2504 static int audio_idx[4] = { 0, 2, 4, 5 };
2505 struct hda_codec *codec;
2506 int num_devs[HDA_PCM_NTYPES];
2508 memset(num_devs, 0, sizeof(num_devs));
2509 list_for_each_entry(codec, &bus->codec_list, list) {
2512 if (!codec->num_pcms) {
2513 if (!codec->patch_ops.build_pcms)
2515 err = codec->patch_ops.build_pcms(codec);
2519 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2520 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2521 int type = cpcm->pcm_type;
2524 if (!cpcm->stream[0].substreams &&
2525 !cpcm->stream[1].substreams)
2526 continue; /* no substreams assigned */
2529 case HDA_PCM_TYPE_AUDIO:
2530 if (num_devs[type] >= ARRAY_SIZE(audio_idx)) {
2531 snd_printk(KERN_WARNING
2532 "Too many audio devices\n");
2535 dev = audio_idx[num_devs[type]];
2537 case HDA_PCM_TYPE_SPDIF:
2538 case HDA_PCM_TYPE_HDMI:
2539 case HDA_PCM_TYPE_MODEM:
2540 if (num_devs[type]) {
2541 snd_printk(KERN_WARNING
2542 "%s already defined\n",
2546 dev = dev_idx[type];
2549 snd_printk(KERN_WARNING
2550 "Invalid PCM type %d\n", type);
2556 err = snd_hda_attach_pcm(codec, cpcm);
2566 * snd_hda_check_board_config - compare the current codec with the config table
2567 * @codec: the HDA codec
2568 * @num_configs: number of config enums
2569 * @models: array of model name strings
2570 * @tbl: configuration table, terminated by null entries
2572 * Compares the modelname or PCI subsystem id of the current codec with the
2573 * given configuration table. If a matching entry is found, returns its
2574 * config value (supposed to be 0 or positive).
2576 * If no entries are matching, the function returns a negative value.
2578 int snd_hda_check_board_config(struct hda_codec *codec,
2579 int num_configs, const char **models,
2580 const struct snd_pci_quirk *tbl)
2582 if (codec->modelname && models) {
2584 for (i = 0; i < num_configs; i++) {
2586 !strcmp(codec->modelname, models[i])) {
2587 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2588 "selected\n", models[i]);
2594 if (!codec->bus->pci || !tbl)
2597 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2600 if (tbl->value >= 0 && tbl->value < num_configs) {
2601 #ifdef CONFIG_SND_DEBUG_VERBOSE
2603 const char *model = NULL;
2605 model = models[tbl->value];
2607 sprintf(tmp, "#%d", tbl->value);
2610 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2611 "for config %x:%x (%s)\n",
2612 model, tbl->subvendor, tbl->subdevice,
2613 (tbl->name ? tbl->name : "Unknown device"));
2621 * snd_hda_add_new_ctls - create controls from the array
2622 * @codec: the HDA codec
2623 * @knew: the array of struct snd_kcontrol_new
2625 * This helper function creates and add new controls in the given array.
2626 * The array must be terminated with an empty entry as terminator.
2628 * Returns 0 if successful, or a negative error code.
2630 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
2634 for (; knew->name; knew++) {
2635 struct snd_kcontrol *kctl;
2636 kctl = snd_ctl_new1(knew, codec);
2639 err = snd_hda_ctl_add(codec, kctl);
2643 kctl = snd_ctl_new1(knew, codec);
2646 kctl->id.device = codec->addr;
2647 err = snd_hda_ctl_add(codec, kctl);
2655 #ifdef CONFIG_SND_HDA_POWER_SAVE
2656 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2657 unsigned int power_state);
2659 static void hda_power_work(struct work_struct *work)
2661 struct hda_codec *codec =
2662 container_of(work, struct hda_codec, power_work.work);
2663 struct hda_bus *bus = codec->bus;
2665 if (!codec->power_on || codec->power_count) {
2666 codec->power_transition = 0;
2670 hda_call_codec_suspend(codec);
2671 if (bus->ops.pm_notify)
2672 bus->ops.pm_notify(bus);
2675 static void hda_keep_power_on(struct hda_codec *codec)
2677 codec->power_count++;
2678 codec->power_on = 1;
2681 void snd_hda_power_up(struct hda_codec *codec)
2683 struct hda_bus *bus = codec->bus;
2685 codec->power_count++;
2686 if (codec->power_on || codec->power_transition)
2689 codec->power_on = 1;
2690 if (bus->ops.pm_notify)
2691 bus->ops.pm_notify(bus);
2692 hda_call_codec_resume(codec);
2693 cancel_delayed_work(&codec->power_work);
2694 codec->power_transition = 0;
2697 void snd_hda_power_down(struct hda_codec *codec)
2699 --codec->power_count;
2700 if (!codec->power_on || codec->power_count || codec->power_transition)
2703 codec->power_transition = 1; /* avoid reentrance */
2704 schedule_delayed_work(&codec->power_work,
2705 msecs_to_jiffies(power_save * 1000));
2709 int snd_hda_check_amp_list_power(struct hda_codec *codec,
2710 struct hda_loopback_check *check,
2713 struct hda_amp_list *p;
2716 if (!check->amplist)
2718 for (p = check->amplist; p->nid; p++) {
2723 return 0; /* nothing changed */
2725 for (p = check->amplist; p->nid; p++) {
2726 for (ch = 0; ch < 2; ch++) {
2727 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
2729 if (!(v & HDA_AMP_MUTE) && v > 0) {
2730 if (!check->power_on) {
2731 check->power_on = 1;
2732 snd_hda_power_up(codec);
2738 if (check->power_on) {
2739 check->power_on = 0;
2740 snd_hda_power_down(codec);
2747 * Channel mode helper
2749 int snd_hda_ch_mode_info(struct hda_codec *codec,
2750 struct snd_ctl_elem_info *uinfo,
2751 const struct hda_channel_mode *chmode,
2754 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2756 uinfo->value.enumerated.items = num_chmodes;
2757 if (uinfo->value.enumerated.item >= num_chmodes)
2758 uinfo->value.enumerated.item = num_chmodes - 1;
2759 sprintf(uinfo->value.enumerated.name, "%dch",
2760 chmode[uinfo->value.enumerated.item].channels);
2764 int snd_hda_ch_mode_get(struct hda_codec *codec,
2765 struct snd_ctl_elem_value *ucontrol,
2766 const struct hda_channel_mode *chmode,
2772 for (i = 0; i < num_chmodes; i++) {
2773 if (max_channels == chmode[i].channels) {
2774 ucontrol->value.enumerated.item[0] = i;
2781 int snd_hda_ch_mode_put(struct hda_codec *codec,
2782 struct snd_ctl_elem_value *ucontrol,
2783 const struct hda_channel_mode *chmode,
2789 mode = ucontrol->value.enumerated.item[0];
2790 if (mode >= num_chmodes)
2792 if (*max_channelsp == chmode[mode].channels)
2794 /* change the current channel setting */
2795 *max_channelsp = chmode[mode].channels;
2796 if (chmode[mode].sequence)
2797 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
2804 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
2805 struct snd_ctl_elem_info *uinfo)
2809 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2811 uinfo->value.enumerated.items = imux->num_items;
2812 if (!imux->num_items)
2814 index = uinfo->value.enumerated.item;
2815 if (index >= imux->num_items)
2816 index = imux->num_items - 1;
2817 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
2821 int snd_hda_input_mux_put(struct hda_codec *codec,
2822 const struct hda_input_mux *imux,
2823 struct snd_ctl_elem_value *ucontrol,
2825 unsigned int *cur_val)
2829 if (!imux->num_items)
2831 idx = ucontrol->value.enumerated.item[0];
2832 if (idx >= imux->num_items)
2833 idx = imux->num_items - 1;
2834 if (*cur_val == idx)
2836 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
2837 imux->items[idx].index);
2844 * Multi-channel / digital-out PCM helper functions
2847 /* setup SPDIF output stream */
2848 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
2849 unsigned int stream_tag, unsigned int format)
2851 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
2852 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2853 set_dig_out_convert(codec, nid,
2854 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
2856 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2857 if (codec->slave_dig_outs) {
2859 for (d = codec->slave_dig_outs; *d; d++)
2860 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
2863 /* turn on again (if needed) */
2864 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2865 set_dig_out_convert(codec, nid,
2866 codec->spdif_ctls & 0xff, -1);
2869 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
2871 snd_hda_codec_cleanup_stream(codec, nid);
2872 if (codec->slave_dig_outs) {
2874 for (d = codec->slave_dig_outs; *d; d++)
2875 snd_hda_codec_cleanup_stream(codec, *d);
2880 * open the digital out in the exclusive mode
2882 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
2883 struct hda_multi_out *mout)
2885 mutex_lock(&codec->spdif_mutex);
2886 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
2887 /* already opened as analog dup; reset it once */
2888 cleanup_dig_out_stream(codec, mout->dig_out_nid);
2889 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
2890 mutex_unlock(&codec->spdif_mutex);
2894 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
2895 struct hda_multi_out *mout,
2896 unsigned int stream_tag,
2897 unsigned int format,
2898 struct snd_pcm_substream *substream)
2900 mutex_lock(&codec->spdif_mutex);
2901 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
2902 mutex_unlock(&codec->spdif_mutex);
2907 * release the digital out
2909 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
2910 struct hda_multi_out *mout)
2912 mutex_lock(&codec->spdif_mutex);
2913 mout->dig_out_used = 0;
2914 mutex_unlock(&codec->spdif_mutex);
2919 * set up more restrictions for analog out
2921 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
2922 struct hda_multi_out *mout,
2923 struct snd_pcm_substream *substream,
2924 struct hda_pcm_stream *hinfo)
2926 struct snd_pcm_runtime *runtime = substream->runtime;
2927 runtime->hw.channels_max = mout->max_channels;
2928 if (mout->dig_out_nid) {
2929 if (!mout->analog_rates) {
2930 mout->analog_rates = hinfo->rates;
2931 mout->analog_formats = hinfo->formats;
2932 mout->analog_maxbps = hinfo->maxbps;
2934 runtime->hw.rates = mout->analog_rates;
2935 runtime->hw.formats = mout->analog_formats;
2936 hinfo->maxbps = mout->analog_maxbps;
2938 if (!mout->spdif_rates) {
2939 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
2941 &mout->spdif_formats,
2942 &mout->spdif_maxbps);
2944 mutex_lock(&codec->spdif_mutex);
2945 if (mout->share_spdif) {
2946 runtime->hw.rates &= mout->spdif_rates;
2947 runtime->hw.formats &= mout->spdif_formats;
2948 if (mout->spdif_maxbps < hinfo->maxbps)
2949 hinfo->maxbps = mout->spdif_maxbps;
2951 mutex_unlock(&codec->spdif_mutex);
2953 return snd_pcm_hw_constraint_step(substream->runtime, 0,
2954 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
2958 * set up the i/o for analog out
2959 * when the digital out is available, copy the front out to digital out, too.
2961 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
2962 struct hda_multi_out *mout,
2963 unsigned int stream_tag,
2964 unsigned int format,
2965 struct snd_pcm_substream *substream)
2967 hda_nid_t *nids = mout->dac_nids;
2968 int chs = substream->runtime->channels;
2971 mutex_lock(&codec->spdif_mutex);
2972 if (mout->dig_out_nid && mout->share_spdif &&
2973 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
2975 snd_hda_is_supported_format(codec, mout->dig_out_nid,
2977 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
2978 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
2979 setup_dig_out_stream(codec, mout->dig_out_nid,
2980 stream_tag, format);
2982 mout->dig_out_used = 0;
2983 cleanup_dig_out_stream(codec, mout->dig_out_nid);
2986 mutex_unlock(&codec->spdif_mutex);
2989 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
2991 if (!mout->no_share_stream &&
2992 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
2993 /* headphone out will just decode front left/right (stereo) */
2994 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
2996 /* extra outputs copied from front */
2997 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
2998 if (!mout->no_share_stream && mout->extra_out_nid[i])
2999 snd_hda_codec_setup_stream(codec,
3000 mout->extra_out_nid[i],
3001 stream_tag, 0, format);
3004 for (i = 1; i < mout->num_dacs; i++) {
3005 if (chs >= (i + 1) * 2) /* independent out */
3006 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3008 else if (!mout->no_share_stream) /* copy front */
3009 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3016 * clean up the setting for analog out
3018 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3019 struct hda_multi_out *mout)
3021 hda_nid_t *nids = mout->dac_nids;
3024 for (i = 0; i < mout->num_dacs; i++)
3025 snd_hda_codec_cleanup_stream(codec, nids[i]);
3027 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3028 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3029 if (mout->extra_out_nid[i])
3030 snd_hda_codec_cleanup_stream(codec,
3031 mout->extra_out_nid[i]);
3032 mutex_lock(&codec->spdif_mutex);
3033 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3034 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3035 mout->dig_out_used = 0;
3037 mutex_unlock(&codec->spdif_mutex);
3042 * Helper for automatic pin configuration
3045 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3047 for (; *list; list++)
3055 * Sort an associated group of pins according to their sequence numbers.
3057 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3064 for (i = 0; i < num_pins; i++) {
3065 for (j = i + 1; j < num_pins; j++) {
3066 if (sequences[i] > sequences[j]) {
3068 sequences[i] = sequences[j];
3080 * Parse all pin widgets and store the useful pin nids to cfg
3082 * The number of line-outs or any primary output is stored in line_outs,
3083 * and the corresponding output pins are assigned to line_out_pins[],
3084 * in the order of front, rear, CLFE, side, ...
3086 * If more extra outputs (speaker and headphone) are found, the pins are
3087 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3088 * is detected, one of speaker of HP pins is assigned as the primary
3089 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3090 * if any analog output exists.
3092 * The analog input pins are assigned to input_pins array.
3093 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3096 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3097 struct auto_pin_cfg *cfg,
3098 hda_nid_t *ignore_nids)
3100 hda_nid_t nid, end_nid;
3101 short seq, assoc_line_out, assoc_speaker;
3102 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3103 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3104 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3106 memset(cfg, 0, sizeof(*cfg));
3108 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3109 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3110 memset(sequences_hp, 0, sizeof(sequences_hp));
3111 assoc_line_out = assoc_speaker = 0;
3113 end_nid = codec->start_nid + codec->num_nodes;
3114 for (nid = codec->start_nid; nid < end_nid; nid++) {
3115 unsigned int wid_caps = get_wcaps(codec, nid);
3116 unsigned int wid_type =
3117 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3118 unsigned int def_conf;
3121 /* read all default configuration for pin complex */
3122 if (wid_type != AC_WID_PIN)
3124 /* ignore the given nids (e.g. pc-beep returns error) */
3125 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3128 def_conf = snd_hda_codec_read(codec, nid, 0,
3129 AC_VERB_GET_CONFIG_DEFAULT, 0);
3130 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3132 loc = get_defcfg_location(def_conf);
3133 switch (get_defcfg_device(def_conf)) {
3134 case AC_JACK_LINE_OUT:
3135 seq = get_defcfg_sequence(def_conf);
3136 assoc = get_defcfg_association(def_conf);
3138 if (!(wid_caps & AC_WCAP_STEREO))
3139 if (!cfg->mono_out_pin)
3140 cfg->mono_out_pin = nid;
3143 if (!assoc_line_out)
3144 assoc_line_out = assoc;
3145 else if (assoc_line_out != assoc)
3147 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3149 cfg->line_out_pins[cfg->line_outs] = nid;
3150 sequences_line_out[cfg->line_outs] = seq;
3153 case AC_JACK_SPEAKER:
3154 seq = get_defcfg_sequence(def_conf);
3155 assoc = get_defcfg_association(def_conf);
3158 if (! assoc_speaker)
3159 assoc_speaker = assoc;
3160 else if (assoc_speaker != assoc)
3162 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3164 cfg->speaker_pins[cfg->speaker_outs] = nid;
3165 sequences_speaker[cfg->speaker_outs] = seq;
3166 cfg->speaker_outs++;
3168 case AC_JACK_HP_OUT:
3169 seq = get_defcfg_sequence(def_conf);
3170 assoc = get_defcfg_association(def_conf);
3171 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3173 cfg->hp_pins[cfg->hp_outs] = nid;
3174 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3177 case AC_JACK_MIC_IN: {
3179 if (loc == AC_JACK_LOC_FRONT) {
3180 preferred = AUTO_PIN_FRONT_MIC;
3183 preferred = AUTO_PIN_MIC;
3184 alt = AUTO_PIN_FRONT_MIC;
3186 if (!cfg->input_pins[preferred])
3187 cfg->input_pins[preferred] = nid;
3188 else if (!cfg->input_pins[alt])
3189 cfg->input_pins[alt] = nid;
3192 case AC_JACK_LINE_IN:
3193 if (loc == AC_JACK_LOC_FRONT)
3194 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3196 cfg->input_pins[AUTO_PIN_LINE] = nid;
3199 cfg->input_pins[AUTO_PIN_CD] = nid;
3202 cfg->input_pins[AUTO_PIN_AUX] = nid;
3204 case AC_JACK_SPDIF_OUT:
3205 cfg->dig_out_pin = nid;
3207 case AC_JACK_SPDIF_IN:
3208 cfg->dig_in_pin = nid;
3214 * If no line-out is defined but multiple HPs are found,
3215 * some of them might be the real line-outs.
3217 if (!cfg->line_outs && cfg->hp_outs > 1) {
3219 while (i < cfg->hp_outs) {
3220 /* The real HPs should have the sequence 0x0f */
3221 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3225 /* Move it to the line-out table */
3226 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3227 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3230 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3231 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3232 memmove(sequences_hp + i - 1, sequences_hp + i,
3233 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3237 /* sort by sequence */
3238 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3240 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3242 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3245 /* if we have only one mic, make it AUTO_PIN_MIC */
3246 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3247 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3248 cfg->input_pins[AUTO_PIN_MIC] =
3249 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3250 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3252 /* ditto for line-in */
3253 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3254 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3255 cfg->input_pins[AUTO_PIN_LINE] =
3256 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3257 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3261 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3262 * as a primary output
3264 if (!cfg->line_outs) {
3265 if (cfg->speaker_outs) {
3266 cfg->line_outs = cfg->speaker_outs;
3267 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3268 sizeof(cfg->speaker_pins));
3269 cfg->speaker_outs = 0;
3270 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3271 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3272 } else if (cfg->hp_outs) {
3273 cfg->line_outs = cfg->hp_outs;
3274 memcpy(cfg->line_out_pins, cfg->hp_pins,
3275 sizeof(cfg->hp_pins));
3277 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3278 cfg->line_out_type = AUTO_PIN_HP_OUT;
3282 /* Reorder the surround channels
3283 * ALSA sequence is front/surr/clfe/side
3285 * 4-ch: front/surr => OK as it is
3286 * 6-ch: front/clfe/surr
3287 * 8-ch: front/clfe/rear/side|fc
3289 switch (cfg->line_outs) {
3292 nid = cfg->line_out_pins[1];
3293 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3294 cfg->line_out_pins[2] = nid;
3299 * debug prints of the parsed results
3301 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3302 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3303 cfg->line_out_pins[2], cfg->line_out_pins[3],
3304 cfg->line_out_pins[4]);
3305 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3306 cfg->speaker_outs, cfg->speaker_pins[0],
3307 cfg->speaker_pins[1], cfg->speaker_pins[2],
3308 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3309 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3310 cfg->hp_outs, cfg->hp_pins[0],
3311 cfg->hp_pins[1], cfg->hp_pins[2],
3312 cfg->hp_pins[3], cfg->hp_pins[4]);
3313 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3314 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3315 " cd=0x%x, aux=0x%x\n",
3316 cfg->input_pins[AUTO_PIN_MIC],
3317 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3318 cfg->input_pins[AUTO_PIN_LINE],
3319 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3320 cfg->input_pins[AUTO_PIN_CD],
3321 cfg->input_pins[AUTO_PIN_AUX]);
3326 /* labels for input pins */
3327 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3328 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3338 * snd_hda_suspend - suspend the codecs
3340 * @state: suspsend state
3342 * Returns 0 if successful.
3344 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3346 struct hda_codec *codec;
3348 list_for_each_entry(codec, &bus->codec_list, list) {
3349 #ifdef CONFIG_SND_HDA_POWER_SAVE
3350 if (!codec->power_on)
3353 hda_call_codec_suspend(codec);
3359 * snd_hda_resume - resume the codecs
3361 * @state: resume state
3363 * Returns 0 if successful.
3365 * This fucntion is defined only when POWER_SAVE isn't set.
3366 * In the power-save mode, the codec is resumed dynamically.
3368 int snd_hda_resume(struct hda_bus *bus)
3370 struct hda_codec *codec;
3372 list_for_each_entry(codec, &bus->codec_list, list) {
3373 if (snd_hda_codec_needs_resume(codec))
3374 hda_call_codec_resume(codec);
3378 #ifdef CONFIG_SND_HDA_POWER_SAVE
3379 int snd_hda_codecs_inuse(struct hda_bus *bus)
3381 struct hda_codec *codec;
3383 list_for_each_entry(codec, &bus->codec_list, list) {
3384 if (snd_hda_codec_needs_resume(codec))
3396 /* get a new element from the given array
3397 * if it exceeds the pre-allocated array size, re-allocate the array
3399 void *snd_array_new(struct snd_array *array)
3401 if (array->used >= array->alloced) {
3402 int num = array->alloced + array->alloc_align;
3404 if (snd_BUG_ON(num >= 4096))
3406 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3410 memcpy(nlist, array->list,
3411 array->elem_size * array->alloced);
3414 array->list = nlist;
3415 array->alloced = num;
3417 return snd_array_elem(array, array->used++);
3420 /* free the given array elements */
3421 void snd_array_free(struct snd_array *array)