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,
104 #ifdef CONFIG_SND_HDA_POWER_SAVE
105 static void hda_power_work(struct work_struct *work);
106 static void hda_keep_power_on(struct hda_codec *codec);
108 static inline void hda_keep_power_on(struct hda_codec *codec) {}
111 const char *snd_hda_get_jack_location(u32 cfg)
113 static char *bases[7] = {
114 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
116 static unsigned char specials_idx[] = {
121 static char *specials[] = {
122 "Rear Panel", "Drive Bar",
123 "Riser", "HDMI", "ATAPI",
124 "Mobile-In", "Mobile-Out"
127 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
128 if ((cfg & 0x0f) < 7)
129 return bases[cfg & 0x0f];
130 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
131 if (cfg == specials_idx[i])
137 const char *snd_hda_get_jack_connectivity(u32 cfg)
139 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
141 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
144 const char *snd_hda_get_jack_type(u32 cfg)
146 static char *jack_types[16] = {
147 "Line Out", "Speaker", "HP Out", "CD",
148 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
149 "Line In", "Aux", "Mic", "Telephony",
150 "SPDIF In", "Digitial In", "Reserved", "Other"
153 return jack_types[(cfg & AC_DEFCFG_DEVICE)
154 >> AC_DEFCFG_DEVICE_SHIFT];
158 * snd_hda_codec_read - send a command and get the response
159 * @codec: the HDA codec
160 * @nid: NID to send the command
161 * @direct: direct flag
162 * @verb: the verb to send
163 * @parm: the parameter for the verb
165 * Send a single command and read the corresponding response.
167 * Returns the obtained response value, or -1 for an error.
169 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
171 unsigned int verb, unsigned int parm)
174 snd_hda_power_up(codec);
175 mutex_lock(&codec->bus->cmd_mutex);
176 if (!codec->bus->ops.command(codec, nid, direct, verb, parm))
177 res = codec->bus->ops.get_response(codec);
179 res = (unsigned int)-1;
180 mutex_unlock(&codec->bus->cmd_mutex);
181 snd_hda_power_down(codec);
186 * snd_hda_codec_write - send a single command without waiting for response
187 * @codec: the HDA codec
188 * @nid: NID to send the command
189 * @direct: direct flag
190 * @verb: the verb to send
191 * @parm: the parameter for the verb
193 * Send a single command without waiting for response.
195 * Returns 0 if successful, or a negative error code.
197 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
198 unsigned int verb, unsigned int parm)
201 snd_hda_power_up(codec);
202 mutex_lock(&codec->bus->cmd_mutex);
203 err = codec->bus->ops.command(codec, nid, direct, verb, parm);
204 mutex_unlock(&codec->bus->cmd_mutex);
205 snd_hda_power_down(codec);
210 * snd_hda_sequence_write - sequence writes
211 * @codec: the HDA codec
212 * @seq: VERB array to send
214 * Send the commands sequentially from the given array.
215 * The array must be terminated with NID=0.
217 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
219 for (; seq->nid; seq++)
220 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
224 * snd_hda_get_sub_nodes - get the range of sub nodes
225 * @codec: the HDA codec
227 * @start_id: the pointer to store the start NID
229 * Parse the NID and store the start NID of its sub-nodes.
230 * Returns the number of sub-nodes.
232 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
237 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
240 *start_id = (parm >> 16) & 0x7fff;
241 return (int)(parm & 0x7fff);
245 * snd_hda_get_connections - get connection list
246 * @codec: the HDA codec
248 * @conn_list: connection list array
249 * @max_conns: max. number of connections to store
251 * Parses the connection list of the given widget and stores the list
254 * Returns the number of connections, or a negative error code.
256 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
257 hda_nid_t *conn_list, int max_conns)
260 int i, conn_len, conns;
261 unsigned int shift, num_elems, mask;
264 if (snd_BUG_ON(!conn_list || max_conns <= 0))
267 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
268 if (parm & AC_CLIST_LONG) {
277 conn_len = parm & AC_CLIST_LENGTH;
278 mask = (1 << (shift-1)) - 1;
281 return 0; /* no connection */
284 /* single connection */
285 parm = snd_hda_codec_read(codec, nid, 0,
286 AC_VERB_GET_CONNECT_LIST, 0);
287 conn_list[0] = parm & mask;
291 /* multi connection */
294 for (i = 0; i < conn_len; i++) {
298 if (i % num_elems == 0)
299 parm = snd_hda_codec_read(codec, nid, 0,
300 AC_VERB_GET_CONNECT_LIST, i);
301 range_val = !!(parm & (1 << (shift-1))); /* ranges */
305 /* ranges between the previous and this one */
306 if (!prev_nid || prev_nid >= val) {
307 snd_printk(KERN_WARNING "hda_codec: "
308 "invalid dep_range_val %x:%x\n",
312 for (n = prev_nid + 1; n <= val; n++) {
313 if (conns >= max_conns) {
315 "Too many connections\n");
318 conn_list[conns++] = n;
321 if (conns >= max_conns) {
322 snd_printk(KERN_ERR "Too many connections\n");
325 conn_list[conns++] = val;
334 * snd_hda_queue_unsol_event - add an unsolicited event to queue
336 * @res: unsolicited event (lower 32bit of RIRB entry)
337 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
339 * Adds the given event to the queue. The events are processed in
340 * the workqueue asynchronously. Call this function in the interrupt
341 * hanlder when RIRB receives an unsolicited event.
343 * Returns 0 if successful, or a negative error code.
345 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
347 struct hda_bus_unsolicited *unsol;
354 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
358 unsol->queue[wp] = res;
359 unsol->queue[wp + 1] = res_ex;
361 schedule_work(&unsol->work);
367 * process queued unsolicited events
369 static void process_unsol_events(struct work_struct *work)
371 struct hda_bus_unsolicited *unsol =
372 container_of(work, struct hda_bus_unsolicited, work);
373 struct hda_bus *bus = unsol->bus;
374 struct hda_codec *codec;
375 unsigned int rp, caddr, res;
377 while (unsol->rp != unsol->wp) {
378 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
381 res = unsol->queue[rp];
382 caddr = unsol->queue[rp + 1];
383 if (!(caddr & (1 << 4))) /* no unsolicited event? */
385 codec = bus->caddr_tbl[caddr & 0x0f];
386 if (codec && codec->patch_ops.unsol_event)
387 codec->patch_ops.unsol_event(codec, res);
392 * initialize unsolicited queue
394 static int init_unsol_queue(struct hda_bus *bus)
396 struct hda_bus_unsolicited *unsol;
398 if (bus->unsol) /* already initialized */
401 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
403 snd_printk(KERN_ERR "hda_codec: "
404 "can't allocate unsolicited queue\n");
407 INIT_WORK(&unsol->work, process_unsol_events);
416 static void snd_hda_codec_free(struct hda_codec *codec);
418 static int snd_hda_bus_free(struct hda_bus *bus)
420 struct hda_codec *codec, *n;
425 flush_scheduled_work();
428 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
429 snd_hda_codec_free(codec);
431 if (bus->ops.private_free)
432 bus->ops.private_free(bus);
437 static int snd_hda_bus_dev_free(struct snd_device *device)
439 struct hda_bus *bus = device->device_data;
440 return snd_hda_bus_free(bus);
443 #ifdef CONFIG_SND_HDA_HWDEP
444 static int snd_hda_bus_dev_register(struct snd_device *device)
446 struct hda_bus *bus = device->device_data;
447 struct hda_codec *codec;
448 list_for_each_entry(codec, &bus->codec_list, list) {
449 snd_hda_hwdep_add_sysfs(codec);
454 #define snd_hda_bus_dev_register NULL
458 * snd_hda_bus_new - create a HDA bus
459 * @card: the card entry
460 * @temp: the template for hda_bus information
461 * @busp: the pointer to store the created bus instance
463 * Returns 0 if successful, or a negative error code.
465 int __devinit snd_hda_bus_new(struct snd_card *card,
466 const struct hda_bus_template *temp,
467 struct hda_bus **busp)
471 static struct snd_device_ops dev_ops = {
472 .dev_register = snd_hda_bus_dev_register,
473 .dev_free = snd_hda_bus_dev_free,
476 if (snd_BUG_ON(!temp))
478 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
484 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
486 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
491 bus->private_data = temp->private_data;
492 bus->pci = temp->pci;
493 bus->modelname = temp->modelname;
494 bus->ops = temp->ops;
496 mutex_init(&bus->cmd_mutex);
497 INIT_LIST_HEAD(&bus->codec_list);
499 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
501 snd_hda_bus_free(bus);
509 #ifdef CONFIG_SND_HDA_GENERIC
510 #define is_generic_config(codec) \
511 (codec->modelname && !strcmp(codec->modelname, "generic"))
513 #define is_generic_config(codec) 0
517 * find a matching codec preset
519 static const struct hda_codec_preset *
520 find_codec_preset(struct hda_codec *codec)
522 const struct hda_codec_preset **tbl, *preset;
524 if (is_generic_config(codec))
525 return NULL; /* use the generic parser */
527 for (tbl = hda_preset_tables; *tbl; tbl++) {
528 for (preset = *tbl; preset->id; preset++) {
529 u32 mask = preset->mask;
530 if (preset->afg && preset->afg != codec->afg)
532 if (preset->mfg && preset->mfg != codec->mfg)
536 if (preset->id == (codec->vendor_id & mask) &&
538 preset->rev == codec->revision_id))
546 * get_codec_name - store the codec name
548 static int get_codec_name(struct hda_codec *codec)
550 const struct hda_vendor_id *c;
551 const char *vendor = NULL;
552 u16 vendor_id = codec->vendor_id >> 16;
553 char tmp[16], name[32];
555 for (c = hda_vendor_ids; c->id; c++) {
556 if (c->id == vendor_id) {
562 sprintf(tmp, "Generic %04x", vendor_id);
565 if (codec->preset && codec->preset->name)
566 snprintf(name, sizeof(name), "%s %s", vendor,
567 codec->preset->name);
569 snprintf(name, sizeof(name), "%s ID %x", vendor,
570 codec->vendor_id & 0xffff);
571 codec->name = kstrdup(name, GFP_KERNEL);
578 * look for an AFG and MFG nodes
580 static void __devinit setup_fg_nodes(struct hda_codec *codec)
585 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
586 for (i = 0; i < total_nodes; i++, nid++) {
588 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
589 switch (func & 0xff) {
590 case AC_GRP_AUDIO_FUNCTION:
593 case AC_GRP_MODEM_FUNCTION:
603 * read widget caps for each widget and store in cache
605 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
610 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
612 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
615 nid = codec->start_nid;
616 for (i = 0; i < codec->num_nodes; i++, nid++)
617 codec->wcaps[i] = snd_hda_param_read(codec, nid,
618 AC_PAR_AUDIO_WIDGET_CAP);
623 static void init_hda_cache(struct hda_cache_rec *cache,
624 unsigned int record_size);
625 static void free_hda_cache(struct hda_cache_rec *cache);
630 static void snd_hda_codec_free(struct hda_codec *codec)
634 #ifdef CONFIG_SND_HDA_POWER_SAVE
635 cancel_delayed_work(&codec->power_work);
636 flush_scheduled_work();
638 list_del(&codec->list);
639 snd_array_free(&codec->mixers);
640 codec->bus->caddr_tbl[codec->addr] = NULL;
641 if (codec->patch_ops.free)
642 codec->patch_ops.free(codec);
643 free_hda_cache(&codec->amp_cache);
644 free_hda_cache(&codec->cmd_cache);
646 kfree(codec->modelname);
652 * snd_hda_codec_new - create a HDA codec
653 * @bus: the bus to assign
654 * @codec_addr: the codec address
655 * @codecp: the pointer to store the generated codec
657 * Returns 0 if successful, or a negative error code.
659 int __devinit snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
660 struct hda_codec **codecp)
662 struct hda_codec *codec;
666 if (snd_BUG_ON(!bus))
668 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
671 if (bus->caddr_tbl[codec_addr]) {
672 snd_printk(KERN_ERR "hda_codec: "
673 "address 0x%x is already occupied\n", codec_addr);
677 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
679 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
684 codec->addr = codec_addr;
685 mutex_init(&codec->spdif_mutex);
686 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
687 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
688 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
689 if (codec->bus->modelname) {
690 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
691 if (!codec->modelname) {
692 snd_hda_codec_free(codec);
697 #ifdef CONFIG_SND_HDA_POWER_SAVE
698 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
699 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
700 * the caller has to power down appropriatley after initialization
703 hda_keep_power_on(codec);
706 list_add_tail(&codec->list, &bus->codec_list);
707 bus->caddr_tbl[codec_addr] = codec;
709 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
711 if (codec->vendor_id == -1)
712 /* read again, hopefully the access method was corrected
713 * in the last read...
715 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
717 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
718 AC_PAR_SUBSYSTEM_ID);
719 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
722 setup_fg_nodes(codec);
723 if (!codec->afg && !codec->mfg) {
724 snd_printdd("hda_codec: no AFG or MFG node found\n");
725 snd_hda_codec_free(codec);
729 if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) {
730 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
731 snd_hda_codec_free(codec);
735 if (!codec->subsystem_id) {
736 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
737 codec->subsystem_id =
738 snd_hda_codec_read(codec, nid, 0,
739 AC_VERB_GET_SUBSYSTEM_ID, 0);
742 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
744 err = snd_hda_codec_configure(codec);
746 snd_hda_codec_free(codec);
749 snd_hda_codec_proc_new(codec);
751 snd_hda_create_hwdep(codec);
753 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
754 codec->subsystem_id, codec->revision_id);
755 snd_component_add(codec->bus->card, component);
762 int snd_hda_codec_configure(struct hda_codec *codec)
766 codec->preset = find_codec_preset(codec);
768 err = get_codec_name(codec);
772 /* audio codec should override the mixer name */
773 if (codec->afg || !*codec->bus->card->mixername)
774 strlcpy(codec->bus->card->mixername, codec->name,
775 sizeof(codec->bus->card->mixername));
777 if (is_generic_config(codec)) {
778 err = snd_hda_parse_generic_codec(codec);
781 if (codec->preset && codec->preset->patch) {
782 err = codec->preset->patch(codec);
786 /* call the default parser */
787 err = snd_hda_parse_generic_codec(codec);
789 printk(KERN_ERR "hda-codec: No codec parser is available\n");
792 if (!err && codec->patch_ops.unsol_event)
793 err = init_unsol_queue(codec->bus);
798 * snd_hda_codec_setup_stream - set up the codec for streaming
799 * @codec: the CODEC to set up
800 * @nid: the NID to set up
801 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
802 * @channel_id: channel id to pass, zero based.
803 * @format: stream format.
805 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
807 int channel_id, int format)
812 snd_printdd("hda_codec_setup_stream: "
813 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
814 nid, stream_tag, channel_id, format);
815 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
816 (stream_tag << 4) | channel_id);
818 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
821 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
826 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
827 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
828 #if 0 /* keep the format */
830 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
835 * amp access functions
838 /* FIXME: more better hash key? */
839 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
840 #define INFO_AMP_CAPS (1<<0)
841 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
843 /* initialize the hash table */
844 static void __devinit init_hda_cache(struct hda_cache_rec *cache,
845 unsigned int record_size)
847 memset(cache, 0, sizeof(*cache));
848 memset(cache->hash, 0xff, sizeof(cache->hash));
849 snd_array_init(&cache->buf, record_size, 64);
852 static void free_hda_cache(struct hda_cache_rec *cache)
854 snd_array_free(&cache->buf);
857 /* query the hash. allocate an entry if not found. */
858 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
861 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
862 u16 cur = cache->hash[idx];
863 struct hda_cache_head *info_head = cache->buf.list;
864 struct hda_cache_head *info;
866 while (cur != 0xffff) {
867 info = &info_head[cur];
868 if (info->key == key)
873 /* add a new hash entry */
874 info = snd_array_new(&cache->buf);
877 info->next = cache->hash[idx];
878 cache->hash[idx] = cur;
883 /* query and allocate an amp hash entry */
884 static inline struct hda_amp_info *
885 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
887 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
891 * query AMP capabilities for the given widget and direction
893 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
895 struct hda_amp_info *info;
897 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
900 if (!(info->head.val & INFO_AMP_CAPS)) {
901 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
903 info->amp_caps = snd_hda_param_read(codec, nid,
904 direction == HDA_OUTPUT ?
908 info->head.val |= INFO_AMP_CAPS;
910 return info->amp_caps;
913 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
916 struct hda_amp_info *info;
918 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
921 info->amp_caps = caps;
922 info->head.val |= INFO_AMP_CAPS;
927 * read the current volume to info
928 * if the cache exists, read the cache value.
930 static unsigned int get_vol_mute(struct hda_codec *codec,
931 struct hda_amp_info *info, hda_nid_t nid,
932 int ch, int direction, int index)
936 if (info->head.val & INFO_AMP_VOL(ch))
937 return info->vol[ch];
939 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
940 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
942 val = snd_hda_codec_read(codec, nid, 0,
943 AC_VERB_GET_AMP_GAIN_MUTE, parm);
944 info->vol[ch] = val & 0xff;
945 info->head.val |= INFO_AMP_VOL(ch);
946 return info->vol[ch];
950 * write the current volume in info to the h/w and update the cache
952 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
953 hda_nid_t nid, int ch, int direction, int index,
958 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
959 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
960 parm |= index << AC_AMP_SET_INDEX_SHIFT;
962 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
967 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
969 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
970 int direction, int index)
972 struct hda_amp_info *info;
973 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
976 return get_vol_mute(codec, info, nid, ch, direction, index);
980 * update the AMP value, mask = bit mask to set, val = the value
982 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
983 int direction, int idx, int mask, int val)
985 struct hda_amp_info *info;
987 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
991 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
992 if (info->vol[ch] == val)
994 put_vol_mute(codec, info, nid, ch, direction, idx, val);
999 * update the AMP stereo with the same mask and value
1001 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1002 int direction, int idx, int mask, int val)
1005 for (ch = 0; ch < 2; ch++)
1006 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1011 #ifdef SND_HDA_NEEDS_RESUME
1012 /* resume the all amp commands from the cache */
1013 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1015 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1018 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1019 u32 key = buffer->head.key;
1021 unsigned int idx, dir, ch;
1025 idx = (key >> 16) & 0xff;
1026 dir = (key >> 24) & 0xff;
1027 for (ch = 0; ch < 2; ch++) {
1028 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1030 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1035 #endif /* SND_HDA_NEEDS_RESUME */
1038 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1039 struct snd_ctl_elem_info *uinfo)
1041 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1042 u16 nid = get_amp_nid(kcontrol);
1043 u8 chs = get_amp_channels(kcontrol);
1044 int dir = get_amp_direction(kcontrol);
1047 caps = query_amp_caps(codec, nid, dir);
1049 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1051 printk(KERN_WARNING "hda_codec: "
1052 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1056 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1057 uinfo->count = chs == 3 ? 2 : 1;
1058 uinfo->value.integer.min = 0;
1059 uinfo->value.integer.max = caps;
1063 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1064 struct snd_ctl_elem_value *ucontrol)
1066 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1067 hda_nid_t nid = get_amp_nid(kcontrol);
1068 int chs = get_amp_channels(kcontrol);
1069 int dir = get_amp_direction(kcontrol);
1070 int idx = get_amp_index(kcontrol);
1071 long *valp = ucontrol->value.integer.value;
1074 *valp++ = snd_hda_codec_amp_read(codec, nid, 0, dir, idx)
1077 *valp = snd_hda_codec_amp_read(codec, nid, 1, dir, idx)
1082 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1083 struct snd_ctl_elem_value *ucontrol)
1085 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1086 hda_nid_t nid = get_amp_nid(kcontrol);
1087 int chs = get_amp_channels(kcontrol);
1088 int dir = get_amp_direction(kcontrol);
1089 int idx = get_amp_index(kcontrol);
1090 long *valp = ucontrol->value.integer.value;
1093 snd_hda_power_up(codec);
1095 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1100 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1102 snd_hda_power_down(codec);
1106 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1107 unsigned int size, unsigned int __user *_tlv)
1109 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1110 hda_nid_t nid = get_amp_nid(kcontrol);
1111 int dir = get_amp_direction(kcontrol);
1112 u32 caps, val1, val2;
1114 if (size < 4 * sizeof(unsigned int))
1116 caps = query_amp_caps(codec, nid, dir);
1117 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1118 val2 = (val2 + 1) * 25;
1119 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1120 val1 = ((int)val1) * ((int)val2);
1121 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1123 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1125 if (put_user(val1, _tlv + 2))
1127 if (put_user(val2, _tlv + 3))
1133 * set (static) TLV for virtual master volume; recalculated as max 0dB
1135 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1141 caps = query_amp_caps(codec, nid, dir);
1142 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1143 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1144 step = (step + 1) * 25;
1145 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1146 tlv[1] = 2 * sizeof(unsigned int);
1147 tlv[2] = -nums * step;
1151 /* find a mixer control element with the given name */
1152 static struct snd_kcontrol *
1153 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1154 const char *name, int idx)
1156 struct snd_ctl_elem_id id;
1157 memset(&id, 0, sizeof(id));
1158 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1160 strcpy(id.name, name);
1161 return snd_ctl_find_id(codec->bus->card, &id);
1164 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1167 return _snd_hda_find_mixer_ctl(codec, name, 0);
1170 /* Add a control element and assign to the codec */
1171 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1174 struct snd_kcontrol **knewp;
1176 err = snd_ctl_add(codec->bus->card, kctl);
1179 knewp = snd_array_new(&codec->mixers);
1186 /* Clear all controls assigned to the given codec */
1187 void snd_hda_ctls_clear(struct hda_codec *codec)
1190 struct snd_kcontrol **kctls = codec->mixers.list;
1191 for (i = 0; i < codec->mixers.used; i++)
1192 snd_ctl_remove(codec->bus->card, kctls[i]);
1193 snd_array_free(&codec->mixers);
1196 void snd_hda_codec_reset(struct hda_codec *codec)
1200 #ifdef CONFIG_SND_HDA_POWER_SAVE
1201 cancel_delayed_work(&codec->power_work);
1202 flush_scheduled_work();
1204 snd_hda_ctls_clear(codec);
1206 for (i = 0; i < codec->num_pcms; i++) {
1207 if (codec->pcm_info[i].pcm)
1208 snd_device_free(codec->bus->card,
1209 codec->pcm_info[i].pcm);
1211 if (codec->patch_ops.free)
1212 codec->patch_ops.free(codec);
1214 free_hda_cache(&codec->amp_cache);
1215 free_hda_cache(&codec->cmd_cache);
1216 codec->num_pcms = 0;
1217 codec->pcm_info = NULL;
1218 codec->preset = NULL;
1221 /* create a virtual master control and add slaves */
1222 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1223 unsigned int *tlv, const char **slaves)
1225 struct snd_kcontrol *kctl;
1229 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1232 snd_printdd("No slave found for %s\n", name);
1235 kctl = snd_ctl_make_virtual_master(name, tlv);
1238 err = snd_hda_ctl_add(codec, kctl);
1242 for (s = slaves; *s; s++) {
1243 struct snd_kcontrol *sctl;
1245 sctl = snd_hda_find_mixer_ctl(codec, *s);
1247 snd_printdd("Cannot find slave %s, skipped\n", *s);
1250 err = snd_ctl_add_slave(kctl, sctl);
1258 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1259 struct snd_ctl_elem_info *uinfo)
1261 int chs = get_amp_channels(kcontrol);
1263 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1264 uinfo->count = chs == 3 ? 2 : 1;
1265 uinfo->value.integer.min = 0;
1266 uinfo->value.integer.max = 1;
1270 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1271 struct snd_ctl_elem_value *ucontrol)
1273 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1274 hda_nid_t nid = get_amp_nid(kcontrol);
1275 int chs = get_amp_channels(kcontrol);
1276 int dir = get_amp_direction(kcontrol);
1277 int idx = get_amp_index(kcontrol);
1278 long *valp = ucontrol->value.integer.value;
1281 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1282 HDA_AMP_MUTE) ? 0 : 1;
1284 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1285 HDA_AMP_MUTE) ? 0 : 1;
1289 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1290 struct snd_ctl_elem_value *ucontrol)
1292 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1293 hda_nid_t nid = get_amp_nid(kcontrol);
1294 int chs = get_amp_channels(kcontrol);
1295 int dir = get_amp_direction(kcontrol);
1296 int idx = get_amp_index(kcontrol);
1297 long *valp = ucontrol->value.integer.value;
1300 snd_hda_power_up(codec);
1302 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1304 *valp ? 0 : HDA_AMP_MUTE);
1308 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1310 *valp ? 0 : HDA_AMP_MUTE);
1311 #ifdef CONFIG_SND_HDA_POWER_SAVE
1312 if (codec->patch_ops.check_power_status)
1313 codec->patch_ops.check_power_status(codec, nid);
1315 snd_hda_power_down(codec);
1320 * bound volume controls
1322 * bind multiple volumes (# indices, from 0)
1325 #define AMP_VAL_IDX_SHIFT 19
1326 #define AMP_VAL_IDX_MASK (0x0f<<19)
1328 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1329 struct snd_ctl_elem_value *ucontrol)
1331 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1335 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1336 pval = kcontrol->private_value;
1337 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1338 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1339 kcontrol->private_value = pval;
1340 mutex_unlock(&codec->spdif_mutex);
1344 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1345 struct snd_ctl_elem_value *ucontrol)
1347 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1349 int i, indices, err = 0, change = 0;
1351 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1352 pval = kcontrol->private_value;
1353 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1354 for (i = 0; i < indices; i++) {
1355 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1356 (i << AMP_VAL_IDX_SHIFT);
1357 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1362 kcontrol->private_value = pval;
1363 mutex_unlock(&codec->spdif_mutex);
1364 return err < 0 ? err : change;
1368 * generic bound volume/swtich controls
1370 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1371 struct snd_ctl_elem_info *uinfo)
1373 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1374 struct hda_bind_ctls *c;
1377 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1378 c = (struct hda_bind_ctls *)kcontrol->private_value;
1379 kcontrol->private_value = *c->values;
1380 err = c->ops->info(kcontrol, uinfo);
1381 kcontrol->private_value = (long)c;
1382 mutex_unlock(&codec->spdif_mutex);
1386 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1387 struct snd_ctl_elem_value *ucontrol)
1389 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1390 struct hda_bind_ctls *c;
1393 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1394 c = (struct hda_bind_ctls *)kcontrol->private_value;
1395 kcontrol->private_value = *c->values;
1396 err = c->ops->get(kcontrol, ucontrol);
1397 kcontrol->private_value = (long)c;
1398 mutex_unlock(&codec->spdif_mutex);
1402 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1403 struct snd_ctl_elem_value *ucontrol)
1405 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1406 struct hda_bind_ctls *c;
1407 unsigned long *vals;
1408 int err = 0, change = 0;
1410 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1411 c = (struct hda_bind_ctls *)kcontrol->private_value;
1412 for (vals = c->values; *vals; vals++) {
1413 kcontrol->private_value = *vals;
1414 err = c->ops->put(kcontrol, ucontrol);
1419 kcontrol->private_value = (long)c;
1420 mutex_unlock(&codec->spdif_mutex);
1421 return err < 0 ? err : change;
1424 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1425 unsigned int size, unsigned int __user *tlv)
1427 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1428 struct hda_bind_ctls *c;
1431 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1432 c = (struct hda_bind_ctls *)kcontrol->private_value;
1433 kcontrol->private_value = *c->values;
1434 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1435 kcontrol->private_value = (long)c;
1436 mutex_unlock(&codec->spdif_mutex);
1440 struct hda_ctl_ops snd_hda_bind_vol = {
1441 .info = snd_hda_mixer_amp_volume_info,
1442 .get = snd_hda_mixer_amp_volume_get,
1443 .put = snd_hda_mixer_amp_volume_put,
1444 .tlv = snd_hda_mixer_amp_tlv
1447 struct hda_ctl_ops snd_hda_bind_sw = {
1448 .info = snd_hda_mixer_amp_switch_info,
1449 .get = snd_hda_mixer_amp_switch_get,
1450 .put = snd_hda_mixer_amp_switch_put,
1451 .tlv = snd_hda_mixer_amp_tlv
1455 * SPDIF out controls
1458 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1459 struct snd_ctl_elem_info *uinfo)
1461 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1466 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1467 struct snd_ctl_elem_value *ucontrol)
1469 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1470 IEC958_AES0_NONAUDIO |
1471 IEC958_AES0_CON_EMPHASIS_5015 |
1472 IEC958_AES0_CON_NOT_COPYRIGHT;
1473 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1474 IEC958_AES1_CON_ORIGINAL;
1478 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1479 struct snd_ctl_elem_value *ucontrol)
1481 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1482 IEC958_AES0_NONAUDIO |
1483 IEC958_AES0_PRO_EMPHASIS_5015;
1487 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1488 struct snd_ctl_elem_value *ucontrol)
1490 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1492 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1493 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1494 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1495 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1500 /* convert from SPDIF status bits to HDA SPDIF bits
1501 * bit 0 (DigEn) is always set zero (to be filled later)
1503 static unsigned short convert_from_spdif_status(unsigned int sbits)
1505 unsigned short val = 0;
1507 if (sbits & IEC958_AES0_PROFESSIONAL)
1508 val |= AC_DIG1_PROFESSIONAL;
1509 if (sbits & IEC958_AES0_NONAUDIO)
1510 val |= AC_DIG1_NONAUDIO;
1511 if (sbits & IEC958_AES0_PROFESSIONAL) {
1512 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1513 IEC958_AES0_PRO_EMPHASIS_5015)
1514 val |= AC_DIG1_EMPHASIS;
1516 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1517 IEC958_AES0_CON_EMPHASIS_5015)
1518 val |= AC_DIG1_EMPHASIS;
1519 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1520 val |= AC_DIG1_COPYRIGHT;
1521 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1522 val |= AC_DIG1_LEVEL;
1523 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1528 /* convert to SPDIF status bits from HDA SPDIF bits
1530 static unsigned int convert_to_spdif_status(unsigned short val)
1532 unsigned int sbits = 0;
1534 if (val & AC_DIG1_NONAUDIO)
1535 sbits |= IEC958_AES0_NONAUDIO;
1536 if (val & AC_DIG1_PROFESSIONAL)
1537 sbits |= IEC958_AES0_PROFESSIONAL;
1538 if (sbits & IEC958_AES0_PROFESSIONAL) {
1539 if (sbits & AC_DIG1_EMPHASIS)
1540 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1542 if (val & AC_DIG1_EMPHASIS)
1543 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1544 if (!(val & AC_DIG1_COPYRIGHT))
1545 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1546 if (val & AC_DIG1_LEVEL)
1547 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1548 sbits |= val & (0x7f << 8);
1553 /* set digital convert verbs both for the given NID and its slaves */
1554 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1559 snd_hda_codec_write(codec, nid, 0, verb, val);
1560 d = codec->slave_dig_outs;
1564 snd_hda_codec_write(codec, *d, 0, verb, val);
1567 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1571 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1573 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1576 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1577 struct snd_ctl_elem_value *ucontrol)
1579 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1580 hda_nid_t nid = kcontrol->private_value;
1584 mutex_lock(&codec->spdif_mutex);
1585 codec->spdif_status = ucontrol->value.iec958.status[0] |
1586 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1587 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1588 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1589 val = convert_from_spdif_status(codec->spdif_status);
1590 val |= codec->spdif_ctls & 1;
1591 change = codec->spdif_ctls != val;
1592 codec->spdif_ctls = val;
1595 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1597 mutex_unlock(&codec->spdif_mutex);
1601 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1603 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1604 struct snd_ctl_elem_value *ucontrol)
1606 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1608 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1612 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1613 struct snd_ctl_elem_value *ucontrol)
1615 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1616 hda_nid_t nid = kcontrol->private_value;
1620 mutex_lock(&codec->spdif_mutex);
1621 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1622 if (ucontrol->value.integer.value[0])
1623 val |= AC_DIG1_ENABLE;
1624 change = codec->spdif_ctls != val;
1626 codec->spdif_ctls = val;
1627 set_dig_out_convert(codec, nid, val & 0xff, -1);
1628 /* unmute amp switch (if any) */
1629 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1630 (val & AC_DIG1_ENABLE))
1631 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1634 mutex_unlock(&codec->spdif_mutex);
1638 static struct snd_kcontrol_new dig_mixes[] = {
1640 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1641 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1642 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1643 .info = snd_hda_spdif_mask_info,
1644 .get = snd_hda_spdif_cmask_get,
1647 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1648 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1649 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1650 .info = snd_hda_spdif_mask_info,
1651 .get = snd_hda_spdif_pmask_get,
1654 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1655 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1656 .info = snd_hda_spdif_mask_info,
1657 .get = snd_hda_spdif_default_get,
1658 .put = snd_hda_spdif_default_put,
1661 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1662 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1663 .info = snd_hda_spdif_out_switch_info,
1664 .get = snd_hda_spdif_out_switch_get,
1665 .put = snd_hda_spdif_out_switch_put,
1670 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1673 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1674 * @codec: the HDA codec
1675 * @nid: audio out widget NID
1677 * Creates controls related with the SPDIF output.
1678 * Called from each patch supporting the SPDIF out.
1680 * Returns 0 if successful, or a negative error code.
1682 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1685 struct snd_kcontrol *kctl;
1686 struct snd_kcontrol_new *dig_mix;
1689 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1690 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1694 if (idx >= SPDIF_MAX_IDX) {
1695 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1698 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1699 kctl = snd_ctl_new1(dig_mix, codec);
1700 kctl->id.index = idx;
1701 kctl->private_value = nid;
1702 err = snd_hda_ctl_add(codec, kctl);
1707 snd_hda_codec_read(codec, nid, 0,
1708 AC_VERB_GET_DIGI_CONVERT_1, 0);
1709 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1714 * SPDIF sharing with analog output
1716 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1717 struct snd_ctl_elem_value *ucontrol)
1719 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1720 ucontrol->value.integer.value[0] = mout->share_spdif;
1724 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1725 struct snd_ctl_elem_value *ucontrol)
1727 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1728 mout->share_spdif = !!ucontrol->value.integer.value[0];
1732 static struct snd_kcontrol_new spdif_share_sw = {
1733 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1734 .name = "IEC958 Default PCM Playback Switch",
1735 .info = snd_ctl_boolean_mono_info,
1736 .get = spdif_share_sw_get,
1737 .put = spdif_share_sw_put,
1740 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
1741 struct hda_multi_out *mout)
1743 if (!mout->dig_out_nid)
1745 /* ATTENTION: here mout is passed as private_data, instead of codec */
1746 return snd_hda_ctl_add(codec,
1747 snd_ctl_new1(&spdif_share_sw, mout));
1754 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
1756 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
1757 struct snd_ctl_elem_value *ucontrol)
1759 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1761 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
1765 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
1766 struct snd_ctl_elem_value *ucontrol)
1768 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1769 hda_nid_t nid = kcontrol->private_value;
1770 unsigned int val = !!ucontrol->value.integer.value[0];
1773 mutex_lock(&codec->spdif_mutex);
1774 change = codec->spdif_in_enable != val;
1776 codec->spdif_in_enable = val;
1777 snd_hda_codec_write_cache(codec, nid, 0,
1778 AC_VERB_SET_DIGI_CONVERT_1, val);
1780 mutex_unlock(&codec->spdif_mutex);
1784 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
1785 struct snd_ctl_elem_value *ucontrol)
1787 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1788 hda_nid_t nid = kcontrol->private_value;
1792 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1793 sbits = convert_to_spdif_status(val);
1794 ucontrol->value.iec958.status[0] = sbits;
1795 ucontrol->value.iec958.status[1] = sbits >> 8;
1796 ucontrol->value.iec958.status[2] = sbits >> 16;
1797 ucontrol->value.iec958.status[3] = sbits >> 24;
1801 static struct snd_kcontrol_new dig_in_ctls[] = {
1803 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1804 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
1805 .info = snd_hda_spdif_in_switch_info,
1806 .get = snd_hda_spdif_in_switch_get,
1807 .put = snd_hda_spdif_in_switch_put,
1810 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1811 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1812 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1813 .info = snd_hda_spdif_mask_info,
1814 .get = snd_hda_spdif_in_status_get,
1820 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1821 * @codec: the HDA codec
1822 * @nid: audio in widget NID
1824 * Creates controls related with the SPDIF input.
1825 * Called from each patch supporting the SPDIF in.
1827 * Returns 0 if successful, or a negative error code.
1829 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1832 struct snd_kcontrol *kctl;
1833 struct snd_kcontrol_new *dig_mix;
1836 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1837 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
1841 if (idx >= SPDIF_MAX_IDX) {
1842 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
1845 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
1846 kctl = snd_ctl_new1(dig_mix, codec);
1847 kctl->private_value = nid;
1848 err = snd_hda_ctl_add(codec, kctl);
1852 codec->spdif_in_enable =
1853 snd_hda_codec_read(codec, nid, 0,
1854 AC_VERB_GET_DIGI_CONVERT_1, 0) &
1859 #ifdef SND_HDA_NEEDS_RESUME
1864 /* build a 32bit cache key with the widget id and the command parameter */
1865 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
1866 #define get_cmd_cache_nid(key) ((key) & 0xff)
1867 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
1870 * snd_hda_codec_write_cache - send a single command with caching
1871 * @codec: the HDA codec
1872 * @nid: NID to send the command
1873 * @direct: direct flag
1874 * @verb: the verb to send
1875 * @parm: the parameter for the verb
1877 * Send a single command without waiting for response.
1879 * Returns 0 if successful, or a negative error code.
1881 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
1882 int direct, unsigned int verb, unsigned int parm)
1885 snd_hda_power_up(codec);
1886 mutex_lock(&codec->bus->cmd_mutex);
1887 err = codec->bus->ops.command(codec, nid, direct, verb, parm);
1889 struct hda_cache_head *c;
1890 u32 key = build_cmd_cache_key(nid, verb);
1891 c = get_alloc_hash(&codec->cmd_cache, key);
1895 mutex_unlock(&codec->bus->cmd_mutex);
1896 snd_hda_power_down(codec);
1900 /* resume the all commands from the cache */
1901 void snd_hda_codec_resume_cache(struct hda_codec *codec)
1903 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
1906 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
1907 u32 key = buffer->key;
1910 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
1911 get_cmd_cache_cmd(key), buffer->val);
1916 * snd_hda_sequence_write_cache - sequence writes with caching
1917 * @codec: the HDA codec
1918 * @seq: VERB array to send
1920 * Send the commands sequentially from the given array.
1921 * Thte commands are recorded on cache for power-save and resume.
1922 * The array must be terminated with NID=0.
1924 void snd_hda_sequence_write_cache(struct hda_codec *codec,
1925 const struct hda_verb *seq)
1927 for (; seq->nid; seq++)
1928 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
1931 #endif /* SND_HDA_NEEDS_RESUME */
1934 * set power state of the codec
1936 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1937 unsigned int power_state)
1942 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
1944 msleep(10); /* partial workaround for "azx_get_response timeout" */
1946 nid = codec->start_nid;
1947 for (i = 0; i < codec->num_nodes; i++, nid++) {
1948 unsigned int wcaps = get_wcaps(codec, nid);
1949 if (wcaps & AC_WCAP_POWER) {
1950 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
1952 if (wid_type == AC_WID_PIN) {
1953 unsigned int pincap;
1955 * don't power down the widget if it controls
1956 * eapd and EAPD_BTLENABLE is set.
1958 pincap = snd_hda_param_read(codec, nid,
1960 if (pincap & AC_PINCAP_EAPD) {
1961 int eapd = snd_hda_codec_read(codec,
1963 AC_VERB_GET_EAPD_BTLENABLE, 0);
1965 if (power_state == AC_PWRST_D3 && eapd)
1969 snd_hda_codec_write(codec, nid, 0,
1970 AC_VERB_SET_POWER_STATE,
1975 if (power_state == AC_PWRST_D0) {
1976 unsigned long end_time;
1979 /* wait until the codec reachs to D0 */
1980 end_time = jiffies + msecs_to_jiffies(500);
1982 state = snd_hda_codec_read(codec, fg, 0,
1983 AC_VERB_GET_POWER_STATE, 0);
1984 if (state == power_state)
1987 } while (time_after_eq(end_time, jiffies));
1991 #ifdef CONFIG_SND_HDA_HWDEP
1992 /* execute additional init verbs */
1993 static void hda_exec_init_verbs(struct hda_codec *codec)
1995 if (codec->init_verbs.list)
1996 snd_hda_sequence_write(codec, codec->init_verbs.list);
1999 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2002 #ifdef SND_HDA_NEEDS_RESUME
2004 * call suspend and power-down; used both from PM and power-save
2006 static void hda_call_codec_suspend(struct hda_codec *codec)
2008 if (codec->patch_ops.suspend)
2009 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2010 hda_set_power_state(codec,
2011 codec->afg ? codec->afg : codec->mfg,
2013 #ifdef CONFIG_SND_HDA_POWER_SAVE
2014 cancel_delayed_work(&codec->power_work);
2015 codec->power_on = 0;
2016 codec->power_transition = 0;
2021 * kick up codec; used both from PM and power-save
2023 static void hda_call_codec_resume(struct hda_codec *codec)
2025 hda_set_power_state(codec,
2026 codec->afg ? codec->afg : codec->mfg,
2028 hda_exec_init_verbs(codec);
2029 if (codec->patch_ops.resume)
2030 codec->patch_ops.resume(codec);
2032 if (codec->patch_ops.init)
2033 codec->patch_ops.init(codec);
2034 snd_hda_codec_resume_amp(codec);
2035 snd_hda_codec_resume_cache(codec);
2038 #endif /* SND_HDA_NEEDS_RESUME */
2042 * snd_hda_build_controls - build mixer controls
2045 * Creates mixer controls for each codec included in the bus.
2047 * Returns 0 if successful, otherwise a negative error code.
2049 int __devinit snd_hda_build_controls(struct hda_bus *bus)
2051 struct hda_codec *codec;
2053 list_for_each_entry(codec, &bus->codec_list, list) {
2054 int err = snd_hda_codec_build_controls(codec);
2061 int snd_hda_codec_build_controls(struct hda_codec *codec)
2064 /* fake as if already powered-on */
2065 hda_keep_power_on(codec);
2067 hda_set_power_state(codec,
2068 codec->afg ? codec->afg : codec->mfg,
2070 hda_exec_init_verbs(codec);
2071 /* continue to initialize... */
2072 if (codec->patch_ops.init)
2073 err = codec->patch_ops.init(codec);
2074 if (!err && codec->patch_ops.build_controls)
2075 err = codec->patch_ops.build_controls(codec);
2076 snd_hda_power_down(codec);
2085 struct hda_rate_tbl {
2087 unsigned int alsa_bits;
2088 unsigned int hda_fmt;
2091 static struct hda_rate_tbl rate_bits[] = {
2092 /* rate in Hz, ALSA rate bitmask, HDA format value */
2094 /* autodetected value used in snd_hda_query_supported_pcm */
2095 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2096 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2097 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2098 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2099 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2100 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2101 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2102 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2103 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2104 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2105 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2106 #define AC_PAR_PCM_RATE_BITS 11
2107 /* up to bits 10, 384kHZ isn't supported properly */
2109 /* not autodetected value */
2110 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2112 { 0 } /* terminator */
2116 * snd_hda_calc_stream_format - calculate format bitset
2117 * @rate: the sample rate
2118 * @channels: the number of channels
2119 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2120 * @maxbps: the max. bps
2122 * Calculate the format bitset from the given rate, channels and th PCM format.
2124 * Return zero if invalid.
2126 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2127 unsigned int channels,
2128 unsigned int format,
2129 unsigned int maxbps)
2132 unsigned int val = 0;
2134 for (i = 0; rate_bits[i].hz; i++)
2135 if (rate_bits[i].hz == rate) {
2136 val = rate_bits[i].hda_fmt;
2139 if (!rate_bits[i].hz) {
2140 snd_printdd("invalid rate %d\n", rate);
2144 if (channels == 0 || channels > 8) {
2145 snd_printdd("invalid channels %d\n", channels);
2148 val |= channels - 1;
2150 switch (snd_pcm_format_width(format)) {
2151 case 8: val |= 0x00; break;
2152 case 16: val |= 0x10; break;
2158 else if (maxbps >= 24)
2164 snd_printdd("invalid format width %d\n",
2165 snd_pcm_format_width(format));
2173 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2174 * @codec: the HDA codec
2175 * @nid: NID to query
2176 * @ratesp: the pointer to store the detected rate bitflags
2177 * @formatsp: the pointer to store the detected formats
2178 * @bpsp: the pointer to store the detected format widths
2180 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2181 * or @bsps argument is ignored.
2183 * Returns 0 if successful, otherwise a negative error code.
2185 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2186 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2189 unsigned int val, streams;
2192 if (nid != codec->afg &&
2193 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2194 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2199 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2203 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2205 rates |= rate_bits[i].alsa_bits;
2210 if (formatsp || bpsp) {
2215 wcaps = get_wcaps(codec, nid);
2216 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2220 streams = snd_hda_param_read(codec, codec->afg,
2227 if (streams & AC_SUPFMT_PCM) {
2228 if (val & AC_SUPPCM_BITS_8) {
2229 formats |= SNDRV_PCM_FMTBIT_U8;
2232 if (val & AC_SUPPCM_BITS_16) {
2233 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2236 if (wcaps & AC_WCAP_DIGITAL) {
2237 if (val & AC_SUPPCM_BITS_32)
2238 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2239 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2240 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2241 if (val & AC_SUPPCM_BITS_24)
2243 else if (val & AC_SUPPCM_BITS_20)
2245 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2246 AC_SUPPCM_BITS_32)) {
2247 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2248 if (val & AC_SUPPCM_BITS_32)
2250 else if (val & AC_SUPPCM_BITS_24)
2252 else if (val & AC_SUPPCM_BITS_20)
2256 else if (streams == AC_SUPFMT_FLOAT32) {
2257 /* should be exclusive */
2258 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2260 } else if (streams == AC_SUPFMT_AC3) {
2261 /* should be exclusive */
2262 /* temporary hack: we have still no proper support
2263 * for the direct AC3 stream...
2265 formats |= SNDRV_PCM_FMTBIT_U8;
2269 *formatsp = formats;
2278 * snd_hda_is_supported_format - check whether the given node supports
2281 * Returns 1 if supported, 0 if not.
2283 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2284 unsigned int format)
2287 unsigned int val = 0, rate, stream;
2289 if (nid != codec->afg &&
2290 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2291 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2296 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2301 rate = format & 0xff00;
2302 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2303 if (rate_bits[i].hda_fmt == rate) {
2308 if (i >= AC_PAR_PCM_RATE_BITS)
2311 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2314 if (!stream && nid != codec->afg)
2315 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2316 if (!stream || stream == -1)
2319 if (stream & AC_SUPFMT_PCM) {
2320 switch (format & 0xf0) {
2322 if (!(val & AC_SUPPCM_BITS_8))
2326 if (!(val & AC_SUPPCM_BITS_16))
2330 if (!(val & AC_SUPPCM_BITS_20))
2334 if (!(val & AC_SUPPCM_BITS_24))
2338 if (!(val & AC_SUPPCM_BITS_32))
2345 /* FIXME: check for float32 and AC3? */
2354 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2355 struct hda_codec *codec,
2356 struct snd_pcm_substream *substream)
2361 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2362 struct hda_codec *codec,
2363 unsigned int stream_tag,
2364 unsigned int format,
2365 struct snd_pcm_substream *substream)
2367 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2371 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2372 struct hda_codec *codec,
2373 struct snd_pcm_substream *substream)
2375 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2379 static int set_pcm_default_values(struct hda_codec *codec,
2380 struct hda_pcm_stream *info)
2382 /* query support PCM information from the given NID */
2383 if (info->nid && (!info->rates || !info->formats)) {
2384 snd_hda_query_supported_pcm(codec, info->nid,
2385 info->rates ? NULL : &info->rates,
2386 info->formats ? NULL : &info->formats,
2387 info->maxbps ? NULL : &info->maxbps);
2389 if (info->ops.open == NULL)
2390 info->ops.open = hda_pcm_default_open_close;
2391 if (info->ops.close == NULL)
2392 info->ops.close = hda_pcm_default_open_close;
2393 if (info->ops.prepare == NULL) {
2394 if (snd_BUG_ON(!info->nid))
2396 info->ops.prepare = hda_pcm_default_prepare;
2398 if (info->ops.cleanup == NULL) {
2399 if (snd_BUG_ON(!info->nid))
2401 info->ops.cleanup = hda_pcm_default_cleanup;
2407 * attach a new PCM stream
2409 static int __devinit
2410 snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2412 struct hda_pcm_stream *info;
2417 for (stream = 0; stream < 2; stream++) {
2418 info = &pcm->stream[stream];
2419 if (info->substreams) {
2420 err = set_pcm_default_values(codec, info);
2425 return codec->bus->ops.attach_pcm(codec, pcm);
2429 * snd_hda_build_pcms - build PCM information
2432 * Create PCM information for each codec included in the bus.
2434 * The build_pcms codec patch is requested to set up codec->num_pcms and
2435 * codec->pcm_info properly. The array is referred by the top-level driver
2436 * to create its PCM instances.
2437 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2440 * At least, substreams, channels_min and channels_max must be filled for
2441 * each stream. substreams = 0 indicates that the stream doesn't exist.
2442 * When rates and/or formats are zero, the supported values are queried
2443 * from the given nid. The nid is used also by the default ops.prepare
2444 * and ops.cleanup callbacks.
2446 * The driver needs to call ops.open in its open callback. Similarly,
2447 * ops.close is supposed to be called in the close callback.
2448 * ops.prepare should be called in the prepare or hw_params callback
2449 * with the proper parameters for set up.
2450 * ops.cleanup should be called in hw_free for clean up of streams.
2452 * This function returns 0 if successfull, or a negative error code.
2454 int snd_hda_build_pcms(struct hda_bus *bus)
2456 static const char *dev_name[HDA_PCM_NTYPES] = {
2457 "Audio", "SPDIF", "HDMI", "Modem"
2459 /* starting device index for each PCM type */
2460 static int dev_idx[HDA_PCM_NTYPES] = {
2461 [HDA_PCM_TYPE_AUDIO] = 0,
2462 [HDA_PCM_TYPE_SPDIF] = 1,
2463 [HDA_PCM_TYPE_HDMI] = 3,
2464 [HDA_PCM_TYPE_MODEM] = 6
2466 /* normal audio device indices; not linear to keep compatibility */
2467 static int audio_idx[4] = { 0, 2, 4, 5 };
2468 struct hda_codec *codec;
2469 int num_devs[HDA_PCM_NTYPES];
2471 memset(num_devs, 0, sizeof(num_devs));
2472 list_for_each_entry(codec, &bus->codec_list, list) {
2475 if (!codec->num_pcms) {
2476 if (!codec->patch_ops.build_pcms)
2478 err = codec->patch_ops.build_pcms(codec);
2482 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2483 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2484 int type = cpcm->pcm_type;
2487 case HDA_PCM_TYPE_AUDIO:
2488 if (num_devs[type] >= ARRAY_SIZE(audio_idx)) {
2489 snd_printk(KERN_WARNING
2490 "Too many audio devices\n");
2493 dev = audio_idx[num_devs[type]];
2495 case HDA_PCM_TYPE_SPDIF:
2496 case HDA_PCM_TYPE_HDMI:
2497 case HDA_PCM_TYPE_MODEM:
2498 if (num_devs[type]) {
2499 snd_printk(KERN_WARNING
2500 "%s already defined\n",
2504 dev = dev_idx[type];
2507 snd_printk(KERN_WARNING
2508 "Invalid PCM type %d\n", type);
2514 err = snd_hda_attach_pcm(codec, cpcm);
2524 * snd_hda_check_board_config - compare the current codec with the config table
2525 * @codec: the HDA codec
2526 * @num_configs: number of config enums
2527 * @models: array of model name strings
2528 * @tbl: configuration table, terminated by null entries
2530 * Compares the modelname or PCI subsystem id of the current codec with the
2531 * given configuration table. If a matching entry is found, returns its
2532 * config value (supposed to be 0 or positive).
2534 * If no entries are matching, the function returns a negative value.
2536 int snd_hda_check_board_config(struct hda_codec *codec,
2537 int num_configs, const char **models,
2538 const struct snd_pci_quirk *tbl)
2540 if (codec->modelname && models) {
2542 for (i = 0; i < num_configs; i++) {
2544 !strcmp(codec->modelname, models[i])) {
2545 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2546 "selected\n", models[i]);
2552 if (!codec->bus->pci || !tbl)
2555 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2558 if (tbl->value >= 0 && tbl->value < num_configs) {
2559 #ifdef CONFIG_SND_DEBUG_VERBOSE
2561 const char *model = NULL;
2563 model = models[tbl->value];
2565 sprintf(tmp, "#%d", tbl->value);
2568 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2569 "for config %x:%x (%s)\n",
2570 model, tbl->subvendor, tbl->subdevice,
2571 (tbl->name ? tbl->name : "Unknown device"));
2579 * snd_hda_add_new_ctls - create controls from the array
2580 * @codec: the HDA codec
2581 * @knew: the array of struct snd_kcontrol_new
2583 * This helper function creates and add new controls in the given array.
2584 * The array must be terminated with an empty entry as terminator.
2586 * Returns 0 if successful, or a negative error code.
2588 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
2592 for (; knew->name; knew++) {
2593 struct snd_kcontrol *kctl;
2594 kctl = snd_ctl_new1(knew, codec);
2597 err = snd_hda_ctl_add(codec, kctl);
2601 kctl = snd_ctl_new1(knew, codec);
2604 kctl->id.device = codec->addr;
2605 err = snd_hda_ctl_add(codec, kctl);
2613 #ifdef CONFIG_SND_HDA_POWER_SAVE
2614 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2615 unsigned int power_state);
2617 static void hda_power_work(struct work_struct *work)
2619 struct hda_codec *codec =
2620 container_of(work, struct hda_codec, power_work.work);
2622 if (!codec->power_on || codec->power_count) {
2623 codec->power_transition = 0;
2627 hda_call_codec_suspend(codec);
2628 if (codec->bus->ops.pm_notify)
2629 codec->bus->ops.pm_notify(codec);
2632 static void hda_keep_power_on(struct hda_codec *codec)
2634 codec->power_count++;
2635 codec->power_on = 1;
2638 void snd_hda_power_up(struct hda_codec *codec)
2640 codec->power_count++;
2641 if (codec->power_on || codec->power_transition)
2644 codec->power_on = 1;
2645 if (codec->bus->ops.pm_notify)
2646 codec->bus->ops.pm_notify(codec);
2647 hda_call_codec_resume(codec);
2648 cancel_delayed_work(&codec->power_work);
2649 codec->power_transition = 0;
2652 void snd_hda_power_down(struct hda_codec *codec)
2654 --codec->power_count;
2655 if (!codec->power_on || codec->power_count || codec->power_transition)
2658 codec->power_transition = 1; /* avoid reentrance */
2659 schedule_delayed_work(&codec->power_work,
2660 msecs_to_jiffies(power_save * 1000));
2664 int snd_hda_check_amp_list_power(struct hda_codec *codec,
2665 struct hda_loopback_check *check,
2668 struct hda_amp_list *p;
2671 if (!check->amplist)
2673 for (p = check->amplist; p->nid; p++) {
2678 return 0; /* nothing changed */
2680 for (p = check->amplist; p->nid; p++) {
2681 for (ch = 0; ch < 2; ch++) {
2682 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
2684 if (!(v & HDA_AMP_MUTE) && v > 0) {
2685 if (!check->power_on) {
2686 check->power_on = 1;
2687 snd_hda_power_up(codec);
2693 if (check->power_on) {
2694 check->power_on = 0;
2695 snd_hda_power_down(codec);
2702 * Channel mode helper
2704 int snd_hda_ch_mode_info(struct hda_codec *codec,
2705 struct snd_ctl_elem_info *uinfo,
2706 const struct hda_channel_mode *chmode,
2709 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2711 uinfo->value.enumerated.items = num_chmodes;
2712 if (uinfo->value.enumerated.item >= num_chmodes)
2713 uinfo->value.enumerated.item = num_chmodes - 1;
2714 sprintf(uinfo->value.enumerated.name, "%dch",
2715 chmode[uinfo->value.enumerated.item].channels);
2719 int snd_hda_ch_mode_get(struct hda_codec *codec,
2720 struct snd_ctl_elem_value *ucontrol,
2721 const struct hda_channel_mode *chmode,
2727 for (i = 0; i < num_chmodes; i++) {
2728 if (max_channels == chmode[i].channels) {
2729 ucontrol->value.enumerated.item[0] = i;
2736 int snd_hda_ch_mode_put(struct hda_codec *codec,
2737 struct snd_ctl_elem_value *ucontrol,
2738 const struct hda_channel_mode *chmode,
2744 mode = ucontrol->value.enumerated.item[0];
2745 if (mode >= num_chmodes)
2747 if (*max_channelsp == chmode[mode].channels)
2749 /* change the current channel setting */
2750 *max_channelsp = chmode[mode].channels;
2751 if (chmode[mode].sequence)
2752 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
2759 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
2760 struct snd_ctl_elem_info *uinfo)
2764 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2766 uinfo->value.enumerated.items = imux->num_items;
2767 if (!imux->num_items)
2769 index = uinfo->value.enumerated.item;
2770 if (index >= imux->num_items)
2771 index = imux->num_items - 1;
2772 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
2776 int snd_hda_input_mux_put(struct hda_codec *codec,
2777 const struct hda_input_mux *imux,
2778 struct snd_ctl_elem_value *ucontrol,
2780 unsigned int *cur_val)
2784 if (!imux->num_items)
2786 idx = ucontrol->value.enumerated.item[0];
2787 if (idx >= imux->num_items)
2788 idx = imux->num_items - 1;
2789 if (*cur_val == idx)
2791 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
2792 imux->items[idx].index);
2799 * Multi-channel / digital-out PCM helper functions
2802 /* setup SPDIF output stream */
2803 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
2804 unsigned int stream_tag, unsigned int format)
2806 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
2807 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2808 set_dig_out_convert(codec, nid,
2809 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
2811 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2812 if (codec->slave_dig_outs) {
2814 for (d = codec->slave_dig_outs; *d; d++)
2815 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
2818 /* turn on again (if needed) */
2819 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2820 set_dig_out_convert(codec, nid,
2821 codec->spdif_ctls & 0xff, -1);
2824 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
2826 snd_hda_codec_cleanup_stream(codec, nid);
2827 if (codec->slave_dig_outs) {
2829 for (d = codec->slave_dig_outs; *d; d++)
2830 snd_hda_codec_cleanup_stream(codec, *d);
2835 * open the digital out in the exclusive mode
2837 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
2838 struct hda_multi_out *mout)
2840 mutex_lock(&codec->spdif_mutex);
2841 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
2842 /* already opened as analog dup; reset it once */
2843 cleanup_dig_out_stream(codec, mout->dig_out_nid);
2844 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
2845 mutex_unlock(&codec->spdif_mutex);
2849 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
2850 struct hda_multi_out *mout,
2851 unsigned int stream_tag,
2852 unsigned int format,
2853 struct snd_pcm_substream *substream)
2855 mutex_lock(&codec->spdif_mutex);
2856 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
2857 mutex_unlock(&codec->spdif_mutex);
2862 * release the digital out
2864 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
2865 struct hda_multi_out *mout)
2867 mutex_lock(&codec->spdif_mutex);
2868 mout->dig_out_used = 0;
2869 mutex_unlock(&codec->spdif_mutex);
2874 * set up more restrictions for analog out
2876 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
2877 struct hda_multi_out *mout,
2878 struct snd_pcm_substream *substream,
2879 struct hda_pcm_stream *hinfo)
2881 struct snd_pcm_runtime *runtime = substream->runtime;
2882 runtime->hw.channels_max = mout->max_channels;
2883 if (mout->dig_out_nid) {
2884 if (!mout->analog_rates) {
2885 mout->analog_rates = hinfo->rates;
2886 mout->analog_formats = hinfo->formats;
2887 mout->analog_maxbps = hinfo->maxbps;
2889 runtime->hw.rates = mout->analog_rates;
2890 runtime->hw.formats = mout->analog_formats;
2891 hinfo->maxbps = mout->analog_maxbps;
2893 if (!mout->spdif_rates) {
2894 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
2896 &mout->spdif_formats,
2897 &mout->spdif_maxbps);
2899 mutex_lock(&codec->spdif_mutex);
2900 if (mout->share_spdif) {
2901 runtime->hw.rates &= mout->spdif_rates;
2902 runtime->hw.formats &= mout->spdif_formats;
2903 if (mout->spdif_maxbps < hinfo->maxbps)
2904 hinfo->maxbps = mout->spdif_maxbps;
2906 mutex_unlock(&codec->spdif_mutex);
2908 return snd_pcm_hw_constraint_step(substream->runtime, 0,
2909 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
2913 * set up the i/o for analog out
2914 * when the digital out is available, copy the front out to digital out, too.
2916 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
2917 struct hda_multi_out *mout,
2918 unsigned int stream_tag,
2919 unsigned int format,
2920 struct snd_pcm_substream *substream)
2922 hda_nid_t *nids = mout->dac_nids;
2923 int chs = substream->runtime->channels;
2926 mutex_lock(&codec->spdif_mutex);
2927 if (mout->dig_out_nid && mout->share_spdif &&
2928 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
2930 snd_hda_is_supported_format(codec, mout->dig_out_nid,
2932 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
2933 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
2934 setup_dig_out_stream(codec, mout->dig_out_nid,
2935 stream_tag, format);
2937 mout->dig_out_used = 0;
2938 cleanup_dig_out_stream(codec, mout->dig_out_nid);
2941 mutex_unlock(&codec->spdif_mutex);
2944 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
2946 if (!mout->no_share_stream &&
2947 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
2948 /* headphone out will just decode front left/right (stereo) */
2949 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
2951 /* extra outputs copied from front */
2952 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
2953 if (!mout->no_share_stream && mout->extra_out_nid[i])
2954 snd_hda_codec_setup_stream(codec,
2955 mout->extra_out_nid[i],
2956 stream_tag, 0, format);
2959 for (i = 1; i < mout->num_dacs; i++) {
2960 if (chs >= (i + 1) * 2) /* independent out */
2961 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
2963 else if (!mout->no_share_stream) /* copy front */
2964 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
2971 * clean up the setting for analog out
2973 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
2974 struct hda_multi_out *mout)
2976 hda_nid_t *nids = mout->dac_nids;
2979 for (i = 0; i < mout->num_dacs; i++)
2980 snd_hda_codec_cleanup_stream(codec, nids[i]);
2982 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
2983 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
2984 if (mout->extra_out_nid[i])
2985 snd_hda_codec_cleanup_stream(codec,
2986 mout->extra_out_nid[i]);
2987 mutex_lock(&codec->spdif_mutex);
2988 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
2989 cleanup_dig_out_stream(codec, mout->dig_out_nid);
2990 mout->dig_out_used = 0;
2992 mutex_unlock(&codec->spdif_mutex);
2997 * Helper for automatic pin configuration
3000 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3002 for (; *list; list++)
3010 * Sort an associated group of pins according to their sequence numbers.
3012 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3019 for (i = 0; i < num_pins; i++) {
3020 for (j = i + 1; j < num_pins; j++) {
3021 if (sequences[i] > sequences[j]) {
3023 sequences[i] = sequences[j];
3035 * Parse all pin widgets and store the useful pin nids to cfg
3037 * The number of line-outs or any primary output is stored in line_outs,
3038 * and the corresponding output pins are assigned to line_out_pins[],
3039 * in the order of front, rear, CLFE, side, ...
3041 * If more extra outputs (speaker and headphone) are found, the pins are
3042 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3043 * is detected, one of speaker of HP pins is assigned as the primary
3044 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3045 * if any analog output exists.
3047 * The analog input pins are assigned to input_pins array.
3048 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3051 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3052 struct auto_pin_cfg *cfg,
3053 hda_nid_t *ignore_nids)
3055 hda_nid_t nid, end_nid;
3056 short seq, assoc_line_out, assoc_speaker;
3057 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3058 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3059 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3061 memset(cfg, 0, sizeof(*cfg));
3063 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3064 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3065 memset(sequences_hp, 0, sizeof(sequences_hp));
3066 assoc_line_out = assoc_speaker = 0;
3068 end_nid = codec->start_nid + codec->num_nodes;
3069 for (nid = codec->start_nid; nid < end_nid; nid++) {
3070 unsigned int wid_caps = get_wcaps(codec, nid);
3071 unsigned int wid_type =
3072 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3073 unsigned int def_conf;
3076 /* read all default configuration for pin complex */
3077 if (wid_type != AC_WID_PIN)
3079 /* ignore the given nids (e.g. pc-beep returns error) */
3080 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3083 def_conf = snd_hda_codec_read(codec, nid, 0,
3084 AC_VERB_GET_CONFIG_DEFAULT, 0);
3085 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3087 loc = get_defcfg_location(def_conf);
3088 switch (get_defcfg_device(def_conf)) {
3089 case AC_JACK_LINE_OUT:
3090 seq = get_defcfg_sequence(def_conf);
3091 assoc = get_defcfg_association(def_conf);
3093 if (!(wid_caps & AC_WCAP_STEREO))
3094 if (!cfg->mono_out_pin)
3095 cfg->mono_out_pin = nid;
3098 if (!assoc_line_out)
3099 assoc_line_out = assoc;
3100 else if (assoc_line_out != assoc)
3102 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3104 cfg->line_out_pins[cfg->line_outs] = nid;
3105 sequences_line_out[cfg->line_outs] = seq;
3108 case AC_JACK_SPEAKER:
3109 seq = get_defcfg_sequence(def_conf);
3110 assoc = get_defcfg_association(def_conf);
3113 if (! assoc_speaker)
3114 assoc_speaker = assoc;
3115 else if (assoc_speaker != assoc)
3117 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3119 cfg->speaker_pins[cfg->speaker_outs] = nid;
3120 sequences_speaker[cfg->speaker_outs] = seq;
3121 cfg->speaker_outs++;
3123 case AC_JACK_HP_OUT:
3124 seq = get_defcfg_sequence(def_conf);
3125 assoc = get_defcfg_association(def_conf);
3126 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3128 cfg->hp_pins[cfg->hp_outs] = nid;
3129 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3132 case AC_JACK_MIC_IN: {
3134 if (loc == AC_JACK_LOC_FRONT) {
3135 preferred = AUTO_PIN_FRONT_MIC;
3138 preferred = AUTO_PIN_MIC;
3139 alt = AUTO_PIN_FRONT_MIC;
3141 if (!cfg->input_pins[preferred])
3142 cfg->input_pins[preferred] = nid;
3143 else if (!cfg->input_pins[alt])
3144 cfg->input_pins[alt] = nid;
3147 case AC_JACK_LINE_IN:
3148 if (loc == AC_JACK_LOC_FRONT)
3149 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3151 cfg->input_pins[AUTO_PIN_LINE] = nid;
3154 cfg->input_pins[AUTO_PIN_CD] = nid;
3157 cfg->input_pins[AUTO_PIN_AUX] = nid;
3159 case AC_JACK_SPDIF_OUT:
3160 cfg->dig_out_pin = nid;
3162 case AC_JACK_SPDIF_IN:
3163 cfg->dig_in_pin = nid;
3169 * If no line-out is defined but multiple HPs are found,
3170 * some of them might be the real line-outs.
3172 if (!cfg->line_outs && cfg->hp_outs > 1) {
3174 while (i < cfg->hp_outs) {
3175 /* The real HPs should have the sequence 0x0f */
3176 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3180 /* Move it to the line-out table */
3181 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3182 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3185 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3186 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3187 memmove(sequences_hp + i - 1, sequences_hp + i,
3188 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3192 /* sort by sequence */
3193 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3195 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3197 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3200 /* if we have only one mic, make it AUTO_PIN_MIC */
3201 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3202 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3203 cfg->input_pins[AUTO_PIN_MIC] =
3204 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3205 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3207 /* ditto for line-in */
3208 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3209 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3210 cfg->input_pins[AUTO_PIN_LINE] =
3211 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3212 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3216 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3217 * as a primary output
3219 if (!cfg->line_outs) {
3220 if (cfg->speaker_outs) {
3221 cfg->line_outs = cfg->speaker_outs;
3222 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3223 sizeof(cfg->speaker_pins));
3224 cfg->speaker_outs = 0;
3225 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3226 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3227 } else if (cfg->hp_outs) {
3228 cfg->line_outs = cfg->hp_outs;
3229 memcpy(cfg->line_out_pins, cfg->hp_pins,
3230 sizeof(cfg->hp_pins));
3232 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3233 cfg->line_out_type = AUTO_PIN_HP_OUT;
3237 /* Reorder the surround channels
3238 * ALSA sequence is front/surr/clfe/side
3240 * 4-ch: front/surr => OK as it is
3241 * 6-ch: front/clfe/surr
3242 * 8-ch: front/clfe/rear/side|fc
3244 switch (cfg->line_outs) {
3247 nid = cfg->line_out_pins[1];
3248 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3249 cfg->line_out_pins[2] = nid;
3254 * debug prints of the parsed results
3256 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3257 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3258 cfg->line_out_pins[2], cfg->line_out_pins[3],
3259 cfg->line_out_pins[4]);
3260 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3261 cfg->speaker_outs, cfg->speaker_pins[0],
3262 cfg->speaker_pins[1], cfg->speaker_pins[2],
3263 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3264 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3265 cfg->hp_outs, cfg->hp_pins[0],
3266 cfg->hp_pins[1], cfg->hp_pins[2],
3267 cfg->hp_pins[3], cfg->hp_pins[4]);
3268 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3269 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3270 " cd=0x%x, aux=0x%x\n",
3271 cfg->input_pins[AUTO_PIN_MIC],
3272 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3273 cfg->input_pins[AUTO_PIN_LINE],
3274 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3275 cfg->input_pins[AUTO_PIN_CD],
3276 cfg->input_pins[AUTO_PIN_AUX]);
3281 /* labels for input pins */
3282 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3283 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3293 * snd_hda_suspend - suspend the codecs
3295 * @state: suspsend state
3297 * Returns 0 if successful.
3299 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3301 struct hda_codec *codec;
3303 list_for_each_entry(codec, &bus->codec_list, list) {
3304 #ifdef CONFIG_SND_HDA_POWER_SAVE
3305 if (!codec->power_on)
3308 hda_call_codec_suspend(codec);
3314 * snd_hda_resume - resume the codecs
3316 * @state: resume state
3318 * Returns 0 if successful.
3320 * This fucntion is defined only when POWER_SAVE isn't set.
3321 * In the power-save mode, the codec is resumed dynamically.
3323 int snd_hda_resume(struct hda_bus *bus)
3325 struct hda_codec *codec;
3327 list_for_each_entry(codec, &bus->codec_list, list) {
3328 if (snd_hda_codec_needs_resume(codec))
3329 hda_call_codec_resume(codec);
3333 #ifdef CONFIG_SND_HDA_POWER_SAVE
3334 int snd_hda_codecs_inuse(struct hda_bus *bus)
3336 struct hda_codec *codec;
3338 list_for_each_entry(codec, &bus->codec_list, list) {
3339 if (snd_hda_codec_needs_resume(codec))
3351 /* get a new element from the given array
3352 * if it exceeds the pre-allocated array size, re-allocate the array
3354 void *snd_array_new(struct snd_array *array)
3356 if (array->used >= array->alloced) {
3357 int num = array->alloced + array->alloc_align;
3358 void *nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3362 memcpy(nlist, array->list,
3363 array->elem_size * array->alloced);
3366 array->list = nlist;
3367 array->alloced = num;
3369 return array->list + (array->used++ * array->elem_size);
3372 /* free the given array elements */
3373 void snd_array_free(struct snd_array *array)