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 { 0x434d, "C-Media" },
68 { 0x8384, "SigmaTel" },
72 static const struct hda_codec_preset *hda_preset_tables[] = {
73 #ifdef CONFIG_SND_HDA_CODEC_REALTEK
74 snd_hda_preset_realtek,
76 #ifdef CONFIG_SND_HDA_CODEC_CMEDIA
77 snd_hda_preset_cmedia,
79 #ifdef CONFIG_SND_HDA_CODEC_ANALOG
80 snd_hda_preset_analog,
82 #ifdef CONFIG_SND_HDA_CODEC_SIGMATEL
83 snd_hda_preset_sigmatel,
85 #ifdef CONFIG_SND_HDA_CODEC_SI3054
86 snd_hda_preset_si3054,
88 #ifdef CONFIG_SND_HDA_CODEC_ATIHDMI
89 snd_hda_preset_atihdmi,
91 #ifdef CONFIG_SND_HDA_CODEC_CONEXANT
92 snd_hda_preset_conexant,
94 #ifdef CONFIG_SND_HDA_CODEC_VIA
97 #ifdef CONFIG_SND_HDA_CODEC_NVHDMI
98 snd_hda_preset_nvhdmi,
103 #ifdef CONFIG_SND_HDA_POWER_SAVE
104 static void hda_power_work(struct work_struct *work);
105 static void hda_keep_power_on(struct hda_codec *codec);
107 static inline void hda_keep_power_on(struct hda_codec *codec) {}
110 const char *snd_hda_get_jack_location(u32 cfg)
112 static char *bases[7] = {
113 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
115 static unsigned char specials_idx[] = {
120 static char *specials[] = {
121 "Rear Panel", "Drive Bar",
122 "Riser", "HDMI", "ATAPI",
123 "Mobile-In", "Mobile-Out"
126 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
127 if ((cfg & 0x0f) < 7)
128 return bases[cfg & 0x0f];
129 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
130 if (cfg == specials_idx[i])
136 const char *snd_hda_get_jack_connectivity(u32 cfg)
138 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
140 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
143 const char *snd_hda_get_jack_type(u32 cfg)
145 static char *jack_types[16] = {
146 "Line Out", "Speaker", "HP Out", "CD",
147 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
148 "Line In", "Aux", "Mic", "Telephony",
149 "SPDIF In", "Digitial In", "Reserved", "Other"
152 return jack_types[(cfg & AC_DEFCFG_DEVICE)
153 >> AC_DEFCFG_DEVICE_SHIFT];
157 * snd_hda_codec_read - send a command and get the response
158 * @codec: the HDA codec
159 * @nid: NID to send the command
160 * @direct: direct flag
161 * @verb: the verb to send
162 * @parm: the parameter for the verb
164 * Send a single command and read the corresponding response.
166 * Returns the obtained response value, or -1 for an error.
168 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
170 unsigned int verb, unsigned int parm)
173 snd_hda_power_up(codec);
174 mutex_lock(&codec->bus->cmd_mutex);
175 if (!codec->bus->ops.command(codec, nid, direct, verb, parm))
176 res = codec->bus->ops.get_response(codec);
178 res = (unsigned int)-1;
179 mutex_unlock(&codec->bus->cmd_mutex);
180 snd_hda_power_down(codec);
185 * snd_hda_codec_write - send a single command without waiting for response
186 * @codec: the HDA codec
187 * @nid: NID to send the command
188 * @direct: direct flag
189 * @verb: the verb to send
190 * @parm: the parameter for the verb
192 * Send a single command without waiting for response.
194 * Returns 0 if successful, or a negative error code.
196 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
197 unsigned int verb, unsigned int parm)
200 snd_hda_power_up(codec);
201 mutex_lock(&codec->bus->cmd_mutex);
202 err = codec->bus->ops.command(codec, nid, direct, verb, parm);
203 mutex_unlock(&codec->bus->cmd_mutex);
204 snd_hda_power_down(codec);
209 * snd_hda_sequence_write - sequence writes
210 * @codec: the HDA codec
211 * @seq: VERB array to send
213 * Send the commands sequentially from the given array.
214 * The array must be terminated with NID=0.
216 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
218 for (; seq->nid; seq++)
219 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
223 * snd_hda_get_sub_nodes - get the range of sub nodes
224 * @codec: the HDA codec
226 * @start_id: the pointer to store the start NID
228 * Parse the NID and store the start NID of its sub-nodes.
229 * Returns the number of sub-nodes.
231 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
236 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
239 *start_id = (parm >> 16) & 0x7fff;
240 return (int)(parm & 0x7fff);
244 * snd_hda_get_connections - get connection list
245 * @codec: the HDA codec
247 * @conn_list: connection list array
248 * @max_conns: max. number of connections to store
250 * Parses the connection list of the given widget and stores the list
253 * Returns the number of connections, or a negative error code.
255 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
256 hda_nid_t *conn_list, int max_conns)
259 int i, conn_len, conns;
260 unsigned int shift, num_elems, mask;
263 if (snd_BUG_ON(!conn_list || max_conns <= 0))
266 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
267 if (parm & AC_CLIST_LONG) {
276 conn_len = parm & AC_CLIST_LENGTH;
277 mask = (1 << (shift-1)) - 1;
280 return 0; /* no connection */
283 /* single connection */
284 parm = snd_hda_codec_read(codec, nid, 0,
285 AC_VERB_GET_CONNECT_LIST, 0);
286 conn_list[0] = parm & mask;
290 /* multi connection */
293 for (i = 0; i < conn_len; i++) {
297 if (i % num_elems == 0)
298 parm = snd_hda_codec_read(codec, nid, 0,
299 AC_VERB_GET_CONNECT_LIST, i);
300 range_val = !!(parm & (1 << (shift-1))); /* ranges */
304 /* ranges between the previous and this one */
305 if (!prev_nid || prev_nid >= val) {
306 snd_printk(KERN_WARNING "hda_codec: "
307 "invalid dep_range_val %x:%x\n",
311 for (n = prev_nid + 1; n <= val; n++) {
312 if (conns >= max_conns) {
314 "Too many connections\n");
317 conn_list[conns++] = n;
320 if (conns >= max_conns) {
321 snd_printk(KERN_ERR "Too many connections\n");
324 conn_list[conns++] = val;
333 * snd_hda_queue_unsol_event - add an unsolicited event to queue
335 * @res: unsolicited event (lower 32bit of RIRB entry)
336 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
338 * Adds the given event to the queue. The events are processed in
339 * the workqueue asynchronously. Call this function in the interrupt
340 * hanlder when RIRB receives an unsolicited event.
342 * Returns 0 if successful, or a negative error code.
344 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
346 struct hda_bus_unsolicited *unsol;
353 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
357 unsol->queue[wp] = res;
358 unsol->queue[wp + 1] = res_ex;
360 schedule_work(&unsol->work);
366 * process queued unsolicited events
368 static void process_unsol_events(struct work_struct *work)
370 struct hda_bus_unsolicited *unsol =
371 container_of(work, struct hda_bus_unsolicited, work);
372 struct hda_bus *bus = unsol->bus;
373 struct hda_codec *codec;
374 unsigned int rp, caddr, res;
376 while (unsol->rp != unsol->wp) {
377 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
380 res = unsol->queue[rp];
381 caddr = unsol->queue[rp + 1];
382 if (!(caddr & (1 << 4))) /* no unsolicited event? */
384 codec = bus->caddr_tbl[caddr & 0x0f];
385 if (codec && codec->patch_ops.unsol_event)
386 codec->patch_ops.unsol_event(codec, res);
391 * initialize unsolicited queue
393 static int init_unsol_queue(struct hda_bus *bus)
395 struct hda_bus_unsolicited *unsol;
397 if (bus->unsol) /* already initialized */
400 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
402 snd_printk(KERN_ERR "hda_codec: "
403 "can't allocate unsolicited queue\n");
406 INIT_WORK(&unsol->work, process_unsol_events);
415 static void snd_hda_codec_free(struct hda_codec *codec);
417 static int snd_hda_bus_free(struct hda_bus *bus)
419 struct hda_codec *codec, *n;
424 flush_scheduled_work();
427 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
428 snd_hda_codec_free(codec);
430 if (bus->ops.private_free)
431 bus->ops.private_free(bus);
436 static int snd_hda_bus_dev_free(struct snd_device *device)
438 struct hda_bus *bus = device->device_data;
439 return snd_hda_bus_free(bus);
442 #ifdef CONFIG_SND_HDA_HWDEP
443 static int snd_hda_bus_dev_register(struct snd_device *device)
445 struct hda_bus *bus = device->device_data;
446 struct hda_codec *codec;
447 list_for_each_entry(codec, &bus->codec_list, list) {
448 snd_hda_hwdep_add_sysfs(codec);
453 #define snd_hda_bus_dev_register NULL
457 * snd_hda_bus_new - create a HDA bus
458 * @card: the card entry
459 * @temp: the template for hda_bus information
460 * @busp: the pointer to store the created bus instance
462 * Returns 0 if successful, or a negative error code.
464 int __devinit snd_hda_bus_new(struct snd_card *card,
465 const struct hda_bus_template *temp,
466 struct hda_bus **busp)
470 static struct snd_device_ops dev_ops = {
471 .dev_register = snd_hda_bus_dev_register,
472 .dev_free = snd_hda_bus_dev_free,
475 if (snd_BUG_ON(!temp))
477 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
483 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
485 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
490 bus->private_data = temp->private_data;
491 bus->pci = temp->pci;
492 bus->modelname = temp->modelname;
493 bus->ops = temp->ops;
495 mutex_init(&bus->cmd_mutex);
496 INIT_LIST_HEAD(&bus->codec_list);
498 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
500 snd_hda_bus_free(bus);
508 #ifdef CONFIG_SND_HDA_GENERIC
509 #define is_generic_config(codec) \
510 (codec->modelname && !strcmp(codec->modelname, "generic"))
512 #define is_generic_config(codec) 0
516 * find a matching codec preset
518 static const struct hda_codec_preset *
519 find_codec_preset(struct hda_codec *codec)
521 const struct hda_codec_preset **tbl, *preset;
523 if (is_generic_config(codec))
524 return NULL; /* use the generic parser */
526 for (tbl = hda_preset_tables; *tbl; tbl++) {
527 for (preset = *tbl; preset->id; preset++) {
528 u32 mask = preset->mask;
529 if (preset->afg && preset->afg != codec->afg)
531 if (preset->mfg && preset->mfg != codec->mfg)
535 if (preset->id == (codec->vendor_id & mask) &&
537 preset->rev == codec->revision_id))
545 * get_codec_name - store the codec name
547 static int get_codec_name(struct hda_codec *codec)
549 const struct hda_vendor_id *c;
550 const char *vendor = NULL;
551 u16 vendor_id = codec->vendor_id >> 16;
552 char tmp[16], name[32];
554 for (c = hda_vendor_ids; c->id; c++) {
555 if (c->id == vendor_id) {
561 sprintf(tmp, "Generic %04x", vendor_id);
564 if (codec->preset && codec->preset->name)
565 snprintf(name, sizeof(name), "%s %s", vendor,
566 codec->preset->name);
568 snprintf(name, sizeof(name), "%s ID %x", vendor,
569 codec->vendor_id & 0xffff);
570 codec->name = kstrdup(name, GFP_KERNEL);
577 * look for an AFG and MFG nodes
579 static void __devinit setup_fg_nodes(struct hda_codec *codec)
584 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
585 for (i = 0; i < total_nodes; i++, nid++) {
587 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
588 switch (func & 0xff) {
589 case AC_GRP_AUDIO_FUNCTION:
592 case AC_GRP_MODEM_FUNCTION:
602 * read widget caps for each widget and store in cache
604 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
609 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
611 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
614 nid = codec->start_nid;
615 for (i = 0; i < codec->num_nodes; i++, nid++)
616 codec->wcaps[i] = snd_hda_param_read(codec, nid,
617 AC_PAR_AUDIO_WIDGET_CAP);
622 static void init_hda_cache(struct hda_cache_rec *cache,
623 unsigned int record_size);
624 static void free_hda_cache(struct hda_cache_rec *cache);
629 static void snd_hda_codec_free(struct hda_codec *codec)
633 #ifdef CONFIG_SND_HDA_POWER_SAVE
634 cancel_delayed_work(&codec->power_work);
635 flush_scheduled_work();
637 list_del(&codec->list);
638 snd_array_free(&codec->mixers);
639 codec->bus->caddr_tbl[codec->addr] = NULL;
640 if (codec->patch_ops.free)
641 codec->patch_ops.free(codec);
642 free_hda_cache(&codec->amp_cache);
643 free_hda_cache(&codec->cmd_cache);
645 kfree(codec->modelname);
651 * snd_hda_codec_new - create a HDA codec
652 * @bus: the bus to assign
653 * @codec_addr: the codec address
654 * @codecp: the pointer to store the generated codec
656 * Returns 0 if successful, or a negative error code.
658 int __devinit snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
659 struct hda_codec **codecp)
661 struct hda_codec *codec;
665 if (snd_BUG_ON(!bus))
667 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
670 if (bus->caddr_tbl[codec_addr]) {
671 snd_printk(KERN_ERR "hda_codec: "
672 "address 0x%x is already occupied\n", codec_addr);
676 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
678 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
683 codec->addr = codec_addr;
684 mutex_init(&codec->spdif_mutex);
685 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
686 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
687 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
688 if (codec->bus->modelname) {
689 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
690 if (!codec->modelname) {
691 snd_hda_codec_free(codec);
696 #ifdef CONFIG_SND_HDA_POWER_SAVE
697 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
698 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
699 * the caller has to power down appropriatley after initialization
702 hda_keep_power_on(codec);
705 list_add_tail(&codec->list, &bus->codec_list);
706 bus->caddr_tbl[codec_addr] = codec;
708 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
710 if (codec->vendor_id == -1)
711 /* read again, hopefully the access method was corrected
712 * in the last read...
714 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
716 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
717 AC_PAR_SUBSYSTEM_ID);
718 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
721 setup_fg_nodes(codec);
722 if (!codec->afg && !codec->mfg) {
723 snd_printdd("hda_codec: no AFG or MFG node found\n");
724 snd_hda_codec_free(codec);
728 if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) {
729 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
730 snd_hda_codec_free(codec);
734 if (!codec->subsystem_id) {
735 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
736 codec->subsystem_id =
737 snd_hda_codec_read(codec, nid, 0,
738 AC_VERB_GET_SUBSYSTEM_ID, 0);
741 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
743 err = snd_hda_codec_configure(codec);
745 snd_hda_codec_free(codec);
748 snd_hda_codec_proc_new(codec);
750 snd_hda_create_hwdep(codec);
752 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
753 codec->subsystem_id, codec->revision_id);
754 snd_component_add(codec->bus->card, component);
761 int snd_hda_codec_configure(struct hda_codec *codec)
765 codec->preset = find_codec_preset(codec);
767 err = get_codec_name(codec);
771 /* audio codec should override the mixer name */
772 if (codec->afg || !*codec->bus->card->mixername)
773 strlcpy(codec->bus->card->mixername, codec->name,
774 sizeof(codec->bus->card->mixername));
776 if (is_generic_config(codec)) {
777 err = snd_hda_parse_generic_codec(codec);
780 if (codec->preset && codec->preset->patch) {
781 err = codec->preset->patch(codec);
785 /* call the default parser */
786 err = snd_hda_parse_generic_codec(codec);
788 printk(KERN_ERR "hda-codec: No codec parser is available\n");
791 if (!err && codec->patch_ops.unsol_event)
792 err = init_unsol_queue(codec->bus);
797 * snd_hda_codec_setup_stream - set up the codec for streaming
798 * @codec: the CODEC to set up
799 * @nid: the NID to set up
800 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
801 * @channel_id: channel id to pass, zero based.
802 * @format: stream format.
804 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
806 int channel_id, int format)
811 snd_printdd("hda_codec_setup_stream: "
812 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
813 nid, stream_tag, channel_id, format);
814 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
815 (stream_tag << 4) | channel_id);
817 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
820 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
825 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
826 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
827 #if 0 /* keep the format */
829 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
834 * amp access functions
837 /* FIXME: more better hash key? */
838 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
839 #define INFO_AMP_CAPS (1<<0)
840 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
842 /* initialize the hash table */
843 static void __devinit init_hda_cache(struct hda_cache_rec *cache,
844 unsigned int record_size)
846 memset(cache, 0, sizeof(*cache));
847 memset(cache->hash, 0xff, sizeof(cache->hash));
848 snd_array_init(&cache->buf, record_size, 64);
851 static void free_hda_cache(struct hda_cache_rec *cache)
853 snd_array_free(&cache->buf);
856 /* query the hash. allocate an entry if not found. */
857 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
860 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
861 u16 cur = cache->hash[idx];
862 struct hda_cache_head *info_head = cache->buf.list;
863 struct hda_cache_head *info;
865 while (cur != 0xffff) {
866 info = &info_head[cur];
867 if (info->key == key)
872 /* add a new hash entry */
873 info = snd_array_new(&cache->buf);
876 info->next = cache->hash[idx];
877 cache->hash[idx] = cur;
882 /* query and allocate an amp hash entry */
883 static inline struct hda_amp_info *
884 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
886 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
890 * query AMP capabilities for the given widget and direction
892 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
894 struct hda_amp_info *info;
896 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
899 if (!(info->head.val & INFO_AMP_CAPS)) {
900 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
902 info->amp_caps = snd_hda_param_read(codec, nid,
903 direction == HDA_OUTPUT ?
907 info->head.val |= INFO_AMP_CAPS;
909 return info->amp_caps;
912 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
915 struct hda_amp_info *info;
917 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
920 info->amp_caps = caps;
921 info->head.val |= INFO_AMP_CAPS;
926 * read the current volume to info
927 * if the cache exists, read the cache value.
929 static unsigned int get_vol_mute(struct hda_codec *codec,
930 struct hda_amp_info *info, hda_nid_t nid,
931 int ch, int direction, int index)
935 if (info->head.val & INFO_AMP_VOL(ch))
936 return info->vol[ch];
938 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
939 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
941 val = snd_hda_codec_read(codec, nid, 0,
942 AC_VERB_GET_AMP_GAIN_MUTE, parm);
943 info->vol[ch] = val & 0xff;
944 info->head.val |= INFO_AMP_VOL(ch);
945 return info->vol[ch];
949 * write the current volume in info to the h/w and update the cache
951 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
952 hda_nid_t nid, int ch, int direction, int index,
957 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
958 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
959 parm |= index << AC_AMP_SET_INDEX_SHIFT;
961 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
966 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
968 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
969 int direction, int index)
971 struct hda_amp_info *info;
972 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
975 return get_vol_mute(codec, info, nid, ch, direction, index);
979 * update the AMP value, mask = bit mask to set, val = the value
981 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
982 int direction, int idx, int mask, int val)
984 struct hda_amp_info *info;
986 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
990 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
991 if (info->vol[ch] == val)
993 put_vol_mute(codec, info, nid, ch, direction, idx, val);
998 * update the AMP stereo with the same mask and value
1000 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1001 int direction, int idx, int mask, int val)
1004 for (ch = 0; ch < 2; ch++)
1005 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1010 #ifdef SND_HDA_NEEDS_RESUME
1011 /* resume the all amp commands from the cache */
1012 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1014 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1017 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1018 u32 key = buffer->head.key;
1020 unsigned int idx, dir, ch;
1024 idx = (key >> 16) & 0xff;
1025 dir = (key >> 24) & 0xff;
1026 for (ch = 0; ch < 2; ch++) {
1027 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1029 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1034 #endif /* SND_HDA_NEEDS_RESUME */
1037 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1038 struct snd_ctl_elem_info *uinfo)
1040 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1041 u16 nid = get_amp_nid(kcontrol);
1042 u8 chs = get_amp_channels(kcontrol);
1043 int dir = get_amp_direction(kcontrol);
1046 caps = query_amp_caps(codec, nid, dir);
1048 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1050 printk(KERN_WARNING "hda_codec: "
1051 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1055 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1056 uinfo->count = chs == 3 ? 2 : 1;
1057 uinfo->value.integer.min = 0;
1058 uinfo->value.integer.max = caps;
1062 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1063 struct snd_ctl_elem_value *ucontrol)
1065 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1066 hda_nid_t nid = get_amp_nid(kcontrol);
1067 int chs = get_amp_channels(kcontrol);
1068 int dir = get_amp_direction(kcontrol);
1069 int idx = get_amp_index(kcontrol);
1070 long *valp = ucontrol->value.integer.value;
1073 *valp++ = snd_hda_codec_amp_read(codec, nid, 0, dir, idx)
1076 *valp = snd_hda_codec_amp_read(codec, nid, 1, dir, idx)
1081 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1082 struct snd_ctl_elem_value *ucontrol)
1084 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1085 hda_nid_t nid = get_amp_nid(kcontrol);
1086 int chs = get_amp_channels(kcontrol);
1087 int dir = get_amp_direction(kcontrol);
1088 int idx = get_amp_index(kcontrol);
1089 long *valp = ucontrol->value.integer.value;
1092 snd_hda_power_up(codec);
1094 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1099 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1101 snd_hda_power_down(codec);
1105 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1106 unsigned int size, unsigned int __user *_tlv)
1108 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1109 hda_nid_t nid = get_amp_nid(kcontrol);
1110 int dir = get_amp_direction(kcontrol);
1111 u32 caps, val1, val2;
1113 if (size < 4 * sizeof(unsigned int))
1115 caps = query_amp_caps(codec, nid, dir);
1116 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1117 val2 = (val2 + 1) * 25;
1118 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1119 val1 = ((int)val1) * ((int)val2);
1120 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1122 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1124 if (put_user(val1, _tlv + 2))
1126 if (put_user(val2, _tlv + 3))
1132 * set (static) TLV for virtual master volume; recalculated as max 0dB
1134 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1140 caps = query_amp_caps(codec, nid, dir);
1141 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1142 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1143 step = (step + 1) * 25;
1144 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1145 tlv[1] = 2 * sizeof(unsigned int);
1146 tlv[2] = -nums * step;
1150 /* find a mixer control element with the given name */
1151 static struct snd_kcontrol *
1152 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1153 const char *name, int idx)
1155 struct snd_ctl_elem_id id;
1156 memset(&id, 0, sizeof(id));
1157 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1159 strcpy(id.name, name);
1160 return snd_ctl_find_id(codec->bus->card, &id);
1163 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1166 return _snd_hda_find_mixer_ctl(codec, name, 0);
1169 /* Add a control element and assign to the codec */
1170 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1173 struct snd_kcontrol **knewp;
1175 err = snd_ctl_add(codec->bus->card, kctl);
1178 knewp = snd_array_new(&codec->mixers);
1185 /* Clear all controls assigned to the given codec */
1186 void snd_hda_ctls_clear(struct hda_codec *codec)
1189 struct snd_kcontrol **kctls = codec->mixers.list;
1190 for (i = 0; i < codec->mixers.used; i++)
1191 snd_ctl_remove(codec->bus->card, kctls[i]);
1192 snd_array_free(&codec->mixers);
1195 void snd_hda_codec_reset(struct hda_codec *codec)
1199 #ifdef CONFIG_SND_HDA_POWER_SAVE
1200 cancel_delayed_work(&codec->power_work);
1201 flush_scheduled_work();
1203 snd_hda_ctls_clear(codec);
1205 for (i = 0; i < codec->num_pcms; i++) {
1206 if (codec->pcm_info[i].pcm)
1207 snd_device_free(codec->bus->card,
1208 codec->pcm_info[i].pcm);
1210 if (codec->patch_ops.free)
1211 codec->patch_ops.free(codec);
1213 free_hda_cache(&codec->amp_cache);
1214 free_hda_cache(&codec->cmd_cache);
1215 codec->num_pcms = 0;
1216 codec->pcm_info = NULL;
1217 codec->preset = NULL;
1220 /* create a virtual master control and add slaves */
1221 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1222 unsigned int *tlv, const char **slaves)
1224 struct snd_kcontrol *kctl;
1228 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1231 snd_printdd("No slave found for %s\n", name);
1234 kctl = snd_ctl_make_virtual_master(name, tlv);
1237 err = snd_hda_ctl_add(codec, kctl);
1241 for (s = slaves; *s; s++) {
1242 struct snd_kcontrol *sctl;
1244 sctl = snd_hda_find_mixer_ctl(codec, *s);
1246 snd_printdd("Cannot find slave %s, skipped\n", *s);
1249 err = snd_ctl_add_slave(kctl, sctl);
1257 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1258 struct snd_ctl_elem_info *uinfo)
1260 int chs = get_amp_channels(kcontrol);
1262 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1263 uinfo->count = chs == 3 ? 2 : 1;
1264 uinfo->value.integer.min = 0;
1265 uinfo->value.integer.max = 1;
1269 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1270 struct snd_ctl_elem_value *ucontrol)
1272 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1273 hda_nid_t nid = get_amp_nid(kcontrol);
1274 int chs = get_amp_channels(kcontrol);
1275 int dir = get_amp_direction(kcontrol);
1276 int idx = get_amp_index(kcontrol);
1277 long *valp = ucontrol->value.integer.value;
1280 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1281 HDA_AMP_MUTE) ? 0 : 1;
1283 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1284 HDA_AMP_MUTE) ? 0 : 1;
1288 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1289 struct snd_ctl_elem_value *ucontrol)
1291 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1292 hda_nid_t nid = get_amp_nid(kcontrol);
1293 int chs = get_amp_channels(kcontrol);
1294 int dir = get_amp_direction(kcontrol);
1295 int idx = get_amp_index(kcontrol);
1296 long *valp = ucontrol->value.integer.value;
1299 snd_hda_power_up(codec);
1301 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1303 *valp ? 0 : HDA_AMP_MUTE);
1307 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1309 *valp ? 0 : HDA_AMP_MUTE);
1310 #ifdef CONFIG_SND_HDA_POWER_SAVE
1311 if (codec->patch_ops.check_power_status)
1312 codec->patch_ops.check_power_status(codec, nid);
1314 snd_hda_power_down(codec);
1319 * bound volume controls
1321 * bind multiple volumes (# indices, from 0)
1324 #define AMP_VAL_IDX_SHIFT 19
1325 #define AMP_VAL_IDX_MASK (0x0f<<19)
1327 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1328 struct snd_ctl_elem_value *ucontrol)
1330 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1334 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1335 pval = kcontrol->private_value;
1336 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1337 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1338 kcontrol->private_value = pval;
1339 mutex_unlock(&codec->spdif_mutex);
1343 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1344 struct snd_ctl_elem_value *ucontrol)
1346 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1348 int i, indices, err = 0, change = 0;
1350 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1351 pval = kcontrol->private_value;
1352 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1353 for (i = 0; i < indices; i++) {
1354 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1355 (i << AMP_VAL_IDX_SHIFT);
1356 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1361 kcontrol->private_value = pval;
1362 mutex_unlock(&codec->spdif_mutex);
1363 return err < 0 ? err : change;
1367 * generic bound volume/swtich controls
1369 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1370 struct snd_ctl_elem_info *uinfo)
1372 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1373 struct hda_bind_ctls *c;
1376 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1377 c = (struct hda_bind_ctls *)kcontrol->private_value;
1378 kcontrol->private_value = *c->values;
1379 err = c->ops->info(kcontrol, uinfo);
1380 kcontrol->private_value = (long)c;
1381 mutex_unlock(&codec->spdif_mutex);
1385 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1386 struct snd_ctl_elem_value *ucontrol)
1388 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1389 struct hda_bind_ctls *c;
1392 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1393 c = (struct hda_bind_ctls *)kcontrol->private_value;
1394 kcontrol->private_value = *c->values;
1395 err = c->ops->get(kcontrol, ucontrol);
1396 kcontrol->private_value = (long)c;
1397 mutex_unlock(&codec->spdif_mutex);
1401 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1402 struct snd_ctl_elem_value *ucontrol)
1404 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1405 struct hda_bind_ctls *c;
1406 unsigned long *vals;
1407 int err = 0, change = 0;
1409 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1410 c = (struct hda_bind_ctls *)kcontrol->private_value;
1411 for (vals = c->values; *vals; vals++) {
1412 kcontrol->private_value = *vals;
1413 err = c->ops->put(kcontrol, ucontrol);
1418 kcontrol->private_value = (long)c;
1419 mutex_unlock(&codec->spdif_mutex);
1420 return err < 0 ? err : change;
1423 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1424 unsigned int size, unsigned int __user *tlv)
1426 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1427 struct hda_bind_ctls *c;
1430 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1431 c = (struct hda_bind_ctls *)kcontrol->private_value;
1432 kcontrol->private_value = *c->values;
1433 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1434 kcontrol->private_value = (long)c;
1435 mutex_unlock(&codec->spdif_mutex);
1439 struct hda_ctl_ops snd_hda_bind_vol = {
1440 .info = snd_hda_mixer_amp_volume_info,
1441 .get = snd_hda_mixer_amp_volume_get,
1442 .put = snd_hda_mixer_amp_volume_put,
1443 .tlv = snd_hda_mixer_amp_tlv
1446 struct hda_ctl_ops snd_hda_bind_sw = {
1447 .info = snd_hda_mixer_amp_switch_info,
1448 .get = snd_hda_mixer_amp_switch_get,
1449 .put = snd_hda_mixer_amp_switch_put,
1450 .tlv = snd_hda_mixer_amp_tlv
1454 * SPDIF out controls
1457 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1458 struct snd_ctl_elem_info *uinfo)
1460 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1465 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1466 struct snd_ctl_elem_value *ucontrol)
1468 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1469 IEC958_AES0_NONAUDIO |
1470 IEC958_AES0_CON_EMPHASIS_5015 |
1471 IEC958_AES0_CON_NOT_COPYRIGHT;
1472 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1473 IEC958_AES1_CON_ORIGINAL;
1477 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1478 struct snd_ctl_elem_value *ucontrol)
1480 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1481 IEC958_AES0_NONAUDIO |
1482 IEC958_AES0_PRO_EMPHASIS_5015;
1486 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1487 struct snd_ctl_elem_value *ucontrol)
1489 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1491 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1492 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1493 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1494 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1499 /* convert from SPDIF status bits to HDA SPDIF bits
1500 * bit 0 (DigEn) is always set zero (to be filled later)
1502 static unsigned short convert_from_spdif_status(unsigned int sbits)
1504 unsigned short val = 0;
1506 if (sbits & IEC958_AES0_PROFESSIONAL)
1507 val |= AC_DIG1_PROFESSIONAL;
1508 if (sbits & IEC958_AES0_NONAUDIO)
1509 val |= AC_DIG1_NONAUDIO;
1510 if (sbits & IEC958_AES0_PROFESSIONAL) {
1511 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1512 IEC958_AES0_PRO_EMPHASIS_5015)
1513 val |= AC_DIG1_EMPHASIS;
1515 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1516 IEC958_AES0_CON_EMPHASIS_5015)
1517 val |= AC_DIG1_EMPHASIS;
1518 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1519 val |= AC_DIG1_COPYRIGHT;
1520 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1521 val |= AC_DIG1_LEVEL;
1522 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1527 /* convert to SPDIF status bits from HDA SPDIF bits
1529 static unsigned int convert_to_spdif_status(unsigned short val)
1531 unsigned int sbits = 0;
1533 if (val & AC_DIG1_NONAUDIO)
1534 sbits |= IEC958_AES0_NONAUDIO;
1535 if (val & AC_DIG1_PROFESSIONAL)
1536 sbits |= IEC958_AES0_PROFESSIONAL;
1537 if (sbits & IEC958_AES0_PROFESSIONAL) {
1538 if (sbits & AC_DIG1_EMPHASIS)
1539 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1541 if (val & AC_DIG1_EMPHASIS)
1542 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1543 if (!(val & AC_DIG1_COPYRIGHT))
1544 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1545 if (val & AC_DIG1_LEVEL)
1546 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1547 sbits |= val & (0x7f << 8);
1552 /* set digital convert verbs both for the given NID and its slaves */
1553 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1558 snd_hda_codec_write(codec, nid, 0, verb, val);
1559 d = codec->slave_dig_outs;
1563 snd_hda_codec_write(codec, *d, 0, verb, val);
1566 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1570 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1572 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1575 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1576 struct snd_ctl_elem_value *ucontrol)
1578 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1579 hda_nid_t nid = kcontrol->private_value;
1583 mutex_lock(&codec->spdif_mutex);
1584 codec->spdif_status = ucontrol->value.iec958.status[0] |
1585 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1586 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1587 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1588 val = convert_from_spdif_status(codec->spdif_status);
1589 val |= codec->spdif_ctls & 1;
1590 change = codec->spdif_ctls != val;
1591 codec->spdif_ctls = val;
1594 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1596 mutex_unlock(&codec->spdif_mutex);
1600 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1602 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1603 struct snd_ctl_elem_value *ucontrol)
1605 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1607 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1611 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1612 struct snd_ctl_elem_value *ucontrol)
1614 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1615 hda_nid_t nid = kcontrol->private_value;
1619 mutex_lock(&codec->spdif_mutex);
1620 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1621 if (ucontrol->value.integer.value[0])
1622 val |= AC_DIG1_ENABLE;
1623 change = codec->spdif_ctls != val;
1625 codec->spdif_ctls = val;
1626 set_dig_out_convert(codec, nid, val & 0xff, -1);
1627 /* unmute amp switch (if any) */
1628 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1629 (val & AC_DIG1_ENABLE))
1630 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1633 mutex_unlock(&codec->spdif_mutex);
1637 static struct snd_kcontrol_new dig_mixes[] = {
1639 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1640 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1641 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1642 .info = snd_hda_spdif_mask_info,
1643 .get = snd_hda_spdif_cmask_get,
1646 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1647 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1648 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1649 .info = snd_hda_spdif_mask_info,
1650 .get = snd_hda_spdif_pmask_get,
1653 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1654 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1655 .info = snd_hda_spdif_mask_info,
1656 .get = snd_hda_spdif_default_get,
1657 .put = snd_hda_spdif_default_put,
1660 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1661 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1662 .info = snd_hda_spdif_out_switch_info,
1663 .get = snd_hda_spdif_out_switch_get,
1664 .put = snd_hda_spdif_out_switch_put,
1669 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1672 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1673 * @codec: the HDA codec
1674 * @nid: audio out widget NID
1676 * Creates controls related with the SPDIF output.
1677 * Called from each patch supporting the SPDIF out.
1679 * Returns 0 if successful, or a negative error code.
1681 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1684 struct snd_kcontrol *kctl;
1685 struct snd_kcontrol_new *dig_mix;
1688 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1689 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1693 if (idx >= SPDIF_MAX_IDX) {
1694 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1697 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1698 kctl = snd_ctl_new1(dig_mix, codec);
1699 kctl->id.index = idx;
1700 kctl->private_value = nid;
1701 err = snd_hda_ctl_add(codec, kctl);
1706 snd_hda_codec_read(codec, nid, 0,
1707 AC_VERB_GET_DIGI_CONVERT_1, 0);
1708 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1713 * SPDIF sharing with analog output
1715 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1716 struct snd_ctl_elem_value *ucontrol)
1718 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1719 ucontrol->value.integer.value[0] = mout->share_spdif;
1723 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1724 struct snd_ctl_elem_value *ucontrol)
1726 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1727 mout->share_spdif = !!ucontrol->value.integer.value[0];
1731 static struct snd_kcontrol_new spdif_share_sw = {
1732 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1733 .name = "IEC958 Default PCM Playback Switch",
1734 .info = snd_ctl_boolean_mono_info,
1735 .get = spdif_share_sw_get,
1736 .put = spdif_share_sw_put,
1739 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
1740 struct hda_multi_out *mout)
1742 if (!mout->dig_out_nid)
1744 /* ATTENTION: here mout is passed as private_data, instead of codec */
1745 return snd_hda_ctl_add(codec,
1746 snd_ctl_new1(&spdif_share_sw, mout));
1753 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
1755 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
1756 struct snd_ctl_elem_value *ucontrol)
1758 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1760 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
1764 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
1765 struct snd_ctl_elem_value *ucontrol)
1767 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1768 hda_nid_t nid = kcontrol->private_value;
1769 unsigned int val = !!ucontrol->value.integer.value[0];
1772 mutex_lock(&codec->spdif_mutex);
1773 change = codec->spdif_in_enable != val;
1775 codec->spdif_in_enable = val;
1776 snd_hda_codec_write_cache(codec, nid, 0,
1777 AC_VERB_SET_DIGI_CONVERT_1, val);
1779 mutex_unlock(&codec->spdif_mutex);
1783 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
1784 struct snd_ctl_elem_value *ucontrol)
1786 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1787 hda_nid_t nid = kcontrol->private_value;
1791 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1792 sbits = convert_to_spdif_status(val);
1793 ucontrol->value.iec958.status[0] = sbits;
1794 ucontrol->value.iec958.status[1] = sbits >> 8;
1795 ucontrol->value.iec958.status[2] = sbits >> 16;
1796 ucontrol->value.iec958.status[3] = sbits >> 24;
1800 static struct snd_kcontrol_new dig_in_ctls[] = {
1802 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1803 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
1804 .info = snd_hda_spdif_in_switch_info,
1805 .get = snd_hda_spdif_in_switch_get,
1806 .put = snd_hda_spdif_in_switch_put,
1809 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1810 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1811 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1812 .info = snd_hda_spdif_mask_info,
1813 .get = snd_hda_spdif_in_status_get,
1819 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1820 * @codec: the HDA codec
1821 * @nid: audio in widget NID
1823 * Creates controls related with the SPDIF input.
1824 * Called from each patch supporting the SPDIF in.
1826 * Returns 0 if successful, or a negative error code.
1828 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1831 struct snd_kcontrol *kctl;
1832 struct snd_kcontrol_new *dig_mix;
1835 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1836 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
1840 if (idx >= SPDIF_MAX_IDX) {
1841 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
1844 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
1845 kctl = snd_ctl_new1(dig_mix, codec);
1846 kctl->private_value = nid;
1847 err = snd_hda_ctl_add(codec, kctl);
1851 codec->spdif_in_enable =
1852 snd_hda_codec_read(codec, nid, 0,
1853 AC_VERB_GET_DIGI_CONVERT_1, 0) &
1858 #ifdef SND_HDA_NEEDS_RESUME
1863 /* build a 32bit cache key with the widget id and the command parameter */
1864 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
1865 #define get_cmd_cache_nid(key) ((key) & 0xff)
1866 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
1869 * snd_hda_codec_write_cache - send a single command with caching
1870 * @codec: the HDA codec
1871 * @nid: NID to send the command
1872 * @direct: direct flag
1873 * @verb: the verb to send
1874 * @parm: the parameter for the verb
1876 * Send a single command without waiting for response.
1878 * Returns 0 if successful, or a negative error code.
1880 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
1881 int direct, unsigned int verb, unsigned int parm)
1884 snd_hda_power_up(codec);
1885 mutex_lock(&codec->bus->cmd_mutex);
1886 err = codec->bus->ops.command(codec, nid, direct, verb, parm);
1888 struct hda_cache_head *c;
1889 u32 key = build_cmd_cache_key(nid, verb);
1890 c = get_alloc_hash(&codec->cmd_cache, key);
1894 mutex_unlock(&codec->bus->cmd_mutex);
1895 snd_hda_power_down(codec);
1899 /* resume the all commands from the cache */
1900 void snd_hda_codec_resume_cache(struct hda_codec *codec)
1902 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
1905 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
1906 u32 key = buffer->key;
1909 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
1910 get_cmd_cache_cmd(key), buffer->val);
1915 * snd_hda_sequence_write_cache - sequence writes with caching
1916 * @codec: the HDA codec
1917 * @seq: VERB array to send
1919 * Send the commands sequentially from the given array.
1920 * Thte commands are recorded on cache for power-save and resume.
1921 * The array must be terminated with NID=0.
1923 void snd_hda_sequence_write_cache(struct hda_codec *codec,
1924 const struct hda_verb *seq)
1926 for (; seq->nid; seq++)
1927 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
1930 #endif /* SND_HDA_NEEDS_RESUME */
1933 * set power state of the codec
1935 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1936 unsigned int power_state)
1941 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
1943 msleep(10); /* partial workaround for "azx_get_response timeout" */
1945 nid = codec->start_nid;
1946 for (i = 0; i < codec->num_nodes; i++, nid++) {
1947 unsigned int wcaps = get_wcaps(codec, nid);
1948 if (wcaps & AC_WCAP_POWER) {
1949 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
1951 if (wid_type == AC_WID_PIN) {
1952 unsigned int pincap;
1954 * don't power down the widget if it controls
1955 * eapd and EAPD_BTLENABLE is set.
1957 pincap = snd_hda_param_read(codec, nid,
1959 if (pincap & AC_PINCAP_EAPD) {
1960 int eapd = snd_hda_codec_read(codec,
1962 AC_VERB_GET_EAPD_BTLENABLE, 0);
1964 if (power_state == AC_PWRST_D3 && eapd)
1968 snd_hda_codec_write(codec, nid, 0,
1969 AC_VERB_SET_POWER_STATE,
1974 if (power_state == AC_PWRST_D0) {
1975 unsigned long end_time;
1978 /* wait until the codec reachs to D0 */
1979 end_time = jiffies + msecs_to_jiffies(500);
1981 state = snd_hda_codec_read(codec, fg, 0,
1982 AC_VERB_GET_POWER_STATE, 0);
1983 if (state == power_state)
1986 } while (time_after_eq(end_time, jiffies));
1990 #ifdef CONFIG_SND_HDA_HWDEP
1991 /* execute additional init verbs */
1992 static void hda_exec_init_verbs(struct hda_codec *codec)
1994 if (codec->init_verbs.list)
1995 snd_hda_sequence_write(codec, codec->init_verbs.list);
1998 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2001 #ifdef SND_HDA_NEEDS_RESUME
2003 * call suspend and power-down; used both from PM and power-save
2005 static void hda_call_codec_suspend(struct hda_codec *codec)
2007 if (codec->patch_ops.suspend)
2008 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2009 hda_set_power_state(codec,
2010 codec->afg ? codec->afg : codec->mfg,
2012 #ifdef CONFIG_SND_HDA_POWER_SAVE
2013 cancel_delayed_work(&codec->power_work);
2014 codec->power_on = 0;
2015 codec->power_transition = 0;
2020 * kick up codec; used both from PM and power-save
2022 static void hda_call_codec_resume(struct hda_codec *codec)
2024 hda_set_power_state(codec,
2025 codec->afg ? codec->afg : codec->mfg,
2027 hda_exec_init_verbs(codec);
2028 if (codec->patch_ops.resume)
2029 codec->patch_ops.resume(codec);
2031 if (codec->patch_ops.init)
2032 codec->patch_ops.init(codec);
2033 snd_hda_codec_resume_amp(codec);
2034 snd_hda_codec_resume_cache(codec);
2037 #endif /* SND_HDA_NEEDS_RESUME */
2041 * snd_hda_build_controls - build mixer controls
2044 * Creates mixer controls for each codec included in the bus.
2046 * Returns 0 if successful, otherwise a negative error code.
2048 int __devinit snd_hda_build_controls(struct hda_bus *bus)
2050 struct hda_codec *codec;
2052 list_for_each_entry(codec, &bus->codec_list, list) {
2053 int err = snd_hda_codec_build_controls(codec);
2060 int snd_hda_codec_build_controls(struct hda_codec *codec)
2063 /* fake as if already powered-on */
2064 hda_keep_power_on(codec);
2066 hda_set_power_state(codec,
2067 codec->afg ? codec->afg : codec->mfg,
2069 hda_exec_init_verbs(codec);
2070 /* continue to initialize... */
2071 if (codec->patch_ops.init)
2072 err = codec->patch_ops.init(codec);
2073 if (!err && codec->patch_ops.build_controls)
2074 err = codec->patch_ops.build_controls(codec);
2075 snd_hda_power_down(codec);
2084 struct hda_rate_tbl {
2086 unsigned int alsa_bits;
2087 unsigned int hda_fmt;
2090 static struct hda_rate_tbl rate_bits[] = {
2091 /* rate in Hz, ALSA rate bitmask, HDA format value */
2093 /* autodetected value used in snd_hda_query_supported_pcm */
2094 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2095 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2096 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2097 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2098 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2099 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2100 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2101 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2102 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2103 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2104 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2105 #define AC_PAR_PCM_RATE_BITS 11
2106 /* up to bits 10, 384kHZ isn't supported properly */
2108 /* not autodetected value */
2109 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2111 { 0 } /* terminator */
2115 * snd_hda_calc_stream_format - calculate format bitset
2116 * @rate: the sample rate
2117 * @channels: the number of channels
2118 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2119 * @maxbps: the max. bps
2121 * Calculate the format bitset from the given rate, channels and th PCM format.
2123 * Return zero if invalid.
2125 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2126 unsigned int channels,
2127 unsigned int format,
2128 unsigned int maxbps)
2131 unsigned int val = 0;
2133 for (i = 0; rate_bits[i].hz; i++)
2134 if (rate_bits[i].hz == rate) {
2135 val = rate_bits[i].hda_fmt;
2138 if (!rate_bits[i].hz) {
2139 snd_printdd("invalid rate %d\n", rate);
2143 if (channels == 0 || channels > 8) {
2144 snd_printdd("invalid channels %d\n", channels);
2147 val |= channels - 1;
2149 switch (snd_pcm_format_width(format)) {
2150 case 8: val |= 0x00; break;
2151 case 16: val |= 0x10; break;
2157 else if (maxbps >= 24)
2163 snd_printdd("invalid format width %d\n",
2164 snd_pcm_format_width(format));
2172 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2173 * @codec: the HDA codec
2174 * @nid: NID to query
2175 * @ratesp: the pointer to store the detected rate bitflags
2176 * @formatsp: the pointer to store the detected formats
2177 * @bpsp: the pointer to store the detected format widths
2179 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2180 * or @bsps argument is ignored.
2182 * Returns 0 if successful, otherwise a negative error code.
2184 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2185 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2188 unsigned int val, streams;
2191 if (nid != codec->afg &&
2192 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2193 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2198 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2202 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2204 rates |= rate_bits[i].alsa_bits;
2209 if (formatsp || bpsp) {
2214 wcaps = get_wcaps(codec, nid);
2215 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2219 streams = snd_hda_param_read(codec, codec->afg,
2226 if (streams & AC_SUPFMT_PCM) {
2227 if (val & AC_SUPPCM_BITS_8) {
2228 formats |= SNDRV_PCM_FMTBIT_U8;
2231 if (val & AC_SUPPCM_BITS_16) {
2232 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2235 if (wcaps & AC_WCAP_DIGITAL) {
2236 if (val & AC_SUPPCM_BITS_32)
2237 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2238 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2239 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2240 if (val & AC_SUPPCM_BITS_24)
2242 else if (val & AC_SUPPCM_BITS_20)
2244 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2245 AC_SUPPCM_BITS_32)) {
2246 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2247 if (val & AC_SUPPCM_BITS_32)
2249 else if (val & AC_SUPPCM_BITS_24)
2251 else if (val & AC_SUPPCM_BITS_20)
2255 else if (streams == AC_SUPFMT_FLOAT32) {
2256 /* should be exclusive */
2257 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2259 } else if (streams == AC_SUPFMT_AC3) {
2260 /* should be exclusive */
2261 /* temporary hack: we have still no proper support
2262 * for the direct AC3 stream...
2264 formats |= SNDRV_PCM_FMTBIT_U8;
2268 *formatsp = formats;
2277 * snd_hda_is_supported_format - check whether the given node supports
2280 * Returns 1 if supported, 0 if not.
2282 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2283 unsigned int format)
2286 unsigned int val = 0, rate, stream;
2288 if (nid != codec->afg &&
2289 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2290 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2295 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2300 rate = format & 0xff00;
2301 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2302 if (rate_bits[i].hda_fmt == rate) {
2307 if (i >= AC_PAR_PCM_RATE_BITS)
2310 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2313 if (!stream && nid != codec->afg)
2314 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2315 if (!stream || stream == -1)
2318 if (stream & AC_SUPFMT_PCM) {
2319 switch (format & 0xf0) {
2321 if (!(val & AC_SUPPCM_BITS_8))
2325 if (!(val & AC_SUPPCM_BITS_16))
2329 if (!(val & AC_SUPPCM_BITS_20))
2333 if (!(val & AC_SUPPCM_BITS_24))
2337 if (!(val & AC_SUPPCM_BITS_32))
2344 /* FIXME: check for float32 and AC3? */
2353 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2354 struct hda_codec *codec,
2355 struct snd_pcm_substream *substream)
2360 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2361 struct hda_codec *codec,
2362 unsigned int stream_tag,
2363 unsigned int format,
2364 struct snd_pcm_substream *substream)
2366 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2370 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2371 struct hda_codec *codec,
2372 struct snd_pcm_substream *substream)
2374 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2378 static int set_pcm_default_values(struct hda_codec *codec,
2379 struct hda_pcm_stream *info)
2381 /* query support PCM information from the given NID */
2382 if (info->nid && (!info->rates || !info->formats)) {
2383 snd_hda_query_supported_pcm(codec, info->nid,
2384 info->rates ? NULL : &info->rates,
2385 info->formats ? NULL : &info->formats,
2386 info->maxbps ? NULL : &info->maxbps);
2388 if (info->ops.open == NULL)
2389 info->ops.open = hda_pcm_default_open_close;
2390 if (info->ops.close == NULL)
2391 info->ops.close = hda_pcm_default_open_close;
2392 if (info->ops.prepare == NULL) {
2393 if (snd_BUG_ON(!info->nid))
2395 info->ops.prepare = hda_pcm_default_prepare;
2397 if (info->ops.cleanup == NULL) {
2398 if (snd_BUG_ON(!info->nid))
2400 info->ops.cleanup = hda_pcm_default_cleanup;
2406 * attach a new PCM stream
2408 static int __devinit
2409 snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2411 struct hda_pcm_stream *info;
2416 for (stream = 0; stream < 2; stream++) {
2417 info = &pcm->stream[stream];
2418 if (info->substreams) {
2419 err = set_pcm_default_values(codec, info);
2424 return codec->bus->ops.attach_pcm(codec, pcm);
2428 * snd_hda_build_pcms - build PCM information
2431 * Create PCM information for each codec included in the bus.
2433 * The build_pcms codec patch is requested to set up codec->num_pcms and
2434 * codec->pcm_info properly. The array is referred by the top-level driver
2435 * to create its PCM instances.
2436 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2439 * At least, substreams, channels_min and channels_max must be filled for
2440 * each stream. substreams = 0 indicates that the stream doesn't exist.
2441 * When rates and/or formats are zero, the supported values are queried
2442 * from the given nid. The nid is used also by the default ops.prepare
2443 * and ops.cleanup callbacks.
2445 * The driver needs to call ops.open in its open callback. Similarly,
2446 * ops.close is supposed to be called in the close callback.
2447 * ops.prepare should be called in the prepare or hw_params callback
2448 * with the proper parameters for set up.
2449 * ops.cleanup should be called in hw_free for clean up of streams.
2451 * This function returns 0 if successfull, or a negative error code.
2453 int snd_hda_build_pcms(struct hda_bus *bus)
2455 static const char *dev_name[HDA_PCM_NTYPES] = {
2456 "Audio", "SPDIF", "HDMI", "Modem"
2458 /* starting device index for each PCM type */
2459 static int dev_idx[HDA_PCM_NTYPES] = {
2460 [HDA_PCM_TYPE_AUDIO] = 0,
2461 [HDA_PCM_TYPE_SPDIF] = 1,
2462 [HDA_PCM_TYPE_HDMI] = 3,
2463 [HDA_PCM_TYPE_MODEM] = 6
2465 /* normal audio device indices; not linear to keep compatibility */
2466 static int audio_idx[4] = { 0, 2, 4, 5 };
2467 struct hda_codec *codec;
2468 int num_devs[HDA_PCM_NTYPES];
2470 memset(num_devs, 0, sizeof(num_devs));
2471 list_for_each_entry(codec, &bus->codec_list, list) {
2474 if (!codec->num_pcms) {
2475 if (!codec->patch_ops.build_pcms)
2477 err = codec->patch_ops.build_pcms(codec);
2481 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2482 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2483 int type = cpcm->pcm_type;
2486 case HDA_PCM_TYPE_AUDIO:
2487 if (num_devs[type] >= ARRAY_SIZE(audio_idx)) {
2488 snd_printk(KERN_WARNING
2489 "Too many audio devices\n");
2492 dev = audio_idx[num_devs[type]];
2494 case HDA_PCM_TYPE_SPDIF:
2495 case HDA_PCM_TYPE_HDMI:
2496 case HDA_PCM_TYPE_MODEM:
2497 if (num_devs[type]) {
2498 snd_printk(KERN_WARNING
2499 "%s already defined\n",
2503 dev = dev_idx[type];
2506 snd_printk(KERN_WARNING
2507 "Invalid PCM type %d\n", type);
2513 err = snd_hda_attach_pcm(codec, cpcm);
2523 * snd_hda_check_board_config - compare the current codec with the config table
2524 * @codec: the HDA codec
2525 * @num_configs: number of config enums
2526 * @models: array of model name strings
2527 * @tbl: configuration table, terminated by null entries
2529 * Compares the modelname or PCI subsystem id of the current codec with the
2530 * given configuration table. If a matching entry is found, returns its
2531 * config value (supposed to be 0 or positive).
2533 * If no entries are matching, the function returns a negative value.
2535 int snd_hda_check_board_config(struct hda_codec *codec,
2536 int num_configs, const char **models,
2537 const struct snd_pci_quirk *tbl)
2539 if (codec->modelname && models) {
2541 for (i = 0; i < num_configs; i++) {
2543 !strcmp(codec->modelname, models[i])) {
2544 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2545 "selected\n", models[i]);
2551 if (!codec->bus->pci || !tbl)
2554 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2557 if (tbl->value >= 0 && tbl->value < num_configs) {
2558 #ifdef CONFIG_SND_DEBUG_VERBOSE
2560 const char *model = NULL;
2562 model = models[tbl->value];
2564 sprintf(tmp, "#%d", tbl->value);
2567 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2568 "for config %x:%x (%s)\n",
2569 model, tbl->subvendor, tbl->subdevice,
2570 (tbl->name ? tbl->name : "Unknown device"));
2578 * snd_hda_add_new_ctls - create controls from the array
2579 * @codec: the HDA codec
2580 * @knew: the array of struct snd_kcontrol_new
2582 * This helper function creates and add new controls in the given array.
2583 * The array must be terminated with an empty entry as terminator.
2585 * Returns 0 if successful, or a negative error code.
2587 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
2591 for (; knew->name; knew++) {
2592 struct snd_kcontrol *kctl;
2593 kctl = snd_ctl_new1(knew, codec);
2596 err = snd_hda_ctl_add(codec, kctl);
2600 kctl = snd_ctl_new1(knew, codec);
2603 kctl->id.device = codec->addr;
2604 err = snd_hda_ctl_add(codec, kctl);
2612 #ifdef CONFIG_SND_HDA_POWER_SAVE
2613 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2614 unsigned int power_state);
2616 static void hda_power_work(struct work_struct *work)
2618 struct hda_codec *codec =
2619 container_of(work, struct hda_codec, power_work.work);
2621 if (!codec->power_on || codec->power_count) {
2622 codec->power_transition = 0;
2626 hda_call_codec_suspend(codec);
2627 if (codec->bus->ops.pm_notify)
2628 codec->bus->ops.pm_notify(codec);
2631 static void hda_keep_power_on(struct hda_codec *codec)
2633 codec->power_count++;
2634 codec->power_on = 1;
2637 void snd_hda_power_up(struct hda_codec *codec)
2639 codec->power_count++;
2640 if (codec->power_on || codec->power_transition)
2643 codec->power_on = 1;
2644 if (codec->bus->ops.pm_notify)
2645 codec->bus->ops.pm_notify(codec);
2646 hda_call_codec_resume(codec);
2647 cancel_delayed_work(&codec->power_work);
2648 codec->power_transition = 0;
2651 void snd_hda_power_down(struct hda_codec *codec)
2653 --codec->power_count;
2654 if (!codec->power_on || codec->power_count || codec->power_transition)
2657 codec->power_transition = 1; /* avoid reentrance */
2658 schedule_delayed_work(&codec->power_work,
2659 msecs_to_jiffies(power_save * 1000));
2663 int snd_hda_check_amp_list_power(struct hda_codec *codec,
2664 struct hda_loopback_check *check,
2667 struct hda_amp_list *p;
2670 if (!check->amplist)
2672 for (p = check->amplist; p->nid; p++) {
2677 return 0; /* nothing changed */
2679 for (p = check->amplist; p->nid; p++) {
2680 for (ch = 0; ch < 2; ch++) {
2681 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
2683 if (!(v & HDA_AMP_MUTE) && v > 0) {
2684 if (!check->power_on) {
2685 check->power_on = 1;
2686 snd_hda_power_up(codec);
2692 if (check->power_on) {
2693 check->power_on = 0;
2694 snd_hda_power_down(codec);
2701 * Channel mode helper
2703 int snd_hda_ch_mode_info(struct hda_codec *codec,
2704 struct snd_ctl_elem_info *uinfo,
2705 const struct hda_channel_mode *chmode,
2708 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2710 uinfo->value.enumerated.items = num_chmodes;
2711 if (uinfo->value.enumerated.item >= num_chmodes)
2712 uinfo->value.enumerated.item = num_chmodes - 1;
2713 sprintf(uinfo->value.enumerated.name, "%dch",
2714 chmode[uinfo->value.enumerated.item].channels);
2718 int snd_hda_ch_mode_get(struct hda_codec *codec,
2719 struct snd_ctl_elem_value *ucontrol,
2720 const struct hda_channel_mode *chmode,
2726 for (i = 0; i < num_chmodes; i++) {
2727 if (max_channels == chmode[i].channels) {
2728 ucontrol->value.enumerated.item[0] = i;
2735 int snd_hda_ch_mode_put(struct hda_codec *codec,
2736 struct snd_ctl_elem_value *ucontrol,
2737 const struct hda_channel_mode *chmode,
2743 mode = ucontrol->value.enumerated.item[0];
2744 if (mode >= num_chmodes)
2746 if (*max_channelsp == chmode[mode].channels)
2748 /* change the current channel setting */
2749 *max_channelsp = chmode[mode].channels;
2750 if (chmode[mode].sequence)
2751 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
2758 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
2759 struct snd_ctl_elem_info *uinfo)
2763 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2765 uinfo->value.enumerated.items = imux->num_items;
2766 if (!imux->num_items)
2768 index = uinfo->value.enumerated.item;
2769 if (index >= imux->num_items)
2770 index = imux->num_items - 1;
2771 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
2775 int snd_hda_input_mux_put(struct hda_codec *codec,
2776 const struct hda_input_mux *imux,
2777 struct snd_ctl_elem_value *ucontrol,
2779 unsigned int *cur_val)
2783 if (!imux->num_items)
2785 idx = ucontrol->value.enumerated.item[0];
2786 if (idx >= imux->num_items)
2787 idx = imux->num_items - 1;
2788 if (*cur_val == idx)
2790 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
2791 imux->items[idx].index);
2798 * Multi-channel / digital-out PCM helper functions
2801 /* setup SPDIF output stream */
2802 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
2803 unsigned int stream_tag, unsigned int format)
2805 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
2806 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2807 set_dig_out_convert(codec, nid,
2808 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
2810 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2811 if (codec->slave_dig_outs) {
2813 for (d = codec->slave_dig_outs; *d; d++)
2814 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
2817 /* turn on again (if needed) */
2818 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2819 set_dig_out_convert(codec, nid,
2820 codec->spdif_ctls & 0xff, -1);
2823 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
2825 snd_hda_codec_cleanup_stream(codec, nid);
2826 if (codec->slave_dig_outs) {
2828 for (d = codec->slave_dig_outs; *d; d++)
2829 snd_hda_codec_cleanup_stream(codec, *d);
2834 * open the digital out in the exclusive mode
2836 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
2837 struct hda_multi_out *mout)
2839 mutex_lock(&codec->spdif_mutex);
2840 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
2841 /* already opened as analog dup; reset it once */
2842 cleanup_dig_out_stream(codec, mout->dig_out_nid);
2843 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
2844 mutex_unlock(&codec->spdif_mutex);
2848 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
2849 struct hda_multi_out *mout,
2850 unsigned int stream_tag,
2851 unsigned int format,
2852 struct snd_pcm_substream *substream)
2854 mutex_lock(&codec->spdif_mutex);
2855 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
2856 mutex_unlock(&codec->spdif_mutex);
2861 * release the digital out
2863 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
2864 struct hda_multi_out *mout)
2866 mutex_lock(&codec->spdif_mutex);
2867 mout->dig_out_used = 0;
2868 mutex_unlock(&codec->spdif_mutex);
2873 * set up more restrictions for analog out
2875 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
2876 struct hda_multi_out *mout,
2877 struct snd_pcm_substream *substream,
2878 struct hda_pcm_stream *hinfo)
2880 struct snd_pcm_runtime *runtime = substream->runtime;
2881 runtime->hw.channels_max = mout->max_channels;
2882 if (mout->dig_out_nid) {
2883 if (!mout->analog_rates) {
2884 mout->analog_rates = hinfo->rates;
2885 mout->analog_formats = hinfo->formats;
2886 mout->analog_maxbps = hinfo->maxbps;
2888 runtime->hw.rates = mout->analog_rates;
2889 runtime->hw.formats = mout->analog_formats;
2890 hinfo->maxbps = mout->analog_maxbps;
2892 if (!mout->spdif_rates) {
2893 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
2895 &mout->spdif_formats,
2896 &mout->spdif_maxbps);
2898 mutex_lock(&codec->spdif_mutex);
2899 if (mout->share_spdif) {
2900 runtime->hw.rates &= mout->spdif_rates;
2901 runtime->hw.formats &= mout->spdif_formats;
2902 if (mout->spdif_maxbps < hinfo->maxbps)
2903 hinfo->maxbps = mout->spdif_maxbps;
2905 mutex_unlock(&codec->spdif_mutex);
2907 return snd_pcm_hw_constraint_step(substream->runtime, 0,
2908 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
2912 * set up the i/o for analog out
2913 * when the digital out is available, copy the front out to digital out, too.
2915 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
2916 struct hda_multi_out *mout,
2917 unsigned int stream_tag,
2918 unsigned int format,
2919 struct snd_pcm_substream *substream)
2921 hda_nid_t *nids = mout->dac_nids;
2922 int chs = substream->runtime->channels;
2925 mutex_lock(&codec->spdif_mutex);
2926 if (mout->dig_out_nid && mout->share_spdif &&
2927 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
2929 snd_hda_is_supported_format(codec, mout->dig_out_nid,
2931 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
2932 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
2933 setup_dig_out_stream(codec, mout->dig_out_nid,
2934 stream_tag, format);
2936 mout->dig_out_used = 0;
2937 cleanup_dig_out_stream(codec, mout->dig_out_nid);
2940 mutex_unlock(&codec->spdif_mutex);
2943 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
2945 if (!mout->no_share_stream &&
2946 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
2947 /* headphone out will just decode front left/right (stereo) */
2948 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
2950 /* extra outputs copied from front */
2951 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
2952 if (!mout->no_share_stream && mout->extra_out_nid[i])
2953 snd_hda_codec_setup_stream(codec,
2954 mout->extra_out_nid[i],
2955 stream_tag, 0, format);
2958 for (i = 1; i < mout->num_dacs; i++) {
2959 if (chs >= (i + 1) * 2) /* independent out */
2960 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
2962 else if (!mout->no_share_stream) /* copy front */
2963 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
2970 * clean up the setting for analog out
2972 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
2973 struct hda_multi_out *mout)
2975 hda_nid_t *nids = mout->dac_nids;
2978 for (i = 0; i < mout->num_dacs; i++)
2979 snd_hda_codec_cleanup_stream(codec, nids[i]);
2981 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
2982 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
2983 if (mout->extra_out_nid[i])
2984 snd_hda_codec_cleanup_stream(codec,
2985 mout->extra_out_nid[i]);
2986 mutex_lock(&codec->spdif_mutex);
2987 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
2988 cleanup_dig_out_stream(codec, mout->dig_out_nid);
2989 mout->dig_out_used = 0;
2991 mutex_unlock(&codec->spdif_mutex);
2996 * Helper for automatic pin configuration
2999 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3001 for (; *list; list++)
3009 * Sort an associated group of pins according to their sequence numbers.
3011 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3018 for (i = 0; i < num_pins; i++) {
3019 for (j = i + 1; j < num_pins; j++) {
3020 if (sequences[i] > sequences[j]) {
3022 sequences[i] = sequences[j];
3034 * Parse all pin widgets and store the useful pin nids to cfg
3036 * The number of line-outs or any primary output is stored in line_outs,
3037 * and the corresponding output pins are assigned to line_out_pins[],
3038 * in the order of front, rear, CLFE, side, ...
3040 * If more extra outputs (speaker and headphone) are found, the pins are
3041 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3042 * is detected, one of speaker of HP pins is assigned as the primary
3043 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3044 * if any analog output exists.
3046 * The analog input pins are assigned to input_pins array.
3047 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3050 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3051 struct auto_pin_cfg *cfg,
3052 hda_nid_t *ignore_nids)
3054 hda_nid_t nid, end_nid;
3055 short seq, assoc_line_out, assoc_speaker;
3056 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3057 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3058 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3060 memset(cfg, 0, sizeof(*cfg));
3062 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3063 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3064 memset(sequences_hp, 0, sizeof(sequences_hp));
3065 assoc_line_out = assoc_speaker = 0;
3067 end_nid = codec->start_nid + codec->num_nodes;
3068 for (nid = codec->start_nid; nid < end_nid; nid++) {
3069 unsigned int wid_caps = get_wcaps(codec, nid);
3070 unsigned int wid_type =
3071 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3072 unsigned int def_conf;
3075 /* read all default configuration for pin complex */
3076 if (wid_type != AC_WID_PIN)
3078 /* ignore the given nids (e.g. pc-beep returns error) */
3079 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3082 def_conf = snd_hda_codec_read(codec, nid, 0,
3083 AC_VERB_GET_CONFIG_DEFAULT, 0);
3084 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3086 loc = get_defcfg_location(def_conf);
3087 switch (get_defcfg_device(def_conf)) {
3088 case AC_JACK_LINE_OUT:
3089 seq = get_defcfg_sequence(def_conf);
3090 assoc = get_defcfg_association(def_conf);
3092 if (!(wid_caps & AC_WCAP_STEREO))
3093 if (!cfg->mono_out_pin)
3094 cfg->mono_out_pin = nid;
3097 if (!assoc_line_out)
3098 assoc_line_out = assoc;
3099 else if (assoc_line_out != assoc)
3101 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3103 cfg->line_out_pins[cfg->line_outs] = nid;
3104 sequences_line_out[cfg->line_outs] = seq;
3107 case AC_JACK_SPEAKER:
3108 seq = get_defcfg_sequence(def_conf);
3109 assoc = get_defcfg_association(def_conf);
3112 if (! assoc_speaker)
3113 assoc_speaker = assoc;
3114 else if (assoc_speaker != assoc)
3116 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3118 cfg->speaker_pins[cfg->speaker_outs] = nid;
3119 sequences_speaker[cfg->speaker_outs] = seq;
3120 cfg->speaker_outs++;
3122 case AC_JACK_HP_OUT:
3123 seq = get_defcfg_sequence(def_conf);
3124 assoc = get_defcfg_association(def_conf);
3125 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3127 cfg->hp_pins[cfg->hp_outs] = nid;
3128 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3131 case AC_JACK_MIC_IN: {
3133 if (loc == AC_JACK_LOC_FRONT) {
3134 preferred = AUTO_PIN_FRONT_MIC;
3137 preferred = AUTO_PIN_MIC;
3138 alt = AUTO_PIN_FRONT_MIC;
3140 if (!cfg->input_pins[preferred])
3141 cfg->input_pins[preferred] = nid;
3142 else if (!cfg->input_pins[alt])
3143 cfg->input_pins[alt] = nid;
3146 case AC_JACK_LINE_IN:
3147 if (loc == AC_JACK_LOC_FRONT)
3148 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3150 cfg->input_pins[AUTO_PIN_LINE] = nid;
3153 cfg->input_pins[AUTO_PIN_CD] = nid;
3156 cfg->input_pins[AUTO_PIN_AUX] = nid;
3158 case AC_JACK_SPDIF_OUT:
3159 cfg->dig_out_pin = nid;
3161 case AC_JACK_SPDIF_IN:
3162 cfg->dig_in_pin = nid;
3168 * If no line-out is defined but multiple HPs are found,
3169 * some of them might be the real line-outs.
3171 if (!cfg->line_outs && cfg->hp_outs > 1) {
3173 while (i < cfg->hp_outs) {
3174 /* The real HPs should have the sequence 0x0f */
3175 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3179 /* Move it to the line-out table */
3180 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3181 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3184 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3185 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3186 memmove(sequences_hp + i - 1, sequences_hp + i,
3187 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3191 /* sort by sequence */
3192 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3194 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3196 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3199 /* if we have only one mic, make it AUTO_PIN_MIC */
3200 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3201 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3202 cfg->input_pins[AUTO_PIN_MIC] =
3203 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3204 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3206 /* ditto for line-in */
3207 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3208 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3209 cfg->input_pins[AUTO_PIN_LINE] =
3210 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3211 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3215 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3216 * as a primary output
3218 if (!cfg->line_outs) {
3219 if (cfg->speaker_outs) {
3220 cfg->line_outs = cfg->speaker_outs;
3221 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3222 sizeof(cfg->speaker_pins));
3223 cfg->speaker_outs = 0;
3224 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3225 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3226 } else if (cfg->hp_outs) {
3227 cfg->line_outs = cfg->hp_outs;
3228 memcpy(cfg->line_out_pins, cfg->hp_pins,
3229 sizeof(cfg->hp_pins));
3231 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3232 cfg->line_out_type = AUTO_PIN_HP_OUT;
3236 /* Reorder the surround channels
3237 * ALSA sequence is front/surr/clfe/side
3239 * 4-ch: front/surr => OK as it is
3240 * 6-ch: front/clfe/surr
3241 * 8-ch: front/clfe/rear/side|fc
3243 switch (cfg->line_outs) {
3246 nid = cfg->line_out_pins[1];
3247 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3248 cfg->line_out_pins[2] = nid;
3253 * debug prints of the parsed results
3255 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3256 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3257 cfg->line_out_pins[2], cfg->line_out_pins[3],
3258 cfg->line_out_pins[4]);
3259 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3260 cfg->speaker_outs, cfg->speaker_pins[0],
3261 cfg->speaker_pins[1], cfg->speaker_pins[2],
3262 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3263 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3264 cfg->hp_outs, cfg->hp_pins[0],
3265 cfg->hp_pins[1], cfg->hp_pins[2],
3266 cfg->hp_pins[3], cfg->hp_pins[4]);
3267 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3268 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3269 " cd=0x%x, aux=0x%x\n",
3270 cfg->input_pins[AUTO_PIN_MIC],
3271 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3272 cfg->input_pins[AUTO_PIN_LINE],
3273 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3274 cfg->input_pins[AUTO_PIN_CD],
3275 cfg->input_pins[AUTO_PIN_AUX]);
3280 /* labels for input pins */
3281 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3282 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3292 * snd_hda_suspend - suspend the codecs
3294 * @state: suspsend state
3296 * Returns 0 if successful.
3298 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3300 struct hda_codec *codec;
3302 list_for_each_entry(codec, &bus->codec_list, list) {
3303 #ifdef CONFIG_SND_HDA_POWER_SAVE
3304 if (!codec->power_on)
3307 hda_call_codec_suspend(codec);
3313 * snd_hda_resume - resume the codecs
3315 * @state: resume state
3317 * Returns 0 if successful.
3319 * This fucntion is defined only when POWER_SAVE isn't set.
3320 * In the power-save mode, the codec is resumed dynamically.
3322 int snd_hda_resume(struct hda_bus *bus)
3324 struct hda_codec *codec;
3326 list_for_each_entry(codec, &bus->codec_list, list) {
3327 if (snd_hda_codec_needs_resume(codec))
3328 hda_call_codec_resume(codec);
3332 #ifdef CONFIG_SND_HDA_POWER_SAVE
3333 int snd_hda_codecs_inuse(struct hda_bus *bus)
3335 struct hda_codec *codec;
3337 list_for_each_entry(codec, &bus->codec_list, list) {
3338 if (snd_hda_codec_needs_resume(codec))
3350 /* get a new element from the given array
3351 * if it exceeds the pre-allocated array size, re-allocate the array
3353 void *snd_array_new(struct snd_array *array)
3355 if (array->used >= array->alloced) {
3356 int num = array->alloced + array->alloc_align;
3357 void *nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3361 memcpy(nlist, array->list,
3362 array->elem_size * array->alloced);
3365 array->list = nlist;
3366 array->alloced = num;
3368 return array->list + (array->used++ * array->elem_size);
3371 /* free the given array elements */
3372 void snd_array_free(struct snd_array *array)