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>
36 * vendor / preset table
39 struct hda_vendor_id {
44 /* codec vendor labels */
45 static struct hda_vendor_id hda_vendor_ids[] = {
47 { 0x1057, "Motorola" },
48 { 0x1095, "Silicon Image" },
49 { 0x10ec, "Realtek" },
53 { 0x11d4, "Analog Devices" },
54 { 0x13f6, "C-Media" },
55 { 0x14f1, "Conexant" },
56 { 0x17e8, "Chrontel" },
58 { 0x1aec, "Wolfson Microelectronics" },
59 { 0x434d, "C-Media" },
60 { 0x8384, "SigmaTel" },
64 static DEFINE_MUTEX(preset_mutex);
65 static LIST_HEAD(hda_preset_tables);
67 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
69 mutex_lock(&preset_mutex);
70 list_add_tail(&preset->list, &hda_preset_tables);
71 mutex_unlock(&preset_mutex);
74 EXPORT_SYMBOL_GPL(snd_hda_add_codec_preset);
76 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
78 mutex_lock(&preset_mutex);
79 list_del(&preset->list);
80 mutex_unlock(&preset_mutex);
83 EXPORT_SYMBOL_GPL(snd_hda_delete_codec_preset);
85 #ifdef CONFIG_SND_HDA_POWER_SAVE
86 static void hda_power_work(struct work_struct *work);
87 static void hda_keep_power_on(struct hda_codec *codec);
89 static inline void hda_keep_power_on(struct hda_codec *codec) {}
92 const char *snd_hda_get_jack_location(u32 cfg)
94 static char *bases[7] = {
95 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
97 static unsigned char specials_idx[] = {
102 static char *specials[] = {
103 "Rear Panel", "Drive Bar",
104 "Riser", "HDMI", "ATAPI",
105 "Mobile-In", "Mobile-Out"
108 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
109 if ((cfg & 0x0f) < 7)
110 return bases[cfg & 0x0f];
111 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
112 if (cfg == specials_idx[i])
117 EXPORT_SYMBOL_GPL(snd_hda_get_jack_location);
119 const char *snd_hda_get_jack_connectivity(u32 cfg)
121 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
123 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
125 EXPORT_SYMBOL_GPL(snd_hda_get_jack_connectivity);
127 const char *snd_hda_get_jack_type(u32 cfg)
129 static char *jack_types[16] = {
130 "Line Out", "Speaker", "HP Out", "CD",
131 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
132 "Line In", "Aux", "Mic", "Telephony",
133 "SPDIF In", "Digitial In", "Reserved", "Other"
136 return jack_types[(cfg & AC_DEFCFG_DEVICE)
137 >> AC_DEFCFG_DEVICE_SHIFT];
139 EXPORT_SYMBOL_GPL(snd_hda_get_jack_type);
142 * Compose a 32bit command word to be sent to the HD-audio controller
144 static inline unsigned int
145 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
146 unsigned int verb, unsigned int parm)
150 val = (u32)(codec->addr & 0x0f) << 28;
151 val |= (u32)direct << 27;
152 val |= (u32)nid << 20;
159 * snd_hda_codec_read - send a command and get the response
160 * @codec: the HDA codec
161 * @nid: NID to send the command
162 * @direct: direct flag
163 * @verb: the verb to send
164 * @parm: the parameter for the verb
166 * Send a single command and read the corresponding response.
168 * Returns the obtained response value, or -1 for an error.
170 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
172 unsigned int verb, unsigned int parm)
174 struct hda_bus *bus = codec->bus;
177 res = make_codec_cmd(codec, nid, direct, verb, parm);
178 snd_hda_power_up(codec);
179 mutex_lock(&bus->cmd_mutex);
180 if (!bus->ops.command(bus, res))
181 res = bus->ops.get_response(bus);
183 res = (unsigned int)-1;
184 mutex_unlock(&bus->cmd_mutex);
185 snd_hda_power_down(codec);
188 EXPORT_SYMBOL_GPL(snd_hda_codec_read);
191 * snd_hda_codec_write - send a single command without waiting for response
192 * @codec: the HDA codec
193 * @nid: NID to send the command
194 * @direct: direct flag
195 * @verb: the verb to send
196 * @parm: the parameter for the verb
198 * Send a single command without waiting for response.
200 * Returns 0 if successful, or a negative error code.
202 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
203 unsigned int verb, unsigned int parm)
205 struct hda_bus *bus = codec->bus;
209 res = make_codec_cmd(codec, nid, direct, verb, parm);
210 snd_hda_power_up(codec);
211 mutex_lock(&bus->cmd_mutex);
212 err = bus->ops.command(bus, res);
213 mutex_unlock(&bus->cmd_mutex);
214 snd_hda_power_down(codec);
217 EXPORT_SYMBOL_GPL(snd_hda_codec_write);
220 * snd_hda_sequence_write - sequence writes
221 * @codec: the HDA codec
222 * @seq: VERB array to send
224 * Send the commands sequentially from the given array.
225 * The array must be terminated with NID=0.
227 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
229 for (; seq->nid; seq++)
230 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
232 EXPORT_SYMBOL_GPL(snd_hda_sequence_write);
235 * snd_hda_get_sub_nodes - get the range of sub nodes
236 * @codec: the HDA codec
238 * @start_id: the pointer to store the start NID
240 * Parse the NID and store the start NID of its sub-nodes.
241 * Returns the number of sub-nodes.
243 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
248 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
251 *start_id = (parm >> 16) & 0x7fff;
252 return (int)(parm & 0x7fff);
254 EXPORT_SYMBOL_GPL(snd_hda_get_sub_nodes);
257 * snd_hda_get_connections - get connection list
258 * @codec: the HDA codec
260 * @conn_list: connection list array
261 * @max_conns: max. number of connections to store
263 * Parses the connection list of the given widget and stores the list
266 * Returns the number of connections, or a negative error code.
268 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
269 hda_nid_t *conn_list, int max_conns)
272 int i, conn_len, conns;
273 unsigned int shift, num_elems, mask;
276 if (snd_BUG_ON(!conn_list || max_conns <= 0))
279 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
280 if (parm & AC_CLIST_LONG) {
289 conn_len = parm & AC_CLIST_LENGTH;
290 mask = (1 << (shift-1)) - 1;
293 return 0; /* no connection */
296 /* single connection */
297 parm = snd_hda_codec_read(codec, nid, 0,
298 AC_VERB_GET_CONNECT_LIST, 0);
299 conn_list[0] = parm & mask;
303 /* multi connection */
306 for (i = 0; i < conn_len; i++) {
310 if (i % num_elems == 0)
311 parm = snd_hda_codec_read(codec, nid, 0,
312 AC_VERB_GET_CONNECT_LIST, i);
313 range_val = !!(parm & (1 << (shift-1))); /* ranges */
317 /* ranges between the previous and this one */
318 if (!prev_nid || prev_nid >= val) {
319 snd_printk(KERN_WARNING "hda_codec: "
320 "invalid dep_range_val %x:%x\n",
324 for (n = prev_nid + 1; n <= val; n++) {
325 if (conns >= max_conns) {
327 "Too many connections\n");
330 conn_list[conns++] = n;
333 if (conns >= max_conns) {
334 snd_printk(KERN_ERR "Too many connections\n");
337 conn_list[conns++] = val;
343 EXPORT_SYMBOL_GPL(snd_hda_get_connections);
347 * snd_hda_queue_unsol_event - add an unsolicited event to queue
349 * @res: unsolicited event (lower 32bit of RIRB entry)
350 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
352 * Adds the given event to the queue. The events are processed in
353 * the workqueue asynchronously. Call this function in the interrupt
354 * hanlder when RIRB receives an unsolicited event.
356 * Returns 0 if successful, or a negative error code.
358 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
360 struct hda_bus_unsolicited *unsol;
367 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
371 unsol->queue[wp] = res;
372 unsol->queue[wp + 1] = res_ex;
374 schedule_work(&unsol->work);
378 EXPORT_SYMBOL_GPL(snd_hda_queue_unsol_event);
381 * process queued unsolicited events
383 static void process_unsol_events(struct work_struct *work)
385 struct hda_bus_unsolicited *unsol =
386 container_of(work, struct hda_bus_unsolicited, work);
387 struct hda_bus *bus = unsol->bus;
388 struct hda_codec *codec;
389 unsigned int rp, caddr, res;
391 while (unsol->rp != unsol->wp) {
392 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
395 res = unsol->queue[rp];
396 caddr = unsol->queue[rp + 1];
397 if (!(caddr & (1 << 4))) /* no unsolicited event? */
399 codec = bus->caddr_tbl[caddr & 0x0f];
400 if (codec && codec->patch_ops.unsol_event)
401 codec->patch_ops.unsol_event(codec, res);
406 * initialize unsolicited queue
408 static int init_unsol_queue(struct hda_bus *bus)
410 struct hda_bus_unsolicited *unsol;
412 if (bus->unsol) /* already initialized */
415 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
417 snd_printk(KERN_ERR "hda_codec: "
418 "can't allocate unsolicited queue\n");
421 INIT_WORK(&unsol->work, process_unsol_events);
430 static void snd_hda_codec_free(struct hda_codec *codec);
432 static int snd_hda_bus_free(struct hda_bus *bus)
434 struct hda_codec *codec, *n;
439 flush_scheduled_work();
442 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
443 snd_hda_codec_free(codec);
445 if (bus->ops.private_free)
446 bus->ops.private_free(bus);
451 static int snd_hda_bus_dev_free(struct snd_device *device)
453 struct hda_bus *bus = device->device_data;
455 return snd_hda_bus_free(bus);
458 #ifdef CONFIG_SND_HDA_HWDEP
459 static int snd_hda_bus_dev_register(struct snd_device *device)
461 struct hda_bus *bus = device->device_data;
462 struct hda_codec *codec;
463 list_for_each_entry(codec, &bus->codec_list, list) {
464 snd_hda_hwdep_add_sysfs(codec);
469 #define snd_hda_bus_dev_register NULL
473 * snd_hda_bus_new - create a HDA bus
474 * @card: the card entry
475 * @temp: the template for hda_bus information
476 * @busp: the pointer to store the created bus instance
478 * Returns 0 if successful, or a negative error code.
480 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
481 const struct hda_bus_template *temp,
482 struct hda_bus **busp)
486 static struct snd_device_ops dev_ops = {
487 .dev_register = snd_hda_bus_dev_register,
488 .dev_free = snd_hda_bus_dev_free,
491 if (snd_BUG_ON(!temp))
493 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
499 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
501 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
506 bus->private_data = temp->private_data;
507 bus->pci = temp->pci;
508 bus->modelname = temp->modelname;
509 bus->power_save = temp->power_save;
510 bus->ops = temp->ops;
512 mutex_init(&bus->cmd_mutex);
513 INIT_LIST_HEAD(&bus->codec_list);
515 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
517 snd_hda_bus_free(bus);
524 EXPORT_SYMBOL_GPL(snd_hda_bus_new);
526 #ifdef CONFIG_SND_HDA_GENERIC
527 #define is_generic_config(codec) \
528 (codec->modelname && !strcmp(codec->modelname, "generic"))
530 #define is_generic_config(codec) 0
533 #ifdef CONFIG_SND_HDA_INTEL_MODULE
534 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
536 #define HDA_MODREQ_MAX_COUNT 0
540 * find a matching codec preset
542 static const struct hda_codec_preset *
543 find_codec_preset(struct hda_codec *codec)
545 struct hda_codec_preset_list *tbl;
546 const struct hda_codec_preset *preset;
547 int mod_requested = 0;
549 if (is_generic_config(codec))
550 return NULL; /* use the generic parser */
553 mutex_lock(&preset_mutex);
554 list_for_each_entry(tbl, &hda_preset_tables, list) {
555 if (!try_module_get(tbl->owner)) {
556 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
559 for (preset = tbl->preset; preset->id; preset++) {
560 u32 mask = preset->mask;
561 if (preset->afg && preset->afg != codec->afg)
563 if (preset->mfg && preset->mfg != codec->mfg)
567 if (preset->id == (codec->vendor_id & mask) &&
569 preset->rev == codec->revision_id)) {
570 mutex_unlock(&preset_mutex);
571 codec->owner = tbl->owner;
575 module_put(tbl->owner);
577 mutex_unlock(&preset_mutex);
579 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
582 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
585 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
586 (codec->vendor_id >> 16) & 0xffff);
587 request_module(name);
595 * get_codec_name - store the codec name
597 static int get_codec_name(struct hda_codec *codec)
599 const struct hda_vendor_id *c;
600 const char *vendor = NULL;
601 u16 vendor_id = codec->vendor_id >> 16;
602 char tmp[16], name[32];
604 for (c = hda_vendor_ids; c->id; c++) {
605 if (c->id == vendor_id) {
611 sprintf(tmp, "Generic %04x", vendor_id);
614 if (codec->preset && codec->preset->name)
615 snprintf(name, sizeof(name), "%s %s", vendor,
616 codec->preset->name);
618 snprintf(name, sizeof(name), "%s ID %x", vendor,
619 codec->vendor_id & 0xffff);
620 codec->name = kstrdup(name, GFP_KERNEL);
627 * look for an AFG and MFG nodes
629 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
634 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
635 for (i = 0; i < total_nodes; i++, nid++) {
637 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
638 switch (func & 0xff) {
639 case AC_GRP_AUDIO_FUNCTION:
642 case AC_GRP_MODEM_FUNCTION:
652 * read widget caps for each widget and store in cache
654 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
659 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
661 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
664 nid = codec->start_nid;
665 for (i = 0; i < codec->num_nodes; i++, nid++)
666 codec->wcaps[i] = snd_hda_param_read(codec, nid,
667 AC_PAR_AUDIO_WIDGET_CAP);
672 static void init_hda_cache(struct hda_cache_rec *cache,
673 unsigned int record_size);
674 static void free_hda_cache(struct hda_cache_rec *cache);
679 static void snd_hda_codec_free(struct hda_codec *codec)
683 #ifdef CONFIG_SND_HDA_POWER_SAVE
684 cancel_delayed_work(&codec->power_work);
685 flush_scheduled_work();
687 list_del(&codec->list);
688 snd_array_free(&codec->mixers);
689 codec->bus->caddr_tbl[codec->addr] = NULL;
690 if (codec->patch_ops.free)
691 codec->patch_ops.free(codec);
692 module_put(codec->owner);
693 free_hda_cache(&codec->amp_cache);
694 free_hda_cache(&codec->cmd_cache);
696 kfree(codec->modelname);
702 * snd_hda_codec_new - create a HDA codec
703 * @bus: the bus to assign
704 * @codec_addr: the codec address
705 * @codecp: the pointer to store the generated codec
707 * Returns 0 if successful, or a negative error code.
709 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
710 struct hda_codec **codecp)
712 struct hda_codec *codec;
716 if (snd_BUG_ON(!bus))
718 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
721 if (bus->caddr_tbl[codec_addr]) {
722 snd_printk(KERN_ERR "hda_codec: "
723 "address 0x%x is already occupied\n", codec_addr);
727 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
729 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
734 codec->addr = codec_addr;
735 mutex_init(&codec->spdif_mutex);
736 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
737 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
738 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
739 if (codec->bus->modelname) {
740 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
741 if (!codec->modelname) {
742 snd_hda_codec_free(codec);
747 #ifdef CONFIG_SND_HDA_POWER_SAVE
748 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
749 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
750 * the caller has to power down appropriatley after initialization
753 hda_keep_power_on(codec);
756 list_add_tail(&codec->list, &bus->codec_list);
757 bus->caddr_tbl[codec_addr] = codec;
759 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
761 if (codec->vendor_id == -1)
762 /* read again, hopefully the access method was corrected
763 * in the last read...
765 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
767 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
768 AC_PAR_SUBSYSTEM_ID);
769 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
772 setup_fg_nodes(codec);
773 if (!codec->afg && !codec->mfg) {
774 snd_printdd("hda_codec: no AFG or MFG node found\n");
775 snd_hda_codec_free(codec);
779 if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) {
780 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
781 snd_hda_codec_free(codec);
785 if (!codec->subsystem_id) {
786 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
787 codec->subsystem_id =
788 snd_hda_codec_read(codec, nid, 0,
789 AC_VERB_GET_SUBSYSTEM_ID, 0);
792 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
794 err = snd_hda_codec_configure(codec);
796 snd_hda_codec_free(codec);
799 snd_hda_codec_proc_new(codec);
801 snd_hda_create_hwdep(codec);
803 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
804 codec->subsystem_id, codec->revision_id);
805 snd_component_add(codec->bus->card, component);
811 EXPORT_SYMBOL_GPL(snd_hda_codec_new);
813 int snd_hda_codec_configure(struct hda_codec *codec)
817 codec->preset = find_codec_preset(codec);
819 err = get_codec_name(codec);
823 /* audio codec should override the mixer name */
824 if (codec->afg || !*codec->bus->card->mixername)
825 strlcpy(codec->bus->card->mixername, codec->name,
826 sizeof(codec->bus->card->mixername));
828 if (is_generic_config(codec)) {
829 err = snd_hda_parse_generic_codec(codec);
832 if (codec->preset && codec->preset->patch) {
833 err = codec->preset->patch(codec);
837 /* call the default parser */
838 err = snd_hda_parse_generic_codec(codec);
840 printk(KERN_ERR "hda-codec: No codec parser is available\n");
843 if (!err && codec->patch_ops.unsol_event)
844 err = init_unsol_queue(codec->bus);
849 * snd_hda_codec_setup_stream - set up the codec for streaming
850 * @codec: the CODEC to set up
851 * @nid: the NID to set up
852 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
853 * @channel_id: channel id to pass, zero based.
854 * @format: stream format.
856 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
858 int channel_id, int format)
863 snd_printdd("hda_codec_setup_stream: "
864 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
865 nid, stream_tag, channel_id, format);
866 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
867 (stream_tag << 4) | channel_id);
869 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
871 EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream);
873 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
878 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
879 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
880 #if 0 /* keep the format */
882 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
885 EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup_stream);
888 * amp access functions
891 /* FIXME: more better hash key? */
892 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
893 #define INFO_AMP_CAPS (1<<0)
894 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
896 /* initialize the hash table */
897 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
898 unsigned int record_size)
900 memset(cache, 0, sizeof(*cache));
901 memset(cache->hash, 0xff, sizeof(cache->hash));
902 snd_array_init(&cache->buf, record_size, 64);
905 static void free_hda_cache(struct hda_cache_rec *cache)
907 snd_array_free(&cache->buf);
910 /* query the hash. allocate an entry if not found. */
911 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
914 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
915 u16 cur = cache->hash[idx];
916 struct hda_cache_head *info;
918 while (cur != 0xffff) {
919 info = snd_array_elem(&cache->buf, cur);
920 if (info->key == key)
925 /* add a new hash entry */
926 info = snd_array_new(&cache->buf);
929 cur = snd_array_index(&cache->buf, info);
932 info->next = cache->hash[idx];
933 cache->hash[idx] = cur;
938 /* query and allocate an amp hash entry */
939 static inline struct hda_amp_info *
940 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
942 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
946 * query AMP capabilities for the given widget and direction
948 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
950 struct hda_amp_info *info;
952 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
955 if (!(info->head.val & INFO_AMP_CAPS)) {
956 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
958 info->amp_caps = snd_hda_param_read(codec, nid,
959 direction == HDA_OUTPUT ?
963 info->head.val |= INFO_AMP_CAPS;
965 return info->amp_caps;
967 EXPORT_SYMBOL_GPL(query_amp_caps);
969 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
972 struct hda_amp_info *info;
974 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
977 info->amp_caps = caps;
978 info->head.val |= INFO_AMP_CAPS;
981 EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
984 * read the current volume to info
985 * if the cache exists, read the cache value.
987 static unsigned int get_vol_mute(struct hda_codec *codec,
988 struct hda_amp_info *info, hda_nid_t nid,
989 int ch, int direction, int index)
993 if (info->head.val & INFO_AMP_VOL(ch))
994 return info->vol[ch];
996 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
997 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
999 val = snd_hda_codec_read(codec, nid, 0,
1000 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1001 info->vol[ch] = val & 0xff;
1002 info->head.val |= INFO_AMP_VOL(ch);
1003 return info->vol[ch];
1007 * write the current volume in info to the h/w and update the cache
1009 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1010 hda_nid_t nid, int ch, int direction, int index,
1015 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1016 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1017 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1019 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1020 info->vol[ch] = val;
1024 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1026 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1027 int direction, int index)
1029 struct hda_amp_info *info;
1030 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1033 return get_vol_mute(codec, info, nid, ch, direction, index);
1035 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_read);
1038 * update the AMP value, mask = bit mask to set, val = the value
1040 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1041 int direction, int idx, int mask, int val)
1043 struct hda_amp_info *info;
1045 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1049 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1050 if (info->vol[ch] == val)
1052 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1055 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update);
1058 * update the AMP stereo with the same mask and value
1060 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1061 int direction, int idx, int mask, int val)
1064 for (ch = 0; ch < 2; ch++)
1065 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1069 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
1071 #ifdef SND_HDA_NEEDS_RESUME
1072 /* resume the all amp commands from the cache */
1073 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1075 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1078 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1079 u32 key = buffer->head.key;
1081 unsigned int idx, dir, ch;
1085 idx = (key >> 16) & 0xff;
1086 dir = (key >> 24) & 0xff;
1087 for (ch = 0; ch < 2; ch++) {
1088 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1090 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1095 EXPORT_SYMBOL_GPL(snd_hda_codec_resume_amp);
1096 #endif /* SND_HDA_NEEDS_RESUME */
1099 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1100 struct snd_ctl_elem_info *uinfo)
1102 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1103 u16 nid = get_amp_nid(kcontrol);
1104 u8 chs = get_amp_channels(kcontrol);
1105 int dir = get_amp_direction(kcontrol);
1108 caps = query_amp_caps(codec, nid, dir);
1110 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1112 printk(KERN_WARNING "hda_codec: "
1113 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1117 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1118 uinfo->count = chs == 3 ? 2 : 1;
1119 uinfo->value.integer.min = 0;
1120 uinfo->value.integer.max = caps;
1123 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
1125 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1126 struct snd_ctl_elem_value *ucontrol)
1128 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1129 hda_nid_t nid = get_amp_nid(kcontrol);
1130 int chs = get_amp_channels(kcontrol);
1131 int dir = get_amp_direction(kcontrol);
1132 int idx = get_amp_index(kcontrol);
1133 long *valp = ucontrol->value.integer.value;
1136 *valp++ = snd_hda_codec_amp_read(codec, nid, 0, dir, idx)
1139 *valp = snd_hda_codec_amp_read(codec, nid, 1, dir, idx)
1143 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
1145 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1146 struct snd_ctl_elem_value *ucontrol)
1148 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1149 hda_nid_t nid = get_amp_nid(kcontrol);
1150 int chs = get_amp_channels(kcontrol);
1151 int dir = get_amp_direction(kcontrol);
1152 int idx = get_amp_index(kcontrol);
1153 long *valp = ucontrol->value.integer.value;
1156 snd_hda_power_up(codec);
1158 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1163 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1165 snd_hda_power_down(codec);
1168 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
1170 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1171 unsigned int size, unsigned int __user *_tlv)
1173 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1174 hda_nid_t nid = get_amp_nid(kcontrol);
1175 int dir = get_amp_direction(kcontrol);
1176 u32 caps, val1, val2;
1178 if (size < 4 * sizeof(unsigned int))
1180 caps = query_amp_caps(codec, nid, dir);
1181 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1182 val2 = (val2 + 1) * 25;
1183 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1184 val1 = ((int)val1) * ((int)val2);
1185 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1187 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1189 if (put_user(val1, _tlv + 2))
1191 if (put_user(val2, _tlv + 3))
1195 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
1198 * set (static) TLV for virtual master volume; recalculated as max 0dB
1200 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1206 caps = query_amp_caps(codec, nid, dir);
1207 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1208 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1209 step = (step + 1) * 25;
1210 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1211 tlv[1] = 2 * sizeof(unsigned int);
1212 tlv[2] = -nums * step;
1215 EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
1217 /* find a mixer control element with the given name */
1218 static struct snd_kcontrol *
1219 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1220 const char *name, int idx)
1222 struct snd_ctl_elem_id id;
1223 memset(&id, 0, sizeof(id));
1224 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1226 strcpy(id.name, name);
1227 return snd_ctl_find_id(codec->bus->card, &id);
1230 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1233 return _snd_hda_find_mixer_ctl(codec, name, 0);
1235 EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
1237 /* Add a control element and assign to the codec */
1238 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1241 struct snd_kcontrol **knewp;
1243 err = snd_ctl_add(codec->bus->card, kctl);
1246 knewp = snd_array_new(&codec->mixers);
1252 EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
1254 #ifdef CONFIG_SND_HDA_RECONFIG
1255 /* Clear all controls assigned to the given codec */
1256 void snd_hda_ctls_clear(struct hda_codec *codec)
1259 struct snd_kcontrol **kctls = codec->mixers.list;
1260 for (i = 0; i < codec->mixers.used; i++)
1261 snd_ctl_remove(codec->bus->card, kctls[i]);
1262 snd_array_free(&codec->mixers);
1265 void snd_hda_codec_reset(struct hda_codec *codec)
1269 #ifdef CONFIG_SND_HDA_POWER_SAVE
1270 cancel_delayed_work(&codec->power_work);
1271 flush_scheduled_work();
1273 snd_hda_ctls_clear(codec);
1275 for (i = 0; i < codec->num_pcms; i++) {
1276 if (codec->pcm_info[i].pcm) {
1277 snd_device_free(codec->bus->card,
1278 codec->pcm_info[i].pcm);
1279 clear_bit(codec->pcm_info[i].device,
1280 codec->bus->pcm_dev_bits);
1283 if (codec->patch_ops.free)
1284 codec->patch_ops.free(codec);
1286 free_hda_cache(&codec->amp_cache);
1287 free_hda_cache(&codec->cmd_cache);
1288 codec->num_pcms = 0;
1289 codec->pcm_info = NULL;
1290 codec->preset = NULL;
1291 module_put(codec->owner);
1292 codec->owner = NULL;
1294 #endif /* CONFIG_SND_HDA_RECONFIG */
1296 /* create a virtual master control and add slaves */
1297 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1298 unsigned int *tlv, const char **slaves)
1300 struct snd_kcontrol *kctl;
1304 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1307 snd_printdd("No slave found for %s\n", name);
1310 kctl = snd_ctl_make_virtual_master(name, tlv);
1313 err = snd_hda_ctl_add(codec, kctl);
1317 for (s = slaves; *s; s++) {
1318 struct snd_kcontrol *sctl;
1320 sctl = snd_hda_find_mixer_ctl(codec, *s);
1322 snd_printdd("Cannot find slave %s, skipped\n", *s);
1325 err = snd_ctl_add_slave(kctl, sctl);
1331 EXPORT_SYMBOL_GPL(snd_hda_add_vmaster);
1334 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1335 struct snd_ctl_elem_info *uinfo)
1337 int chs = get_amp_channels(kcontrol);
1339 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1340 uinfo->count = chs == 3 ? 2 : 1;
1341 uinfo->value.integer.min = 0;
1342 uinfo->value.integer.max = 1;
1345 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
1347 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1348 struct snd_ctl_elem_value *ucontrol)
1350 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1351 hda_nid_t nid = get_amp_nid(kcontrol);
1352 int chs = get_amp_channels(kcontrol);
1353 int dir = get_amp_direction(kcontrol);
1354 int idx = get_amp_index(kcontrol);
1355 long *valp = ucontrol->value.integer.value;
1358 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1359 HDA_AMP_MUTE) ? 0 : 1;
1361 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1362 HDA_AMP_MUTE) ? 0 : 1;
1365 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
1367 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1368 struct snd_ctl_elem_value *ucontrol)
1370 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1371 hda_nid_t nid = get_amp_nid(kcontrol);
1372 int chs = get_amp_channels(kcontrol);
1373 int dir = get_amp_direction(kcontrol);
1374 int idx = get_amp_index(kcontrol);
1375 long *valp = ucontrol->value.integer.value;
1378 snd_hda_power_up(codec);
1380 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1382 *valp ? 0 : HDA_AMP_MUTE);
1386 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1388 *valp ? 0 : HDA_AMP_MUTE);
1389 #ifdef CONFIG_SND_HDA_POWER_SAVE
1390 if (codec->patch_ops.check_power_status)
1391 codec->patch_ops.check_power_status(codec, nid);
1393 snd_hda_power_down(codec);
1396 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
1399 * bound volume controls
1401 * bind multiple volumes (# indices, from 0)
1404 #define AMP_VAL_IDX_SHIFT 19
1405 #define AMP_VAL_IDX_MASK (0x0f<<19)
1407 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1408 struct snd_ctl_elem_value *ucontrol)
1410 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1414 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1415 pval = kcontrol->private_value;
1416 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1417 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1418 kcontrol->private_value = pval;
1419 mutex_unlock(&codec->spdif_mutex);
1422 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_get);
1424 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1425 struct snd_ctl_elem_value *ucontrol)
1427 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1429 int i, indices, err = 0, change = 0;
1431 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1432 pval = kcontrol->private_value;
1433 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1434 for (i = 0; i < indices; i++) {
1435 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1436 (i << AMP_VAL_IDX_SHIFT);
1437 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1442 kcontrol->private_value = pval;
1443 mutex_unlock(&codec->spdif_mutex);
1444 return err < 0 ? err : change;
1446 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_put);
1449 * generic bound volume/swtich controls
1451 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1452 struct snd_ctl_elem_info *uinfo)
1454 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1455 struct hda_bind_ctls *c;
1458 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1459 c = (struct hda_bind_ctls *)kcontrol->private_value;
1460 kcontrol->private_value = *c->values;
1461 err = c->ops->info(kcontrol, uinfo);
1462 kcontrol->private_value = (long)c;
1463 mutex_unlock(&codec->spdif_mutex);
1466 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_info);
1468 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1469 struct snd_ctl_elem_value *ucontrol)
1471 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1472 struct hda_bind_ctls *c;
1475 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1476 c = (struct hda_bind_ctls *)kcontrol->private_value;
1477 kcontrol->private_value = *c->values;
1478 err = c->ops->get(kcontrol, ucontrol);
1479 kcontrol->private_value = (long)c;
1480 mutex_unlock(&codec->spdif_mutex);
1483 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_get);
1485 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1486 struct snd_ctl_elem_value *ucontrol)
1488 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1489 struct hda_bind_ctls *c;
1490 unsigned long *vals;
1491 int err = 0, change = 0;
1493 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1494 c = (struct hda_bind_ctls *)kcontrol->private_value;
1495 for (vals = c->values; *vals; vals++) {
1496 kcontrol->private_value = *vals;
1497 err = c->ops->put(kcontrol, ucontrol);
1502 kcontrol->private_value = (long)c;
1503 mutex_unlock(&codec->spdif_mutex);
1504 return err < 0 ? err : change;
1506 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_put);
1508 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1509 unsigned int size, unsigned int __user *tlv)
1511 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1512 struct hda_bind_ctls *c;
1515 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1516 c = (struct hda_bind_ctls *)kcontrol->private_value;
1517 kcontrol->private_value = *c->values;
1518 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1519 kcontrol->private_value = (long)c;
1520 mutex_unlock(&codec->spdif_mutex);
1523 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_tlv);
1525 struct hda_ctl_ops snd_hda_bind_vol = {
1526 .info = snd_hda_mixer_amp_volume_info,
1527 .get = snd_hda_mixer_amp_volume_get,
1528 .put = snd_hda_mixer_amp_volume_put,
1529 .tlv = snd_hda_mixer_amp_tlv
1531 EXPORT_SYMBOL_GPL(snd_hda_bind_vol);
1533 struct hda_ctl_ops snd_hda_bind_sw = {
1534 .info = snd_hda_mixer_amp_switch_info,
1535 .get = snd_hda_mixer_amp_switch_get,
1536 .put = snd_hda_mixer_amp_switch_put,
1537 .tlv = snd_hda_mixer_amp_tlv
1539 EXPORT_SYMBOL_GPL(snd_hda_bind_sw);
1542 * SPDIF out controls
1545 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1546 struct snd_ctl_elem_info *uinfo)
1548 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1553 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1554 struct snd_ctl_elem_value *ucontrol)
1556 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1557 IEC958_AES0_NONAUDIO |
1558 IEC958_AES0_CON_EMPHASIS_5015 |
1559 IEC958_AES0_CON_NOT_COPYRIGHT;
1560 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1561 IEC958_AES1_CON_ORIGINAL;
1565 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1566 struct snd_ctl_elem_value *ucontrol)
1568 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1569 IEC958_AES0_NONAUDIO |
1570 IEC958_AES0_PRO_EMPHASIS_5015;
1574 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1575 struct snd_ctl_elem_value *ucontrol)
1577 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1579 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1580 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1581 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1582 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1587 /* convert from SPDIF status bits to HDA SPDIF bits
1588 * bit 0 (DigEn) is always set zero (to be filled later)
1590 static unsigned short convert_from_spdif_status(unsigned int sbits)
1592 unsigned short val = 0;
1594 if (sbits & IEC958_AES0_PROFESSIONAL)
1595 val |= AC_DIG1_PROFESSIONAL;
1596 if (sbits & IEC958_AES0_NONAUDIO)
1597 val |= AC_DIG1_NONAUDIO;
1598 if (sbits & IEC958_AES0_PROFESSIONAL) {
1599 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1600 IEC958_AES0_PRO_EMPHASIS_5015)
1601 val |= AC_DIG1_EMPHASIS;
1603 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1604 IEC958_AES0_CON_EMPHASIS_5015)
1605 val |= AC_DIG1_EMPHASIS;
1606 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1607 val |= AC_DIG1_COPYRIGHT;
1608 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1609 val |= AC_DIG1_LEVEL;
1610 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1615 /* convert to SPDIF status bits from HDA SPDIF bits
1617 static unsigned int convert_to_spdif_status(unsigned short val)
1619 unsigned int sbits = 0;
1621 if (val & AC_DIG1_NONAUDIO)
1622 sbits |= IEC958_AES0_NONAUDIO;
1623 if (val & AC_DIG1_PROFESSIONAL)
1624 sbits |= IEC958_AES0_PROFESSIONAL;
1625 if (sbits & IEC958_AES0_PROFESSIONAL) {
1626 if (sbits & AC_DIG1_EMPHASIS)
1627 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1629 if (val & AC_DIG1_EMPHASIS)
1630 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1631 if (!(val & AC_DIG1_COPYRIGHT))
1632 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1633 if (val & AC_DIG1_LEVEL)
1634 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1635 sbits |= val & (0x7f << 8);
1640 /* set digital convert verbs both for the given NID and its slaves */
1641 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1646 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1647 d = codec->slave_dig_outs;
1651 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1654 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1658 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1660 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1663 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1664 struct snd_ctl_elem_value *ucontrol)
1666 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1667 hda_nid_t nid = kcontrol->private_value;
1671 mutex_lock(&codec->spdif_mutex);
1672 codec->spdif_status = ucontrol->value.iec958.status[0] |
1673 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1674 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1675 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1676 val = convert_from_spdif_status(codec->spdif_status);
1677 val |= codec->spdif_ctls & 1;
1678 change = codec->spdif_ctls != val;
1679 codec->spdif_ctls = val;
1682 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1684 mutex_unlock(&codec->spdif_mutex);
1688 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1690 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1691 struct snd_ctl_elem_value *ucontrol)
1693 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1695 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1699 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1700 struct snd_ctl_elem_value *ucontrol)
1702 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1703 hda_nid_t nid = kcontrol->private_value;
1707 mutex_lock(&codec->spdif_mutex);
1708 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1709 if (ucontrol->value.integer.value[0])
1710 val |= AC_DIG1_ENABLE;
1711 change = codec->spdif_ctls != val;
1713 codec->spdif_ctls = val;
1714 set_dig_out_convert(codec, nid, val & 0xff, -1);
1715 /* unmute amp switch (if any) */
1716 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1717 (val & AC_DIG1_ENABLE))
1718 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1721 mutex_unlock(&codec->spdif_mutex);
1725 static struct snd_kcontrol_new dig_mixes[] = {
1727 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1728 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1729 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1730 .info = snd_hda_spdif_mask_info,
1731 .get = snd_hda_spdif_cmask_get,
1734 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1735 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1736 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1737 .info = snd_hda_spdif_mask_info,
1738 .get = snd_hda_spdif_pmask_get,
1741 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1742 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1743 .info = snd_hda_spdif_mask_info,
1744 .get = snd_hda_spdif_default_get,
1745 .put = snd_hda_spdif_default_put,
1748 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1749 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1750 .info = snd_hda_spdif_out_switch_info,
1751 .get = snd_hda_spdif_out_switch_get,
1752 .put = snd_hda_spdif_out_switch_put,
1757 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1760 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1761 * @codec: the HDA codec
1762 * @nid: audio out widget NID
1764 * Creates controls related with the SPDIF output.
1765 * Called from each patch supporting the SPDIF out.
1767 * Returns 0 if successful, or a negative error code.
1769 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1772 struct snd_kcontrol *kctl;
1773 struct snd_kcontrol_new *dig_mix;
1776 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1777 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1781 if (idx >= SPDIF_MAX_IDX) {
1782 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1785 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1786 kctl = snd_ctl_new1(dig_mix, codec);
1789 kctl->id.index = idx;
1790 kctl->private_value = nid;
1791 err = snd_hda_ctl_add(codec, kctl);
1796 snd_hda_codec_read(codec, nid, 0,
1797 AC_VERB_GET_DIGI_CONVERT_1, 0);
1798 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1801 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_out_ctls);
1804 * SPDIF sharing with analog output
1806 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1807 struct snd_ctl_elem_value *ucontrol)
1809 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1810 ucontrol->value.integer.value[0] = mout->share_spdif;
1814 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1815 struct snd_ctl_elem_value *ucontrol)
1817 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1818 mout->share_spdif = !!ucontrol->value.integer.value[0];
1822 static struct snd_kcontrol_new spdif_share_sw = {
1823 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1824 .name = "IEC958 Default PCM Playback Switch",
1825 .info = snd_ctl_boolean_mono_info,
1826 .get = spdif_share_sw_get,
1827 .put = spdif_share_sw_put,
1830 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
1831 struct hda_multi_out *mout)
1833 if (!mout->dig_out_nid)
1835 /* ATTENTION: here mout is passed as private_data, instead of codec */
1836 return snd_hda_ctl_add(codec,
1837 snd_ctl_new1(&spdif_share_sw, mout));
1839 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
1845 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
1847 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
1848 struct snd_ctl_elem_value *ucontrol)
1850 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1852 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
1856 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
1857 struct snd_ctl_elem_value *ucontrol)
1859 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1860 hda_nid_t nid = kcontrol->private_value;
1861 unsigned int val = !!ucontrol->value.integer.value[0];
1864 mutex_lock(&codec->spdif_mutex);
1865 change = codec->spdif_in_enable != val;
1867 codec->spdif_in_enable = val;
1868 snd_hda_codec_write_cache(codec, nid, 0,
1869 AC_VERB_SET_DIGI_CONVERT_1, val);
1871 mutex_unlock(&codec->spdif_mutex);
1875 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
1876 struct snd_ctl_elem_value *ucontrol)
1878 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1879 hda_nid_t nid = kcontrol->private_value;
1883 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1884 sbits = convert_to_spdif_status(val);
1885 ucontrol->value.iec958.status[0] = sbits;
1886 ucontrol->value.iec958.status[1] = sbits >> 8;
1887 ucontrol->value.iec958.status[2] = sbits >> 16;
1888 ucontrol->value.iec958.status[3] = sbits >> 24;
1892 static struct snd_kcontrol_new dig_in_ctls[] = {
1894 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1895 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
1896 .info = snd_hda_spdif_in_switch_info,
1897 .get = snd_hda_spdif_in_switch_get,
1898 .put = snd_hda_spdif_in_switch_put,
1901 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1902 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1903 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1904 .info = snd_hda_spdif_mask_info,
1905 .get = snd_hda_spdif_in_status_get,
1911 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1912 * @codec: the HDA codec
1913 * @nid: audio in widget NID
1915 * Creates controls related with the SPDIF input.
1916 * Called from each patch supporting the SPDIF in.
1918 * Returns 0 if successful, or a negative error code.
1920 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1923 struct snd_kcontrol *kctl;
1924 struct snd_kcontrol_new *dig_mix;
1927 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1928 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
1932 if (idx >= SPDIF_MAX_IDX) {
1933 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
1936 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
1937 kctl = snd_ctl_new1(dig_mix, codec);
1938 kctl->private_value = nid;
1939 err = snd_hda_ctl_add(codec, kctl);
1943 codec->spdif_in_enable =
1944 snd_hda_codec_read(codec, nid, 0,
1945 AC_VERB_GET_DIGI_CONVERT_1, 0) &
1949 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
1951 #ifdef SND_HDA_NEEDS_RESUME
1956 /* build a 32bit cache key with the widget id and the command parameter */
1957 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
1958 #define get_cmd_cache_nid(key) ((key) & 0xff)
1959 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
1962 * snd_hda_codec_write_cache - send a single command with caching
1963 * @codec: the HDA codec
1964 * @nid: NID to send the command
1965 * @direct: direct flag
1966 * @verb: the verb to send
1967 * @parm: the parameter for the verb
1969 * Send a single command without waiting for response.
1971 * Returns 0 if successful, or a negative error code.
1973 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
1974 int direct, unsigned int verb, unsigned int parm)
1976 struct hda_bus *bus = codec->bus;
1980 res = make_codec_cmd(codec, nid, direct, verb, parm);
1981 snd_hda_power_up(codec);
1982 mutex_lock(&bus->cmd_mutex);
1983 err = bus->ops.command(bus, res);
1985 struct hda_cache_head *c;
1986 u32 key = build_cmd_cache_key(nid, verb);
1987 c = get_alloc_hash(&codec->cmd_cache, key);
1991 mutex_unlock(&bus->cmd_mutex);
1992 snd_hda_power_down(codec);
1995 EXPORT_SYMBOL_GPL(snd_hda_codec_write_cache);
1997 /* resume the all commands from the cache */
1998 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2000 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2003 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2004 u32 key = buffer->key;
2007 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2008 get_cmd_cache_cmd(key), buffer->val);
2011 EXPORT_SYMBOL_GPL(snd_hda_codec_resume_cache);
2014 * snd_hda_sequence_write_cache - sequence writes with caching
2015 * @codec: the HDA codec
2016 * @seq: VERB array to send
2018 * Send the commands sequentially from the given array.
2019 * Thte commands are recorded on cache for power-save and resume.
2020 * The array must be terminated with NID=0.
2022 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2023 const struct hda_verb *seq)
2025 for (; seq->nid; seq++)
2026 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2029 EXPORT_SYMBOL_GPL(snd_hda_sequence_write_cache);
2030 #endif /* SND_HDA_NEEDS_RESUME */
2033 * set power state of the codec
2035 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2036 unsigned int power_state)
2041 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2043 msleep(10); /* partial workaround for "azx_get_response timeout" */
2045 nid = codec->start_nid;
2046 for (i = 0; i < codec->num_nodes; i++, nid++) {
2047 unsigned int wcaps = get_wcaps(codec, nid);
2048 if (wcaps & AC_WCAP_POWER) {
2049 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2051 if (wid_type == AC_WID_PIN) {
2052 unsigned int pincap;
2054 * don't power down the widget if it controls
2055 * eapd and EAPD_BTLENABLE is set.
2057 pincap = snd_hda_param_read(codec, nid,
2059 if (pincap & AC_PINCAP_EAPD) {
2060 int eapd = snd_hda_codec_read(codec,
2062 AC_VERB_GET_EAPD_BTLENABLE, 0);
2064 if (power_state == AC_PWRST_D3 && eapd)
2068 snd_hda_codec_write(codec, nid, 0,
2069 AC_VERB_SET_POWER_STATE,
2074 if (power_state == AC_PWRST_D0) {
2075 unsigned long end_time;
2078 /* wait until the codec reachs to D0 */
2079 end_time = jiffies + msecs_to_jiffies(500);
2081 state = snd_hda_codec_read(codec, fg, 0,
2082 AC_VERB_GET_POWER_STATE, 0);
2083 if (state == power_state)
2086 } while (time_after_eq(end_time, jiffies));
2090 #ifdef CONFIG_SND_HDA_HWDEP
2091 /* execute additional init verbs */
2092 static void hda_exec_init_verbs(struct hda_codec *codec)
2094 if (codec->init_verbs.list)
2095 snd_hda_sequence_write(codec, codec->init_verbs.list);
2098 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2101 #ifdef SND_HDA_NEEDS_RESUME
2103 * call suspend and power-down; used both from PM and power-save
2105 static void hda_call_codec_suspend(struct hda_codec *codec)
2107 if (codec->patch_ops.suspend)
2108 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2109 hda_set_power_state(codec,
2110 codec->afg ? codec->afg : codec->mfg,
2112 #ifdef CONFIG_SND_HDA_POWER_SAVE
2113 cancel_delayed_work(&codec->power_work);
2114 codec->power_on = 0;
2115 codec->power_transition = 0;
2120 * kick up codec; used both from PM and power-save
2122 static void hda_call_codec_resume(struct hda_codec *codec)
2124 hda_set_power_state(codec,
2125 codec->afg ? codec->afg : codec->mfg,
2127 hda_exec_init_verbs(codec);
2128 if (codec->patch_ops.resume)
2129 codec->patch_ops.resume(codec);
2131 if (codec->patch_ops.init)
2132 codec->patch_ops.init(codec);
2133 snd_hda_codec_resume_amp(codec);
2134 snd_hda_codec_resume_cache(codec);
2137 #endif /* SND_HDA_NEEDS_RESUME */
2141 * snd_hda_build_controls - build mixer controls
2144 * Creates mixer controls for each codec included in the bus.
2146 * Returns 0 if successful, otherwise a negative error code.
2148 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2150 struct hda_codec *codec;
2152 list_for_each_entry(codec, &bus->codec_list, list) {
2153 int err = snd_hda_codec_build_controls(codec);
2159 EXPORT_SYMBOL_GPL(snd_hda_build_controls);
2161 int snd_hda_codec_build_controls(struct hda_codec *codec)
2164 /* fake as if already powered-on */
2165 hda_keep_power_on(codec);
2167 hda_set_power_state(codec,
2168 codec->afg ? codec->afg : codec->mfg,
2170 hda_exec_init_verbs(codec);
2171 /* continue to initialize... */
2172 if (codec->patch_ops.init)
2173 err = codec->patch_ops.init(codec);
2174 if (!err && codec->patch_ops.build_controls)
2175 err = codec->patch_ops.build_controls(codec);
2176 snd_hda_power_down(codec);
2185 struct hda_rate_tbl {
2187 unsigned int alsa_bits;
2188 unsigned int hda_fmt;
2191 static struct hda_rate_tbl rate_bits[] = {
2192 /* rate in Hz, ALSA rate bitmask, HDA format value */
2194 /* autodetected value used in snd_hda_query_supported_pcm */
2195 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2196 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2197 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2198 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2199 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2200 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2201 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2202 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2203 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2204 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2205 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2206 #define AC_PAR_PCM_RATE_BITS 11
2207 /* up to bits 10, 384kHZ isn't supported properly */
2209 /* not autodetected value */
2210 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2212 { 0 } /* terminator */
2216 * snd_hda_calc_stream_format - calculate format bitset
2217 * @rate: the sample rate
2218 * @channels: the number of channels
2219 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2220 * @maxbps: the max. bps
2222 * Calculate the format bitset from the given rate, channels and th PCM format.
2224 * Return zero if invalid.
2226 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2227 unsigned int channels,
2228 unsigned int format,
2229 unsigned int maxbps)
2232 unsigned int val = 0;
2234 for (i = 0; rate_bits[i].hz; i++)
2235 if (rate_bits[i].hz == rate) {
2236 val = rate_bits[i].hda_fmt;
2239 if (!rate_bits[i].hz) {
2240 snd_printdd("invalid rate %d\n", rate);
2244 if (channels == 0 || channels > 8) {
2245 snd_printdd("invalid channels %d\n", channels);
2248 val |= channels - 1;
2250 switch (snd_pcm_format_width(format)) {
2251 case 8: val |= 0x00; break;
2252 case 16: val |= 0x10; break;
2258 else if (maxbps >= 24)
2264 snd_printdd("invalid format width %d\n",
2265 snd_pcm_format_width(format));
2271 EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format);
2274 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2275 * @codec: the HDA codec
2276 * @nid: NID to query
2277 * @ratesp: the pointer to store the detected rate bitflags
2278 * @formatsp: the pointer to store the detected formats
2279 * @bpsp: the pointer to store the detected format widths
2281 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2282 * or @bsps argument is ignored.
2284 * Returns 0 if successful, otherwise a negative error code.
2286 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2287 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2290 unsigned int val, streams;
2293 if (nid != codec->afg &&
2294 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2295 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2300 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2304 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2306 rates |= rate_bits[i].alsa_bits;
2311 if (formatsp || bpsp) {
2316 wcaps = get_wcaps(codec, nid);
2317 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2321 streams = snd_hda_param_read(codec, codec->afg,
2328 if (streams & AC_SUPFMT_PCM) {
2329 if (val & AC_SUPPCM_BITS_8) {
2330 formats |= SNDRV_PCM_FMTBIT_U8;
2333 if (val & AC_SUPPCM_BITS_16) {
2334 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2337 if (wcaps & AC_WCAP_DIGITAL) {
2338 if (val & AC_SUPPCM_BITS_32)
2339 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2340 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2341 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2342 if (val & AC_SUPPCM_BITS_24)
2344 else if (val & AC_SUPPCM_BITS_20)
2346 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2347 AC_SUPPCM_BITS_32)) {
2348 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2349 if (val & AC_SUPPCM_BITS_32)
2351 else if (val & AC_SUPPCM_BITS_24)
2353 else if (val & AC_SUPPCM_BITS_20)
2357 else if (streams == AC_SUPFMT_FLOAT32) {
2358 /* should be exclusive */
2359 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2361 } else if (streams == AC_SUPFMT_AC3) {
2362 /* should be exclusive */
2363 /* temporary hack: we have still no proper support
2364 * for the direct AC3 stream...
2366 formats |= SNDRV_PCM_FMTBIT_U8;
2370 *formatsp = formats;
2379 * snd_hda_is_supported_format - check whether the given node supports
2382 * Returns 1 if supported, 0 if not.
2384 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2385 unsigned int format)
2388 unsigned int val = 0, rate, stream;
2390 if (nid != codec->afg &&
2391 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2392 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2397 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2402 rate = format & 0xff00;
2403 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2404 if (rate_bits[i].hda_fmt == rate) {
2409 if (i >= AC_PAR_PCM_RATE_BITS)
2412 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2415 if (!stream && nid != codec->afg)
2416 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2417 if (!stream || stream == -1)
2420 if (stream & AC_SUPFMT_PCM) {
2421 switch (format & 0xf0) {
2423 if (!(val & AC_SUPPCM_BITS_8))
2427 if (!(val & AC_SUPPCM_BITS_16))
2431 if (!(val & AC_SUPPCM_BITS_20))
2435 if (!(val & AC_SUPPCM_BITS_24))
2439 if (!(val & AC_SUPPCM_BITS_32))
2446 /* FIXME: check for float32 and AC3? */
2451 EXPORT_SYMBOL_GPL(snd_hda_is_supported_format);
2456 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2457 struct hda_codec *codec,
2458 struct snd_pcm_substream *substream)
2463 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2464 struct hda_codec *codec,
2465 unsigned int stream_tag,
2466 unsigned int format,
2467 struct snd_pcm_substream *substream)
2469 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2473 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2474 struct hda_codec *codec,
2475 struct snd_pcm_substream *substream)
2477 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2481 static int set_pcm_default_values(struct hda_codec *codec,
2482 struct hda_pcm_stream *info)
2484 /* query support PCM information from the given NID */
2485 if (info->nid && (!info->rates || !info->formats)) {
2486 snd_hda_query_supported_pcm(codec, info->nid,
2487 info->rates ? NULL : &info->rates,
2488 info->formats ? NULL : &info->formats,
2489 info->maxbps ? NULL : &info->maxbps);
2491 if (info->ops.open == NULL)
2492 info->ops.open = hda_pcm_default_open_close;
2493 if (info->ops.close == NULL)
2494 info->ops.close = hda_pcm_default_open_close;
2495 if (info->ops.prepare == NULL) {
2496 if (snd_BUG_ON(!info->nid))
2498 info->ops.prepare = hda_pcm_default_prepare;
2500 if (info->ops.cleanup == NULL) {
2501 if (snd_BUG_ON(!info->nid))
2503 info->ops.cleanup = hda_pcm_default_cleanup;
2509 * get the empty PCM device number to assign
2511 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2513 static const char *dev_name[HDA_PCM_NTYPES] = {
2514 "Audio", "SPDIF", "HDMI", "Modem"
2516 /* starting device index for each PCM type */
2517 static int dev_idx[HDA_PCM_NTYPES] = {
2518 [HDA_PCM_TYPE_AUDIO] = 0,
2519 [HDA_PCM_TYPE_SPDIF] = 1,
2520 [HDA_PCM_TYPE_HDMI] = 3,
2521 [HDA_PCM_TYPE_MODEM] = 6
2523 /* normal audio device indices; not linear to keep compatibility */
2524 static int audio_idx[4] = { 0, 2, 4, 5 };
2528 case HDA_PCM_TYPE_AUDIO:
2529 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2531 if (!test_bit(dev, bus->pcm_dev_bits))
2534 if (i >= ARRAY_SIZE(audio_idx)) {
2535 snd_printk(KERN_WARNING "Too many audio devices\n");
2539 case HDA_PCM_TYPE_SPDIF:
2540 case HDA_PCM_TYPE_HDMI:
2541 case HDA_PCM_TYPE_MODEM:
2542 dev = dev_idx[type];
2543 if (test_bit(dev, bus->pcm_dev_bits)) {
2544 snd_printk(KERN_WARNING "%s already defined\n",
2550 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2553 set_bit(dev, bus->pcm_dev_bits);
2558 * attach a new PCM stream
2560 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2562 struct hda_bus *bus = codec->bus;
2563 struct hda_pcm_stream *info;
2566 if (snd_BUG_ON(!pcm->name))
2568 for (stream = 0; stream < 2; stream++) {
2569 info = &pcm->stream[stream];
2570 if (info->substreams) {
2571 err = set_pcm_default_values(codec, info);
2576 return bus->ops.attach_pcm(bus, codec, pcm);
2579 /* assign all PCMs of the given codec */
2580 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2585 if (!codec->num_pcms) {
2586 if (!codec->patch_ops.build_pcms)
2588 err = codec->patch_ops.build_pcms(codec);
2592 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2593 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2596 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2597 return 0; /* no substreams assigned */
2600 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2604 err = snd_hda_attach_pcm(codec, cpcm);
2613 * snd_hda_build_pcms - build PCM information
2616 * Create PCM information for each codec included in the bus.
2618 * The build_pcms codec patch is requested to set up codec->num_pcms and
2619 * codec->pcm_info properly. The array is referred by the top-level driver
2620 * to create its PCM instances.
2621 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2624 * At least, substreams, channels_min and channels_max must be filled for
2625 * each stream. substreams = 0 indicates that the stream doesn't exist.
2626 * When rates and/or formats are zero, the supported values are queried
2627 * from the given nid. The nid is used also by the default ops.prepare
2628 * and ops.cleanup callbacks.
2630 * The driver needs to call ops.open in its open callback. Similarly,
2631 * ops.close is supposed to be called in the close callback.
2632 * ops.prepare should be called in the prepare or hw_params callback
2633 * with the proper parameters for set up.
2634 * ops.cleanup should be called in hw_free for clean up of streams.
2636 * This function returns 0 if successfull, or a negative error code.
2638 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2640 struct hda_codec *codec;
2642 list_for_each_entry(codec, &bus->codec_list, list) {
2643 int err = snd_hda_codec_build_pcms(codec);
2649 EXPORT_SYMBOL_GPL(snd_hda_build_pcms);
2652 * snd_hda_check_board_config - compare the current codec with the config table
2653 * @codec: the HDA codec
2654 * @num_configs: number of config enums
2655 * @models: array of model name strings
2656 * @tbl: configuration table, terminated by null entries
2658 * Compares the modelname or PCI subsystem id of the current codec with the
2659 * given configuration table. If a matching entry is found, returns its
2660 * config value (supposed to be 0 or positive).
2662 * If no entries are matching, the function returns a negative value.
2664 int snd_hda_check_board_config(struct hda_codec *codec,
2665 int num_configs, const char **models,
2666 const struct snd_pci_quirk *tbl)
2668 if (codec->modelname && models) {
2670 for (i = 0; i < num_configs; i++) {
2672 !strcmp(codec->modelname, models[i])) {
2673 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2674 "selected\n", models[i]);
2680 if (!codec->bus->pci || !tbl)
2683 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2686 if (tbl->value >= 0 && tbl->value < num_configs) {
2687 #ifdef CONFIG_SND_DEBUG_VERBOSE
2689 const char *model = NULL;
2691 model = models[tbl->value];
2693 sprintf(tmp, "#%d", tbl->value);
2696 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2697 "for config %x:%x (%s)\n",
2698 model, tbl->subvendor, tbl->subdevice,
2699 (tbl->name ? tbl->name : "Unknown device"));
2705 EXPORT_SYMBOL_GPL(snd_hda_check_board_config);
2708 * snd_hda_add_new_ctls - create controls from the array
2709 * @codec: the HDA codec
2710 * @knew: the array of struct snd_kcontrol_new
2712 * This helper function creates and add new controls in the given array.
2713 * The array must be terminated with an empty entry as terminator.
2715 * Returns 0 if successful, or a negative error code.
2717 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
2721 for (; knew->name; knew++) {
2722 struct snd_kcontrol *kctl;
2723 kctl = snd_ctl_new1(knew, codec);
2726 err = snd_hda_ctl_add(codec, kctl);
2730 kctl = snd_ctl_new1(knew, codec);
2733 kctl->id.device = codec->addr;
2734 err = snd_hda_ctl_add(codec, kctl);
2741 EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
2743 #ifdef CONFIG_SND_HDA_POWER_SAVE
2744 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2745 unsigned int power_state);
2747 static void hda_power_work(struct work_struct *work)
2749 struct hda_codec *codec =
2750 container_of(work, struct hda_codec, power_work.work);
2751 struct hda_bus *bus = codec->bus;
2753 if (!codec->power_on || codec->power_count) {
2754 codec->power_transition = 0;
2758 hda_call_codec_suspend(codec);
2759 if (bus->ops.pm_notify)
2760 bus->ops.pm_notify(bus);
2763 static void hda_keep_power_on(struct hda_codec *codec)
2765 codec->power_count++;
2766 codec->power_on = 1;
2769 void snd_hda_power_up(struct hda_codec *codec)
2771 struct hda_bus *bus = codec->bus;
2773 codec->power_count++;
2774 if (codec->power_on || codec->power_transition)
2777 codec->power_on = 1;
2778 if (bus->ops.pm_notify)
2779 bus->ops.pm_notify(bus);
2780 hda_call_codec_resume(codec);
2781 cancel_delayed_work(&codec->power_work);
2782 codec->power_transition = 0;
2784 EXPORT_SYMBOL_GPL(snd_hda_power_up);
2786 #define power_save(codec) \
2787 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2789 #define power_save(codec) \
2790 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2792 void snd_hda_power_down(struct hda_codec *codec)
2794 --codec->power_count;
2795 if (!codec->power_on || codec->power_count || codec->power_transition)
2797 if (power_save(codec)) {
2798 codec->power_transition = 1; /* avoid reentrance */
2799 schedule_delayed_work(&codec->power_work,
2800 msecs_to_jiffies(power_save(codec) * 1000));
2803 EXPORT_SYMBOL_GPL(snd_hda_power_down);
2805 int snd_hda_check_amp_list_power(struct hda_codec *codec,
2806 struct hda_loopback_check *check,
2809 struct hda_amp_list *p;
2812 if (!check->amplist)
2814 for (p = check->amplist; p->nid; p++) {
2819 return 0; /* nothing changed */
2821 for (p = check->amplist; p->nid; p++) {
2822 for (ch = 0; ch < 2; ch++) {
2823 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
2825 if (!(v & HDA_AMP_MUTE) && v > 0) {
2826 if (!check->power_on) {
2827 check->power_on = 1;
2828 snd_hda_power_up(codec);
2834 if (check->power_on) {
2835 check->power_on = 0;
2836 snd_hda_power_down(codec);
2840 EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
2844 * Channel mode helper
2846 int snd_hda_ch_mode_info(struct hda_codec *codec,
2847 struct snd_ctl_elem_info *uinfo,
2848 const struct hda_channel_mode *chmode,
2851 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2853 uinfo->value.enumerated.items = num_chmodes;
2854 if (uinfo->value.enumerated.item >= num_chmodes)
2855 uinfo->value.enumerated.item = num_chmodes - 1;
2856 sprintf(uinfo->value.enumerated.name, "%dch",
2857 chmode[uinfo->value.enumerated.item].channels);
2860 EXPORT_SYMBOL_GPL(snd_hda_ch_mode_info);
2862 int snd_hda_ch_mode_get(struct hda_codec *codec,
2863 struct snd_ctl_elem_value *ucontrol,
2864 const struct hda_channel_mode *chmode,
2870 for (i = 0; i < num_chmodes; i++) {
2871 if (max_channels == chmode[i].channels) {
2872 ucontrol->value.enumerated.item[0] = i;
2878 EXPORT_SYMBOL_GPL(snd_hda_ch_mode_get);
2880 int snd_hda_ch_mode_put(struct hda_codec *codec,
2881 struct snd_ctl_elem_value *ucontrol,
2882 const struct hda_channel_mode *chmode,
2888 mode = ucontrol->value.enumerated.item[0];
2889 if (mode >= num_chmodes)
2891 if (*max_channelsp == chmode[mode].channels)
2893 /* change the current channel setting */
2894 *max_channelsp = chmode[mode].channels;
2895 if (chmode[mode].sequence)
2896 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
2899 EXPORT_SYMBOL_GPL(snd_hda_ch_mode_put);
2904 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
2905 struct snd_ctl_elem_info *uinfo)
2909 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2911 uinfo->value.enumerated.items = imux->num_items;
2912 if (!imux->num_items)
2914 index = uinfo->value.enumerated.item;
2915 if (index >= imux->num_items)
2916 index = imux->num_items - 1;
2917 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
2920 EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
2922 int snd_hda_input_mux_put(struct hda_codec *codec,
2923 const struct hda_input_mux *imux,
2924 struct snd_ctl_elem_value *ucontrol,
2926 unsigned int *cur_val)
2930 if (!imux->num_items)
2932 idx = ucontrol->value.enumerated.item[0];
2933 if (idx >= imux->num_items)
2934 idx = imux->num_items - 1;
2935 if (*cur_val == idx)
2937 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
2938 imux->items[idx].index);
2942 EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
2946 * Multi-channel / digital-out PCM helper functions
2949 /* setup SPDIF output stream */
2950 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
2951 unsigned int stream_tag, unsigned int format)
2953 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
2954 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2955 set_dig_out_convert(codec, nid,
2956 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
2958 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2959 if (codec->slave_dig_outs) {
2961 for (d = codec->slave_dig_outs; *d; d++)
2962 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
2965 /* turn on again (if needed) */
2966 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2967 set_dig_out_convert(codec, nid,
2968 codec->spdif_ctls & 0xff, -1);
2971 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
2973 snd_hda_codec_cleanup_stream(codec, nid);
2974 if (codec->slave_dig_outs) {
2976 for (d = codec->slave_dig_outs; *d; d++)
2977 snd_hda_codec_cleanup_stream(codec, *d);
2982 * open the digital out in the exclusive mode
2984 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
2985 struct hda_multi_out *mout)
2987 mutex_lock(&codec->spdif_mutex);
2988 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
2989 /* already opened as analog dup; reset it once */
2990 cleanup_dig_out_stream(codec, mout->dig_out_nid);
2991 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
2992 mutex_unlock(&codec->spdif_mutex);
2995 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
2997 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
2998 struct hda_multi_out *mout,
2999 unsigned int stream_tag,
3000 unsigned int format,
3001 struct snd_pcm_substream *substream)
3003 mutex_lock(&codec->spdif_mutex);
3004 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3005 mutex_unlock(&codec->spdif_mutex);
3008 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
3011 * release the digital out
3013 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3014 struct hda_multi_out *mout)
3016 mutex_lock(&codec->spdif_mutex);
3017 mout->dig_out_used = 0;
3018 mutex_unlock(&codec->spdif_mutex);
3021 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
3024 * set up more restrictions for analog out
3026 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3027 struct hda_multi_out *mout,
3028 struct snd_pcm_substream *substream,
3029 struct hda_pcm_stream *hinfo)
3031 struct snd_pcm_runtime *runtime = substream->runtime;
3032 runtime->hw.channels_max = mout->max_channels;
3033 if (mout->dig_out_nid) {
3034 if (!mout->analog_rates) {
3035 mout->analog_rates = hinfo->rates;
3036 mout->analog_formats = hinfo->formats;
3037 mout->analog_maxbps = hinfo->maxbps;
3039 runtime->hw.rates = mout->analog_rates;
3040 runtime->hw.formats = mout->analog_formats;
3041 hinfo->maxbps = mout->analog_maxbps;
3043 if (!mout->spdif_rates) {
3044 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3046 &mout->spdif_formats,
3047 &mout->spdif_maxbps);
3049 mutex_lock(&codec->spdif_mutex);
3050 if (mout->share_spdif) {
3051 runtime->hw.rates &= mout->spdif_rates;
3052 runtime->hw.formats &= mout->spdif_formats;
3053 if (mout->spdif_maxbps < hinfo->maxbps)
3054 hinfo->maxbps = mout->spdif_maxbps;
3056 mutex_unlock(&codec->spdif_mutex);
3058 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3059 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3061 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
3064 * set up the i/o for analog out
3065 * when the digital out is available, copy the front out to digital out, too.
3067 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3068 struct hda_multi_out *mout,
3069 unsigned int stream_tag,
3070 unsigned int format,
3071 struct snd_pcm_substream *substream)
3073 hda_nid_t *nids = mout->dac_nids;
3074 int chs = substream->runtime->channels;
3077 mutex_lock(&codec->spdif_mutex);
3078 if (mout->dig_out_nid && mout->share_spdif &&
3079 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3081 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3083 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3084 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3085 setup_dig_out_stream(codec, mout->dig_out_nid,
3086 stream_tag, format);
3088 mout->dig_out_used = 0;
3089 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3092 mutex_unlock(&codec->spdif_mutex);
3095 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3097 if (!mout->no_share_stream &&
3098 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3099 /* headphone out will just decode front left/right (stereo) */
3100 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3102 /* extra outputs copied from front */
3103 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3104 if (!mout->no_share_stream && mout->extra_out_nid[i])
3105 snd_hda_codec_setup_stream(codec,
3106 mout->extra_out_nid[i],
3107 stream_tag, 0, format);
3110 for (i = 1; i < mout->num_dacs; i++) {
3111 if (chs >= (i + 1) * 2) /* independent out */
3112 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3114 else if (!mout->no_share_stream) /* copy front */
3115 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3120 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
3123 * clean up the setting for analog out
3125 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3126 struct hda_multi_out *mout)
3128 hda_nid_t *nids = mout->dac_nids;
3131 for (i = 0; i < mout->num_dacs; i++)
3132 snd_hda_codec_cleanup_stream(codec, nids[i]);
3134 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3135 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3136 if (mout->extra_out_nid[i])
3137 snd_hda_codec_cleanup_stream(codec,
3138 mout->extra_out_nid[i]);
3139 mutex_lock(&codec->spdif_mutex);
3140 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3141 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3142 mout->dig_out_used = 0;
3144 mutex_unlock(&codec->spdif_mutex);
3147 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
3150 * Helper for automatic pin configuration
3153 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3155 for (; *list; list++)
3163 * Sort an associated group of pins according to their sequence numbers.
3165 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3172 for (i = 0; i < num_pins; i++) {
3173 for (j = i + 1; j < num_pins; j++) {
3174 if (sequences[i] > sequences[j]) {
3176 sequences[i] = sequences[j];
3188 * Parse all pin widgets and store the useful pin nids to cfg
3190 * The number of line-outs or any primary output is stored in line_outs,
3191 * and the corresponding output pins are assigned to line_out_pins[],
3192 * in the order of front, rear, CLFE, side, ...
3194 * If more extra outputs (speaker and headphone) are found, the pins are
3195 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3196 * is detected, one of speaker of HP pins is assigned as the primary
3197 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3198 * if any analog output exists.
3200 * The analog input pins are assigned to input_pins array.
3201 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3204 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3205 struct auto_pin_cfg *cfg,
3206 hda_nid_t *ignore_nids)
3208 hda_nid_t nid, end_nid;
3209 short seq, assoc_line_out, assoc_speaker;
3210 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3211 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3212 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3214 memset(cfg, 0, sizeof(*cfg));
3216 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3217 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3218 memset(sequences_hp, 0, sizeof(sequences_hp));
3219 assoc_line_out = assoc_speaker = 0;
3221 end_nid = codec->start_nid + codec->num_nodes;
3222 for (nid = codec->start_nid; nid < end_nid; nid++) {
3223 unsigned int wid_caps = get_wcaps(codec, nid);
3224 unsigned int wid_type =
3225 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3226 unsigned int def_conf;
3229 /* read all default configuration for pin complex */
3230 if (wid_type != AC_WID_PIN)
3232 /* ignore the given nids (e.g. pc-beep returns error) */
3233 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3236 def_conf = snd_hda_codec_read(codec, nid, 0,
3237 AC_VERB_GET_CONFIG_DEFAULT, 0);
3238 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3240 loc = get_defcfg_location(def_conf);
3241 switch (get_defcfg_device(def_conf)) {
3242 case AC_JACK_LINE_OUT:
3243 seq = get_defcfg_sequence(def_conf);
3244 assoc = get_defcfg_association(def_conf);
3246 if (!(wid_caps & AC_WCAP_STEREO))
3247 if (!cfg->mono_out_pin)
3248 cfg->mono_out_pin = nid;
3251 if (!assoc_line_out)
3252 assoc_line_out = assoc;
3253 else if (assoc_line_out != assoc)
3255 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3257 cfg->line_out_pins[cfg->line_outs] = nid;
3258 sequences_line_out[cfg->line_outs] = seq;
3261 case AC_JACK_SPEAKER:
3262 seq = get_defcfg_sequence(def_conf);
3263 assoc = get_defcfg_association(def_conf);
3266 if (! assoc_speaker)
3267 assoc_speaker = assoc;
3268 else if (assoc_speaker != assoc)
3270 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3272 cfg->speaker_pins[cfg->speaker_outs] = nid;
3273 sequences_speaker[cfg->speaker_outs] = seq;
3274 cfg->speaker_outs++;
3276 case AC_JACK_HP_OUT:
3277 seq = get_defcfg_sequence(def_conf);
3278 assoc = get_defcfg_association(def_conf);
3279 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3281 cfg->hp_pins[cfg->hp_outs] = nid;
3282 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3285 case AC_JACK_MIC_IN: {
3287 if (loc == AC_JACK_LOC_FRONT) {
3288 preferred = AUTO_PIN_FRONT_MIC;
3291 preferred = AUTO_PIN_MIC;
3292 alt = AUTO_PIN_FRONT_MIC;
3294 if (!cfg->input_pins[preferred])
3295 cfg->input_pins[preferred] = nid;
3296 else if (!cfg->input_pins[alt])
3297 cfg->input_pins[alt] = nid;
3300 case AC_JACK_LINE_IN:
3301 if (loc == AC_JACK_LOC_FRONT)
3302 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3304 cfg->input_pins[AUTO_PIN_LINE] = nid;
3307 cfg->input_pins[AUTO_PIN_CD] = nid;
3310 cfg->input_pins[AUTO_PIN_AUX] = nid;
3312 case AC_JACK_SPDIF_OUT:
3313 cfg->dig_out_pin = nid;
3315 case AC_JACK_SPDIF_IN:
3316 cfg->dig_in_pin = nid;
3322 * If no line-out is defined but multiple HPs are found,
3323 * some of them might be the real line-outs.
3325 if (!cfg->line_outs && cfg->hp_outs > 1) {
3327 while (i < cfg->hp_outs) {
3328 /* The real HPs should have the sequence 0x0f */
3329 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3333 /* Move it to the line-out table */
3334 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3335 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3338 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3339 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3340 memmove(sequences_hp + i - 1, sequences_hp + i,
3341 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3345 /* sort by sequence */
3346 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3348 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3350 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3353 /* if we have only one mic, make it AUTO_PIN_MIC */
3354 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3355 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3356 cfg->input_pins[AUTO_PIN_MIC] =
3357 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3358 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3360 /* ditto for line-in */
3361 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3362 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3363 cfg->input_pins[AUTO_PIN_LINE] =
3364 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3365 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3369 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3370 * as a primary output
3372 if (!cfg->line_outs) {
3373 if (cfg->speaker_outs) {
3374 cfg->line_outs = cfg->speaker_outs;
3375 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3376 sizeof(cfg->speaker_pins));
3377 cfg->speaker_outs = 0;
3378 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3379 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3380 } else if (cfg->hp_outs) {
3381 cfg->line_outs = cfg->hp_outs;
3382 memcpy(cfg->line_out_pins, cfg->hp_pins,
3383 sizeof(cfg->hp_pins));
3385 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3386 cfg->line_out_type = AUTO_PIN_HP_OUT;
3390 /* Reorder the surround channels
3391 * ALSA sequence is front/surr/clfe/side
3393 * 4-ch: front/surr => OK as it is
3394 * 6-ch: front/clfe/surr
3395 * 8-ch: front/clfe/rear/side|fc
3397 switch (cfg->line_outs) {
3400 nid = cfg->line_out_pins[1];
3401 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3402 cfg->line_out_pins[2] = nid;
3407 * debug prints of the parsed results
3409 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3410 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3411 cfg->line_out_pins[2], cfg->line_out_pins[3],
3412 cfg->line_out_pins[4]);
3413 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3414 cfg->speaker_outs, cfg->speaker_pins[0],
3415 cfg->speaker_pins[1], cfg->speaker_pins[2],
3416 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3417 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3418 cfg->hp_outs, cfg->hp_pins[0],
3419 cfg->hp_pins[1], cfg->hp_pins[2],
3420 cfg->hp_pins[3], cfg->hp_pins[4]);
3421 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3422 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3423 " cd=0x%x, aux=0x%x\n",
3424 cfg->input_pins[AUTO_PIN_MIC],
3425 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3426 cfg->input_pins[AUTO_PIN_LINE],
3427 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3428 cfg->input_pins[AUTO_PIN_CD],
3429 cfg->input_pins[AUTO_PIN_AUX]);
3433 EXPORT_SYMBOL_GPL(snd_hda_parse_pin_def_config);
3435 /* labels for input pins */
3436 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3437 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3439 EXPORT_SYMBOL_GPL(auto_pin_cfg_labels);
3448 * snd_hda_suspend - suspend the codecs
3450 * @state: suspsend state
3452 * Returns 0 if successful.
3454 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3456 struct hda_codec *codec;
3458 list_for_each_entry(codec, &bus->codec_list, list) {
3459 #ifdef CONFIG_SND_HDA_POWER_SAVE
3460 if (!codec->power_on)
3463 hda_call_codec_suspend(codec);
3467 EXPORT_SYMBOL_GPL(snd_hda_suspend);
3470 * snd_hda_resume - resume the codecs
3473 * Returns 0 if successful.
3475 * This fucntion is defined only when POWER_SAVE isn't set.
3476 * In the power-save mode, the codec is resumed dynamically.
3478 int snd_hda_resume(struct hda_bus *bus)
3480 struct hda_codec *codec;
3482 list_for_each_entry(codec, &bus->codec_list, list) {
3483 if (snd_hda_codec_needs_resume(codec))
3484 hda_call_codec_resume(codec);
3488 EXPORT_SYMBOL_GPL(snd_hda_resume);
3489 #endif /* CONFIG_PM */
3495 /* get a new element from the given array
3496 * if it exceeds the pre-allocated array size, re-allocate the array
3498 void *snd_array_new(struct snd_array *array)
3500 if (array->used >= array->alloced) {
3501 int num = array->alloced + array->alloc_align;
3503 if (snd_BUG_ON(num >= 4096))
3505 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3509 memcpy(nlist, array->list,
3510 array->elem_size * array->alloced);
3513 array->list = nlist;
3514 array->alloced = num;
3516 return snd_array_elem(array, array->used++);
3518 EXPORT_SYMBOL_GPL(snd_array_new);
3520 /* free the given array elements */
3521 void snd_array_free(struct snd_array *array)
3528 EXPORT_SYMBOL_GPL(snd_array_free);
3531 * used by hda_proc.c and hda_eld.c
3533 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3535 static unsigned int rates[] = {
3536 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3537 96000, 176400, 192000, 384000
3541 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3543 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3545 buf[j] = '\0'; /* necessary when j == 0 */
3547 EXPORT_SYMBOL_GPL(snd_print_pcm_rates);
3549 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3551 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3554 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3555 if (pcm & (AC_SUPPCM_BITS_8 << i))
3556 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3558 buf[j] = '\0'; /* necessary when j == 0 */
3560 EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
3562 MODULE_DESCRIPTION("HDA codec core");
3563 MODULE_LICENSE("GPL");