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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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
534 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
536 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(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);
1285 codec->proc_widget_hook = NULL;
1287 free_hda_cache(&codec->amp_cache);
1288 free_hda_cache(&codec->cmd_cache);
1289 codec->num_pcms = 0;
1290 codec->pcm_info = NULL;
1291 codec->preset = NULL;
1292 module_put(codec->owner);
1293 codec->owner = NULL;
1295 #endif /* CONFIG_SND_HDA_RECONFIG */
1297 /* create a virtual master control and add slaves */
1298 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1299 unsigned int *tlv, const char **slaves)
1301 struct snd_kcontrol *kctl;
1305 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1308 snd_printdd("No slave found for %s\n", name);
1311 kctl = snd_ctl_make_virtual_master(name, tlv);
1314 err = snd_hda_ctl_add(codec, kctl);
1318 for (s = slaves; *s; s++) {
1319 struct snd_kcontrol *sctl;
1321 sctl = snd_hda_find_mixer_ctl(codec, *s);
1323 snd_printdd("Cannot find slave %s, skipped\n", *s);
1326 err = snd_ctl_add_slave(kctl, sctl);
1332 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1335 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1336 struct snd_ctl_elem_info *uinfo)
1338 int chs = get_amp_channels(kcontrol);
1340 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1341 uinfo->count = chs == 3 ? 2 : 1;
1342 uinfo->value.integer.min = 0;
1343 uinfo->value.integer.max = 1;
1346 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1348 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1349 struct snd_ctl_elem_value *ucontrol)
1351 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1352 hda_nid_t nid = get_amp_nid(kcontrol);
1353 int chs = get_amp_channels(kcontrol);
1354 int dir = get_amp_direction(kcontrol);
1355 int idx = get_amp_index(kcontrol);
1356 long *valp = ucontrol->value.integer.value;
1359 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1360 HDA_AMP_MUTE) ? 0 : 1;
1362 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1363 HDA_AMP_MUTE) ? 0 : 1;
1366 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1368 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1369 struct snd_ctl_elem_value *ucontrol)
1371 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1372 hda_nid_t nid = get_amp_nid(kcontrol);
1373 int chs = get_amp_channels(kcontrol);
1374 int dir = get_amp_direction(kcontrol);
1375 int idx = get_amp_index(kcontrol);
1376 long *valp = ucontrol->value.integer.value;
1379 snd_hda_power_up(codec);
1381 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1383 *valp ? 0 : HDA_AMP_MUTE);
1387 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1389 *valp ? 0 : HDA_AMP_MUTE);
1390 #ifdef CONFIG_SND_HDA_POWER_SAVE
1391 if (codec->patch_ops.check_power_status)
1392 codec->patch_ops.check_power_status(codec, nid);
1394 snd_hda_power_down(codec);
1397 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1400 * bound volume controls
1402 * bind multiple volumes (# indices, from 0)
1405 #define AMP_VAL_IDX_SHIFT 19
1406 #define AMP_VAL_IDX_MASK (0x0f<<19)
1408 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1409 struct snd_ctl_elem_value *ucontrol)
1411 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1415 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1416 pval = kcontrol->private_value;
1417 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1418 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1419 kcontrol->private_value = pval;
1420 mutex_unlock(&codec->spdif_mutex);
1423 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1425 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1426 struct snd_ctl_elem_value *ucontrol)
1428 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1430 int i, indices, err = 0, change = 0;
1432 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1433 pval = kcontrol->private_value;
1434 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1435 for (i = 0; i < indices; i++) {
1436 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1437 (i << AMP_VAL_IDX_SHIFT);
1438 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1443 kcontrol->private_value = pval;
1444 mutex_unlock(&codec->spdif_mutex);
1445 return err < 0 ? err : change;
1447 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1450 * generic bound volume/swtich controls
1452 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1453 struct snd_ctl_elem_info *uinfo)
1455 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1456 struct hda_bind_ctls *c;
1459 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1460 c = (struct hda_bind_ctls *)kcontrol->private_value;
1461 kcontrol->private_value = *c->values;
1462 err = c->ops->info(kcontrol, uinfo);
1463 kcontrol->private_value = (long)c;
1464 mutex_unlock(&codec->spdif_mutex);
1467 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1469 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1470 struct snd_ctl_elem_value *ucontrol)
1472 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1473 struct hda_bind_ctls *c;
1476 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1477 c = (struct hda_bind_ctls *)kcontrol->private_value;
1478 kcontrol->private_value = *c->values;
1479 err = c->ops->get(kcontrol, ucontrol);
1480 kcontrol->private_value = (long)c;
1481 mutex_unlock(&codec->spdif_mutex);
1484 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1486 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1487 struct snd_ctl_elem_value *ucontrol)
1489 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1490 struct hda_bind_ctls *c;
1491 unsigned long *vals;
1492 int err = 0, change = 0;
1494 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1495 c = (struct hda_bind_ctls *)kcontrol->private_value;
1496 for (vals = c->values; *vals; vals++) {
1497 kcontrol->private_value = *vals;
1498 err = c->ops->put(kcontrol, ucontrol);
1503 kcontrol->private_value = (long)c;
1504 mutex_unlock(&codec->spdif_mutex);
1505 return err < 0 ? err : change;
1507 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1509 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1510 unsigned int size, unsigned int __user *tlv)
1512 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1513 struct hda_bind_ctls *c;
1516 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1517 c = (struct hda_bind_ctls *)kcontrol->private_value;
1518 kcontrol->private_value = *c->values;
1519 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1520 kcontrol->private_value = (long)c;
1521 mutex_unlock(&codec->spdif_mutex);
1524 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1526 struct hda_ctl_ops snd_hda_bind_vol = {
1527 .info = snd_hda_mixer_amp_volume_info,
1528 .get = snd_hda_mixer_amp_volume_get,
1529 .put = snd_hda_mixer_amp_volume_put,
1530 .tlv = snd_hda_mixer_amp_tlv
1532 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1534 struct hda_ctl_ops snd_hda_bind_sw = {
1535 .info = snd_hda_mixer_amp_switch_info,
1536 .get = snd_hda_mixer_amp_switch_get,
1537 .put = snd_hda_mixer_amp_switch_put,
1538 .tlv = snd_hda_mixer_amp_tlv
1540 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1543 * SPDIF out controls
1546 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1547 struct snd_ctl_elem_info *uinfo)
1549 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1554 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1555 struct snd_ctl_elem_value *ucontrol)
1557 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1558 IEC958_AES0_NONAUDIO |
1559 IEC958_AES0_CON_EMPHASIS_5015 |
1560 IEC958_AES0_CON_NOT_COPYRIGHT;
1561 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1562 IEC958_AES1_CON_ORIGINAL;
1566 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1567 struct snd_ctl_elem_value *ucontrol)
1569 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1570 IEC958_AES0_NONAUDIO |
1571 IEC958_AES0_PRO_EMPHASIS_5015;
1575 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1576 struct snd_ctl_elem_value *ucontrol)
1578 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1580 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1581 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1582 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1583 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1588 /* convert from SPDIF status bits to HDA SPDIF bits
1589 * bit 0 (DigEn) is always set zero (to be filled later)
1591 static unsigned short convert_from_spdif_status(unsigned int sbits)
1593 unsigned short val = 0;
1595 if (sbits & IEC958_AES0_PROFESSIONAL)
1596 val |= AC_DIG1_PROFESSIONAL;
1597 if (sbits & IEC958_AES0_NONAUDIO)
1598 val |= AC_DIG1_NONAUDIO;
1599 if (sbits & IEC958_AES0_PROFESSIONAL) {
1600 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1601 IEC958_AES0_PRO_EMPHASIS_5015)
1602 val |= AC_DIG1_EMPHASIS;
1604 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1605 IEC958_AES0_CON_EMPHASIS_5015)
1606 val |= AC_DIG1_EMPHASIS;
1607 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1608 val |= AC_DIG1_COPYRIGHT;
1609 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1610 val |= AC_DIG1_LEVEL;
1611 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1616 /* convert to SPDIF status bits from HDA SPDIF bits
1618 static unsigned int convert_to_spdif_status(unsigned short val)
1620 unsigned int sbits = 0;
1622 if (val & AC_DIG1_NONAUDIO)
1623 sbits |= IEC958_AES0_NONAUDIO;
1624 if (val & AC_DIG1_PROFESSIONAL)
1625 sbits |= IEC958_AES0_PROFESSIONAL;
1626 if (sbits & IEC958_AES0_PROFESSIONAL) {
1627 if (sbits & AC_DIG1_EMPHASIS)
1628 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1630 if (val & AC_DIG1_EMPHASIS)
1631 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1632 if (!(val & AC_DIG1_COPYRIGHT))
1633 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1634 if (val & AC_DIG1_LEVEL)
1635 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1636 sbits |= val & (0x7f << 8);
1641 /* set digital convert verbs both for the given NID and its slaves */
1642 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1647 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1648 d = codec->slave_dig_outs;
1652 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1655 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1659 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1661 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1664 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1665 struct snd_ctl_elem_value *ucontrol)
1667 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1668 hda_nid_t nid = kcontrol->private_value;
1672 mutex_lock(&codec->spdif_mutex);
1673 codec->spdif_status = ucontrol->value.iec958.status[0] |
1674 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1675 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1676 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1677 val = convert_from_spdif_status(codec->spdif_status);
1678 val |= codec->spdif_ctls & 1;
1679 change = codec->spdif_ctls != val;
1680 codec->spdif_ctls = val;
1683 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1685 mutex_unlock(&codec->spdif_mutex);
1689 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1691 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1692 struct snd_ctl_elem_value *ucontrol)
1694 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1696 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1700 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1701 struct snd_ctl_elem_value *ucontrol)
1703 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1704 hda_nid_t nid = kcontrol->private_value;
1708 mutex_lock(&codec->spdif_mutex);
1709 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1710 if (ucontrol->value.integer.value[0])
1711 val |= AC_DIG1_ENABLE;
1712 change = codec->spdif_ctls != val;
1714 codec->spdif_ctls = val;
1715 set_dig_out_convert(codec, nid, val & 0xff, -1);
1716 /* unmute amp switch (if any) */
1717 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1718 (val & AC_DIG1_ENABLE))
1719 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1722 mutex_unlock(&codec->spdif_mutex);
1726 static struct snd_kcontrol_new dig_mixes[] = {
1728 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1729 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1730 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1731 .info = snd_hda_spdif_mask_info,
1732 .get = snd_hda_spdif_cmask_get,
1735 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1736 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1737 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1738 .info = snd_hda_spdif_mask_info,
1739 .get = snd_hda_spdif_pmask_get,
1742 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1743 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1744 .info = snd_hda_spdif_mask_info,
1745 .get = snd_hda_spdif_default_get,
1746 .put = snd_hda_spdif_default_put,
1749 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1750 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1751 .info = snd_hda_spdif_out_switch_info,
1752 .get = snd_hda_spdif_out_switch_get,
1753 .put = snd_hda_spdif_out_switch_put,
1758 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1761 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1762 * @codec: the HDA codec
1763 * @nid: audio out widget NID
1765 * Creates controls related with the SPDIF output.
1766 * Called from each patch supporting the SPDIF out.
1768 * Returns 0 if successful, or a negative error code.
1770 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1773 struct snd_kcontrol *kctl;
1774 struct snd_kcontrol_new *dig_mix;
1777 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1778 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1782 if (idx >= SPDIF_MAX_IDX) {
1783 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1786 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1787 kctl = snd_ctl_new1(dig_mix, codec);
1790 kctl->id.index = idx;
1791 kctl->private_value = nid;
1792 err = snd_hda_ctl_add(codec, kctl);
1797 snd_hda_codec_read(codec, nid, 0,
1798 AC_VERB_GET_DIGI_CONVERT_1, 0);
1799 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1802 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1805 * SPDIF sharing with analog output
1807 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1808 struct snd_ctl_elem_value *ucontrol)
1810 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1811 ucontrol->value.integer.value[0] = mout->share_spdif;
1815 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1816 struct snd_ctl_elem_value *ucontrol)
1818 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1819 mout->share_spdif = !!ucontrol->value.integer.value[0];
1823 static struct snd_kcontrol_new spdif_share_sw = {
1824 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1825 .name = "IEC958 Default PCM Playback Switch",
1826 .info = snd_ctl_boolean_mono_info,
1827 .get = spdif_share_sw_get,
1828 .put = spdif_share_sw_put,
1831 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
1832 struct hda_multi_out *mout)
1834 if (!mout->dig_out_nid)
1836 /* ATTENTION: here mout is passed as private_data, instead of codec */
1837 return snd_hda_ctl_add(codec,
1838 snd_ctl_new1(&spdif_share_sw, mout));
1840 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
1846 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
1848 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
1849 struct snd_ctl_elem_value *ucontrol)
1851 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1853 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
1857 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
1858 struct snd_ctl_elem_value *ucontrol)
1860 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1861 hda_nid_t nid = kcontrol->private_value;
1862 unsigned int val = !!ucontrol->value.integer.value[0];
1865 mutex_lock(&codec->spdif_mutex);
1866 change = codec->spdif_in_enable != val;
1868 codec->spdif_in_enable = val;
1869 snd_hda_codec_write_cache(codec, nid, 0,
1870 AC_VERB_SET_DIGI_CONVERT_1, val);
1872 mutex_unlock(&codec->spdif_mutex);
1876 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
1877 struct snd_ctl_elem_value *ucontrol)
1879 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1880 hda_nid_t nid = kcontrol->private_value;
1884 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1885 sbits = convert_to_spdif_status(val);
1886 ucontrol->value.iec958.status[0] = sbits;
1887 ucontrol->value.iec958.status[1] = sbits >> 8;
1888 ucontrol->value.iec958.status[2] = sbits >> 16;
1889 ucontrol->value.iec958.status[3] = sbits >> 24;
1893 static struct snd_kcontrol_new dig_in_ctls[] = {
1895 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1896 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
1897 .info = snd_hda_spdif_in_switch_info,
1898 .get = snd_hda_spdif_in_switch_get,
1899 .put = snd_hda_spdif_in_switch_put,
1902 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1903 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1904 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1905 .info = snd_hda_spdif_mask_info,
1906 .get = snd_hda_spdif_in_status_get,
1912 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1913 * @codec: the HDA codec
1914 * @nid: audio in widget NID
1916 * Creates controls related with the SPDIF input.
1917 * Called from each patch supporting the SPDIF in.
1919 * Returns 0 if successful, or a negative error code.
1921 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1924 struct snd_kcontrol *kctl;
1925 struct snd_kcontrol_new *dig_mix;
1928 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1929 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
1933 if (idx >= SPDIF_MAX_IDX) {
1934 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
1937 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
1938 kctl = snd_ctl_new1(dig_mix, codec);
1939 kctl->private_value = nid;
1940 err = snd_hda_ctl_add(codec, kctl);
1944 codec->spdif_in_enable =
1945 snd_hda_codec_read(codec, nid, 0,
1946 AC_VERB_GET_DIGI_CONVERT_1, 0) &
1950 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
1952 #ifdef SND_HDA_NEEDS_RESUME
1957 /* build a 32bit cache key with the widget id and the command parameter */
1958 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
1959 #define get_cmd_cache_nid(key) ((key) & 0xff)
1960 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
1963 * snd_hda_codec_write_cache - send a single command with caching
1964 * @codec: the HDA codec
1965 * @nid: NID to send the command
1966 * @direct: direct flag
1967 * @verb: the verb to send
1968 * @parm: the parameter for the verb
1970 * Send a single command without waiting for response.
1972 * Returns 0 if successful, or a negative error code.
1974 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
1975 int direct, unsigned int verb, unsigned int parm)
1977 struct hda_bus *bus = codec->bus;
1981 res = make_codec_cmd(codec, nid, direct, verb, parm);
1982 snd_hda_power_up(codec);
1983 mutex_lock(&bus->cmd_mutex);
1984 err = bus->ops.command(bus, res);
1986 struct hda_cache_head *c;
1987 u32 key = build_cmd_cache_key(nid, verb);
1988 c = get_alloc_hash(&codec->cmd_cache, key);
1992 mutex_unlock(&bus->cmd_mutex);
1993 snd_hda_power_down(codec);
1996 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
1998 /* resume the all commands from the cache */
1999 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2001 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2004 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2005 u32 key = buffer->key;
2008 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2009 get_cmd_cache_cmd(key), buffer->val);
2012 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2015 * snd_hda_sequence_write_cache - sequence writes with caching
2016 * @codec: the HDA codec
2017 * @seq: VERB array to send
2019 * Send the commands sequentially from the given array.
2020 * Thte commands are recorded on cache for power-save and resume.
2021 * The array must be terminated with NID=0.
2023 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2024 const struct hda_verb *seq)
2026 for (; seq->nid; seq++)
2027 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2030 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2031 #endif /* SND_HDA_NEEDS_RESUME */
2034 * set power state of the codec
2036 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2037 unsigned int power_state)
2042 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2044 msleep(10); /* partial workaround for "azx_get_response timeout" */
2046 nid = codec->start_nid;
2047 for (i = 0; i < codec->num_nodes; i++, nid++) {
2048 unsigned int wcaps = get_wcaps(codec, nid);
2049 if (wcaps & AC_WCAP_POWER) {
2050 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2052 if (wid_type == AC_WID_PIN) {
2053 unsigned int pincap;
2055 * don't power down the widget if it controls
2056 * eapd and EAPD_BTLENABLE is set.
2058 pincap = snd_hda_param_read(codec, nid,
2060 if (pincap & AC_PINCAP_EAPD) {
2061 int eapd = snd_hda_codec_read(codec,
2063 AC_VERB_GET_EAPD_BTLENABLE, 0);
2065 if (power_state == AC_PWRST_D3 && eapd)
2069 snd_hda_codec_write(codec, nid, 0,
2070 AC_VERB_SET_POWER_STATE,
2075 if (power_state == AC_PWRST_D0) {
2076 unsigned long end_time;
2079 /* wait until the codec reachs to D0 */
2080 end_time = jiffies + msecs_to_jiffies(500);
2082 state = snd_hda_codec_read(codec, fg, 0,
2083 AC_VERB_GET_POWER_STATE, 0);
2084 if (state == power_state)
2087 } while (time_after_eq(end_time, jiffies));
2091 #ifdef CONFIG_SND_HDA_HWDEP
2092 /* execute additional init verbs */
2093 static void hda_exec_init_verbs(struct hda_codec *codec)
2095 if (codec->init_verbs.list)
2096 snd_hda_sequence_write(codec, codec->init_verbs.list);
2099 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2102 #ifdef SND_HDA_NEEDS_RESUME
2104 * call suspend and power-down; used both from PM and power-save
2106 static void hda_call_codec_suspend(struct hda_codec *codec)
2108 if (codec->patch_ops.suspend)
2109 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2110 hda_set_power_state(codec,
2111 codec->afg ? codec->afg : codec->mfg,
2113 #ifdef CONFIG_SND_HDA_POWER_SAVE
2114 cancel_delayed_work(&codec->power_work);
2115 codec->power_on = 0;
2116 codec->power_transition = 0;
2121 * kick up codec; used both from PM and power-save
2123 static void hda_call_codec_resume(struct hda_codec *codec)
2125 hda_set_power_state(codec,
2126 codec->afg ? codec->afg : codec->mfg,
2128 hda_exec_init_verbs(codec);
2129 if (codec->patch_ops.resume)
2130 codec->patch_ops.resume(codec);
2132 if (codec->patch_ops.init)
2133 codec->patch_ops.init(codec);
2134 snd_hda_codec_resume_amp(codec);
2135 snd_hda_codec_resume_cache(codec);
2138 #endif /* SND_HDA_NEEDS_RESUME */
2142 * snd_hda_build_controls - build mixer controls
2145 * Creates mixer controls for each codec included in the bus.
2147 * Returns 0 if successful, otherwise a negative error code.
2149 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2151 struct hda_codec *codec;
2153 list_for_each_entry(codec, &bus->codec_list, list) {
2154 int err = snd_hda_codec_build_controls(codec);
2160 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2162 int snd_hda_codec_build_controls(struct hda_codec *codec)
2165 /* fake as if already powered-on */
2166 hda_keep_power_on(codec);
2168 hda_set_power_state(codec,
2169 codec->afg ? codec->afg : codec->mfg,
2171 hda_exec_init_verbs(codec);
2172 /* continue to initialize... */
2173 if (codec->patch_ops.init)
2174 err = codec->patch_ops.init(codec);
2175 if (!err && codec->patch_ops.build_controls)
2176 err = codec->patch_ops.build_controls(codec);
2177 snd_hda_power_down(codec);
2186 struct hda_rate_tbl {
2188 unsigned int alsa_bits;
2189 unsigned int hda_fmt;
2192 static struct hda_rate_tbl rate_bits[] = {
2193 /* rate in Hz, ALSA rate bitmask, HDA format value */
2195 /* autodetected value used in snd_hda_query_supported_pcm */
2196 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2197 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2198 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2199 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2200 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2201 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2202 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2203 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2204 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2205 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2206 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2207 #define AC_PAR_PCM_RATE_BITS 11
2208 /* up to bits 10, 384kHZ isn't supported properly */
2210 /* not autodetected value */
2211 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2213 { 0 } /* terminator */
2217 * snd_hda_calc_stream_format - calculate format bitset
2218 * @rate: the sample rate
2219 * @channels: the number of channels
2220 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2221 * @maxbps: the max. bps
2223 * Calculate the format bitset from the given rate, channels and th PCM format.
2225 * Return zero if invalid.
2227 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2228 unsigned int channels,
2229 unsigned int format,
2230 unsigned int maxbps)
2233 unsigned int val = 0;
2235 for (i = 0; rate_bits[i].hz; i++)
2236 if (rate_bits[i].hz == rate) {
2237 val = rate_bits[i].hda_fmt;
2240 if (!rate_bits[i].hz) {
2241 snd_printdd("invalid rate %d\n", rate);
2245 if (channels == 0 || channels > 8) {
2246 snd_printdd("invalid channels %d\n", channels);
2249 val |= channels - 1;
2251 switch (snd_pcm_format_width(format)) {
2252 case 8: val |= 0x00; break;
2253 case 16: val |= 0x10; break;
2259 else if (maxbps >= 24)
2265 snd_printdd("invalid format width %d\n",
2266 snd_pcm_format_width(format));
2272 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2275 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2276 * @codec: the HDA codec
2277 * @nid: NID to query
2278 * @ratesp: the pointer to store the detected rate bitflags
2279 * @formatsp: the pointer to store the detected formats
2280 * @bpsp: the pointer to store the detected format widths
2282 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2283 * or @bsps argument is ignored.
2285 * Returns 0 if successful, otherwise a negative error code.
2287 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2288 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2291 unsigned int val, streams;
2294 if (nid != codec->afg &&
2295 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2296 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2301 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2305 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2307 rates |= rate_bits[i].alsa_bits;
2312 if (formatsp || bpsp) {
2317 wcaps = get_wcaps(codec, nid);
2318 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2322 streams = snd_hda_param_read(codec, codec->afg,
2329 if (streams & AC_SUPFMT_PCM) {
2330 if (val & AC_SUPPCM_BITS_8) {
2331 formats |= SNDRV_PCM_FMTBIT_U8;
2334 if (val & AC_SUPPCM_BITS_16) {
2335 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2338 if (wcaps & AC_WCAP_DIGITAL) {
2339 if (val & AC_SUPPCM_BITS_32)
2340 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2341 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2342 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2343 if (val & AC_SUPPCM_BITS_24)
2345 else if (val & AC_SUPPCM_BITS_20)
2347 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2348 AC_SUPPCM_BITS_32)) {
2349 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2350 if (val & AC_SUPPCM_BITS_32)
2352 else if (val & AC_SUPPCM_BITS_24)
2354 else if (val & AC_SUPPCM_BITS_20)
2358 else if (streams == AC_SUPFMT_FLOAT32) {
2359 /* should be exclusive */
2360 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2362 } else if (streams == AC_SUPFMT_AC3) {
2363 /* should be exclusive */
2364 /* temporary hack: we have still no proper support
2365 * for the direct AC3 stream...
2367 formats |= SNDRV_PCM_FMTBIT_U8;
2371 *formatsp = formats;
2380 * snd_hda_is_supported_format - check whether the given node supports
2383 * Returns 1 if supported, 0 if not.
2385 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2386 unsigned int format)
2389 unsigned int val = 0, rate, stream;
2391 if (nid != codec->afg &&
2392 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2393 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2398 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2403 rate = format & 0xff00;
2404 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2405 if (rate_bits[i].hda_fmt == rate) {
2410 if (i >= AC_PAR_PCM_RATE_BITS)
2413 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2416 if (!stream && nid != codec->afg)
2417 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2418 if (!stream || stream == -1)
2421 if (stream & AC_SUPFMT_PCM) {
2422 switch (format & 0xf0) {
2424 if (!(val & AC_SUPPCM_BITS_8))
2428 if (!(val & AC_SUPPCM_BITS_16))
2432 if (!(val & AC_SUPPCM_BITS_20))
2436 if (!(val & AC_SUPPCM_BITS_24))
2440 if (!(val & AC_SUPPCM_BITS_32))
2447 /* FIXME: check for float32 and AC3? */
2452 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2457 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2458 struct hda_codec *codec,
2459 struct snd_pcm_substream *substream)
2464 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2465 struct hda_codec *codec,
2466 unsigned int stream_tag,
2467 unsigned int format,
2468 struct snd_pcm_substream *substream)
2470 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2474 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2475 struct hda_codec *codec,
2476 struct snd_pcm_substream *substream)
2478 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2482 static int set_pcm_default_values(struct hda_codec *codec,
2483 struct hda_pcm_stream *info)
2485 /* query support PCM information from the given NID */
2486 if (info->nid && (!info->rates || !info->formats)) {
2487 snd_hda_query_supported_pcm(codec, info->nid,
2488 info->rates ? NULL : &info->rates,
2489 info->formats ? NULL : &info->formats,
2490 info->maxbps ? NULL : &info->maxbps);
2492 if (info->ops.open == NULL)
2493 info->ops.open = hda_pcm_default_open_close;
2494 if (info->ops.close == NULL)
2495 info->ops.close = hda_pcm_default_open_close;
2496 if (info->ops.prepare == NULL) {
2497 if (snd_BUG_ON(!info->nid))
2499 info->ops.prepare = hda_pcm_default_prepare;
2501 if (info->ops.cleanup == NULL) {
2502 if (snd_BUG_ON(!info->nid))
2504 info->ops.cleanup = hda_pcm_default_cleanup;
2510 * get the empty PCM device number to assign
2512 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2514 static const char *dev_name[HDA_PCM_NTYPES] = {
2515 "Audio", "SPDIF", "HDMI", "Modem"
2517 /* starting device index for each PCM type */
2518 static int dev_idx[HDA_PCM_NTYPES] = {
2519 [HDA_PCM_TYPE_AUDIO] = 0,
2520 [HDA_PCM_TYPE_SPDIF] = 1,
2521 [HDA_PCM_TYPE_HDMI] = 3,
2522 [HDA_PCM_TYPE_MODEM] = 6
2524 /* normal audio device indices; not linear to keep compatibility */
2525 static int audio_idx[4] = { 0, 2, 4, 5 };
2529 case HDA_PCM_TYPE_AUDIO:
2530 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2532 if (!test_bit(dev, bus->pcm_dev_bits))
2535 if (i >= ARRAY_SIZE(audio_idx)) {
2536 snd_printk(KERN_WARNING "Too many audio devices\n");
2540 case HDA_PCM_TYPE_SPDIF:
2541 case HDA_PCM_TYPE_HDMI:
2542 case HDA_PCM_TYPE_MODEM:
2543 dev = dev_idx[type];
2544 if (test_bit(dev, bus->pcm_dev_bits)) {
2545 snd_printk(KERN_WARNING "%s already defined\n",
2551 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2554 set_bit(dev, bus->pcm_dev_bits);
2559 * attach a new PCM stream
2561 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2563 struct hda_bus *bus = codec->bus;
2564 struct hda_pcm_stream *info;
2567 if (snd_BUG_ON(!pcm->name))
2569 for (stream = 0; stream < 2; stream++) {
2570 info = &pcm->stream[stream];
2571 if (info->substreams) {
2572 err = set_pcm_default_values(codec, info);
2577 return bus->ops.attach_pcm(bus, codec, pcm);
2580 /* assign all PCMs of the given codec */
2581 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2586 if (!codec->num_pcms) {
2587 if (!codec->patch_ops.build_pcms)
2589 err = codec->patch_ops.build_pcms(codec);
2593 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2594 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2597 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2598 return 0; /* no substreams assigned */
2601 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2605 err = snd_hda_attach_pcm(codec, cpcm);
2614 * snd_hda_build_pcms - build PCM information
2617 * Create PCM information for each codec included in the bus.
2619 * The build_pcms codec patch is requested to set up codec->num_pcms and
2620 * codec->pcm_info properly. The array is referred by the top-level driver
2621 * to create its PCM instances.
2622 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2625 * At least, substreams, channels_min and channels_max must be filled for
2626 * each stream. substreams = 0 indicates that the stream doesn't exist.
2627 * When rates and/or formats are zero, the supported values are queried
2628 * from the given nid. The nid is used also by the default ops.prepare
2629 * and ops.cleanup callbacks.
2631 * The driver needs to call ops.open in its open callback. Similarly,
2632 * ops.close is supposed to be called in the close callback.
2633 * ops.prepare should be called in the prepare or hw_params callback
2634 * with the proper parameters for set up.
2635 * ops.cleanup should be called in hw_free for clean up of streams.
2637 * This function returns 0 if successfull, or a negative error code.
2639 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2641 struct hda_codec *codec;
2643 list_for_each_entry(codec, &bus->codec_list, list) {
2644 int err = snd_hda_codec_build_pcms(codec);
2650 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2653 * snd_hda_check_board_config - compare the current codec with the config table
2654 * @codec: the HDA codec
2655 * @num_configs: number of config enums
2656 * @models: array of model name strings
2657 * @tbl: configuration table, terminated by null entries
2659 * Compares the modelname or PCI subsystem id of the current codec with the
2660 * given configuration table. If a matching entry is found, returns its
2661 * config value (supposed to be 0 or positive).
2663 * If no entries are matching, the function returns a negative value.
2665 int snd_hda_check_board_config(struct hda_codec *codec,
2666 int num_configs, const char **models,
2667 const struct snd_pci_quirk *tbl)
2669 if (codec->modelname && models) {
2671 for (i = 0; i < num_configs; i++) {
2673 !strcmp(codec->modelname, models[i])) {
2674 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2675 "selected\n", models[i]);
2681 if (!codec->bus->pci || !tbl)
2684 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2687 if (tbl->value >= 0 && tbl->value < num_configs) {
2688 #ifdef CONFIG_SND_DEBUG_VERBOSE
2690 const char *model = NULL;
2692 model = models[tbl->value];
2694 sprintf(tmp, "#%d", tbl->value);
2697 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2698 "for config %x:%x (%s)\n",
2699 model, tbl->subvendor, tbl->subdevice,
2700 (tbl->name ? tbl->name : "Unknown device"));
2706 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
2709 * snd_hda_add_new_ctls - create controls from the array
2710 * @codec: the HDA codec
2711 * @knew: the array of struct snd_kcontrol_new
2713 * This helper function creates and add new controls in the given array.
2714 * The array must be terminated with an empty entry as terminator.
2716 * Returns 0 if successful, or a negative error code.
2718 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
2722 for (; knew->name; knew++) {
2723 struct snd_kcontrol *kctl;
2724 kctl = snd_ctl_new1(knew, codec);
2727 err = snd_hda_ctl_add(codec, kctl);
2731 kctl = snd_ctl_new1(knew, codec);
2734 kctl->id.device = codec->addr;
2735 err = snd_hda_ctl_add(codec, kctl);
2742 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
2744 #ifdef CONFIG_SND_HDA_POWER_SAVE
2745 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2746 unsigned int power_state);
2748 static void hda_power_work(struct work_struct *work)
2750 struct hda_codec *codec =
2751 container_of(work, struct hda_codec, power_work.work);
2752 struct hda_bus *bus = codec->bus;
2754 if (!codec->power_on || codec->power_count) {
2755 codec->power_transition = 0;
2759 hda_call_codec_suspend(codec);
2760 if (bus->ops.pm_notify)
2761 bus->ops.pm_notify(bus);
2764 static void hda_keep_power_on(struct hda_codec *codec)
2766 codec->power_count++;
2767 codec->power_on = 1;
2770 void snd_hda_power_up(struct hda_codec *codec)
2772 struct hda_bus *bus = codec->bus;
2774 codec->power_count++;
2775 if (codec->power_on || codec->power_transition)
2778 codec->power_on = 1;
2779 if (bus->ops.pm_notify)
2780 bus->ops.pm_notify(bus);
2781 hda_call_codec_resume(codec);
2782 cancel_delayed_work(&codec->power_work);
2783 codec->power_transition = 0;
2785 EXPORT_SYMBOL_HDA(snd_hda_power_up);
2787 #define power_save(codec) \
2788 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2790 #define power_save(codec) \
2791 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2793 void snd_hda_power_down(struct hda_codec *codec)
2795 --codec->power_count;
2796 if (!codec->power_on || codec->power_count || codec->power_transition)
2798 if (power_save(codec)) {
2799 codec->power_transition = 1; /* avoid reentrance */
2800 schedule_delayed_work(&codec->power_work,
2801 msecs_to_jiffies(power_save(codec) * 1000));
2804 EXPORT_SYMBOL_HDA(snd_hda_power_down);
2806 int snd_hda_check_amp_list_power(struct hda_codec *codec,
2807 struct hda_loopback_check *check,
2810 struct hda_amp_list *p;
2813 if (!check->amplist)
2815 for (p = check->amplist; p->nid; p++) {
2820 return 0; /* nothing changed */
2822 for (p = check->amplist; p->nid; p++) {
2823 for (ch = 0; ch < 2; ch++) {
2824 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
2826 if (!(v & HDA_AMP_MUTE) && v > 0) {
2827 if (!check->power_on) {
2828 check->power_on = 1;
2829 snd_hda_power_up(codec);
2835 if (check->power_on) {
2836 check->power_on = 0;
2837 snd_hda_power_down(codec);
2841 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
2845 * Channel mode helper
2847 int snd_hda_ch_mode_info(struct hda_codec *codec,
2848 struct snd_ctl_elem_info *uinfo,
2849 const struct hda_channel_mode *chmode,
2852 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2854 uinfo->value.enumerated.items = num_chmodes;
2855 if (uinfo->value.enumerated.item >= num_chmodes)
2856 uinfo->value.enumerated.item = num_chmodes - 1;
2857 sprintf(uinfo->value.enumerated.name, "%dch",
2858 chmode[uinfo->value.enumerated.item].channels);
2861 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
2863 int snd_hda_ch_mode_get(struct hda_codec *codec,
2864 struct snd_ctl_elem_value *ucontrol,
2865 const struct hda_channel_mode *chmode,
2871 for (i = 0; i < num_chmodes; i++) {
2872 if (max_channels == chmode[i].channels) {
2873 ucontrol->value.enumerated.item[0] = i;
2879 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
2881 int snd_hda_ch_mode_put(struct hda_codec *codec,
2882 struct snd_ctl_elem_value *ucontrol,
2883 const struct hda_channel_mode *chmode,
2889 mode = ucontrol->value.enumerated.item[0];
2890 if (mode >= num_chmodes)
2892 if (*max_channelsp == chmode[mode].channels)
2894 /* change the current channel setting */
2895 *max_channelsp = chmode[mode].channels;
2896 if (chmode[mode].sequence)
2897 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
2900 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
2905 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
2906 struct snd_ctl_elem_info *uinfo)
2910 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2912 uinfo->value.enumerated.items = imux->num_items;
2913 if (!imux->num_items)
2915 index = uinfo->value.enumerated.item;
2916 if (index >= imux->num_items)
2917 index = imux->num_items - 1;
2918 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
2921 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
2923 int snd_hda_input_mux_put(struct hda_codec *codec,
2924 const struct hda_input_mux *imux,
2925 struct snd_ctl_elem_value *ucontrol,
2927 unsigned int *cur_val)
2931 if (!imux->num_items)
2933 idx = ucontrol->value.enumerated.item[0];
2934 if (idx >= imux->num_items)
2935 idx = imux->num_items - 1;
2936 if (*cur_val == idx)
2938 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
2939 imux->items[idx].index);
2943 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
2947 * Multi-channel / digital-out PCM helper functions
2950 /* setup SPDIF output stream */
2951 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
2952 unsigned int stream_tag, unsigned int format)
2954 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
2955 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2956 set_dig_out_convert(codec, nid,
2957 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
2959 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2960 if (codec->slave_dig_outs) {
2962 for (d = codec->slave_dig_outs; *d; d++)
2963 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
2966 /* turn on again (if needed) */
2967 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2968 set_dig_out_convert(codec, nid,
2969 codec->spdif_ctls & 0xff, -1);
2972 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
2974 snd_hda_codec_cleanup_stream(codec, nid);
2975 if (codec->slave_dig_outs) {
2977 for (d = codec->slave_dig_outs; *d; d++)
2978 snd_hda_codec_cleanup_stream(codec, *d);
2983 * open the digital out in the exclusive mode
2985 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
2986 struct hda_multi_out *mout)
2988 mutex_lock(&codec->spdif_mutex);
2989 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
2990 /* already opened as analog dup; reset it once */
2991 cleanup_dig_out_stream(codec, mout->dig_out_nid);
2992 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
2993 mutex_unlock(&codec->spdif_mutex);
2996 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
2998 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
2999 struct hda_multi_out *mout,
3000 unsigned int stream_tag,
3001 unsigned int format,
3002 struct snd_pcm_substream *substream)
3004 mutex_lock(&codec->spdif_mutex);
3005 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3006 mutex_unlock(&codec->spdif_mutex);
3009 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3012 * release the digital out
3014 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3015 struct hda_multi_out *mout)
3017 mutex_lock(&codec->spdif_mutex);
3018 mout->dig_out_used = 0;
3019 mutex_unlock(&codec->spdif_mutex);
3022 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3025 * set up more restrictions for analog out
3027 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3028 struct hda_multi_out *mout,
3029 struct snd_pcm_substream *substream,
3030 struct hda_pcm_stream *hinfo)
3032 struct snd_pcm_runtime *runtime = substream->runtime;
3033 runtime->hw.channels_max = mout->max_channels;
3034 if (mout->dig_out_nid) {
3035 if (!mout->analog_rates) {
3036 mout->analog_rates = hinfo->rates;
3037 mout->analog_formats = hinfo->formats;
3038 mout->analog_maxbps = hinfo->maxbps;
3040 runtime->hw.rates = mout->analog_rates;
3041 runtime->hw.formats = mout->analog_formats;
3042 hinfo->maxbps = mout->analog_maxbps;
3044 if (!mout->spdif_rates) {
3045 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3047 &mout->spdif_formats,
3048 &mout->spdif_maxbps);
3050 mutex_lock(&codec->spdif_mutex);
3051 if (mout->share_spdif) {
3052 runtime->hw.rates &= mout->spdif_rates;
3053 runtime->hw.formats &= mout->spdif_formats;
3054 if (mout->spdif_maxbps < hinfo->maxbps)
3055 hinfo->maxbps = mout->spdif_maxbps;
3057 mutex_unlock(&codec->spdif_mutex);
3059 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3060 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3062 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3065 * set up the i/o for analog out
3066 * when the digital out is available, copy the front out to digital out, too.
3068 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3069 struct hda_multi_out *mout,
3070 unsigned int stream_tag,
3071 unsigned int format,
3072 struct snd_pcm_substream *substream)
3074 hda_nid_t *nids = mout->dac_nids;
3075 int chs = substream->runtime->channels;
3078 mutex_lock(&codec->spdif_mutex);
3079 if (mout->dig_out_nid && mout->share_spdif &&
3080 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3082 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3084 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3085 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3086 setup_dig_out_stream(codec, mout->dig_out_nid,
3087 stream_tag, format);
3089 mout->dig_out_used = 0;
3090 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3093 mutex_unlock(&codec->spdif_mutex);
3096 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3098 if (!mout->no_share_stream &&
3099 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3100 /* headphone out will just decode front left/right (stereo) */
3101 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3103 /* extra outputs copied from front */
3104 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3105 if (!mout->no_share_stream && mout->extra_out_nid[i])
3106 snd_hda_codec_setup_stream(codec,
3107 mout->extra_out_nid[i],
3108 stream_tag, 0, format);
3111 for (i = 1; i < mout->num_dacs; i++) {
3112 if (chs >= (i + 1) * 2) /* independent out */
3113 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3115 else if (!mout->no_share_stream) /* copy front */
3116 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3121 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3124 * clean up the setting for analog out
3126 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3127 struct hda_multi_out *mout)
3129 hda_nid_t *nids = mout->dac_nids;
3132 for (i = 0; i < mout->num_dacs; i++)
3133 snd_hda_codec_cleanup_stream(codec, nids[i]);
3135 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3136 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3137 if (mout->extra_out_nid[i])
3138 snd_hda_codec_cleanup_stream(codec,
3139 mout->extra_out_nid[i]);
3140 mutex_lock(&codec->spdif_mutex);
3141 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3142 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3143 mout->dig_out_used = 0;
3145 mutex_unlock(&codec->spdif_mutex);
3148 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3151 * Helper for automatic pin configuration
3154 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3156 for (; *list; list++)
3164 * Sort an associated group of pins according to their sequence numbers.
3166 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3173 for (i = 0; i < num_pins; i++) {
3174 for (j = i + 1; j < num_pins; j++) {
3175 if (sequences[i] > sequences[j]) {
3177 sequences[i] = sequences[j];
3189 * Parse all pin widgets and store the useful pin nids to cfg
3191 * The number of line-outs or any primary output is stored in line_outs,
3192 * and the corresponding output pins are assigned to line_out_pins[],
3193 * in the order of front, rear, CLFE, side, ...
3195 * If more extra outputs (speaker and headphone) are found, the pins are
3196 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3197 * is detected, one of speaker of HP pins is assigned as the primary
3198 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3199 * if any analog output exists.
3201 * The analog input pins are assigned to input_pins array.
3202 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3205 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3206 struct auto_pin_cfg *cfg,
3207 hda_nid_t *ignore_nids)
3209 hda_nid_t nid, end_nid;
3210 short seq, assoc_line_out, assoc_speaker;
3211 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3212 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3213 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3215 memset(cfg, 0, sizeof(*cfg));
3217 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3218 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3219 memset(sequences_hp, 0, sizeof(sequences_hp));
3220 assoc_line_out = assoc_speaker = 0;
3222 end_nid = codec->start_nid + codec->num_nodes;
3223 for (nid = codec->start_nid; nid < end_nid; nid++) {
3224 unsigned int wid_caps = get_wcaps(codec, nid);
3225 unsigned int wid_type =
3226 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3227 unsigned int def_conf;
3230 /* read all default configuration for pin complex */
3231 if (wid_type != AC_WID_PIN)
3233 /* ignore the given nids (e.g. pc-beep returns error) */
3234 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3237 def_conf = snd_hda_codec_read(codec, nid, 0,
3238 AC_VERB_GET_CONFIG_DEFAULT, 0);
3239 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3241 loc = get_defcfg_location(def_conf);
3242 switch (get_defcfg_device(def_conf)) {
3243 case AC_JACK_LINE_OUT:
3244 seq = get_defcfg_sequence(def_conf);
3245 assoc = get_defcfg_association(def_conf);
3247 if (!(wid_caps & AC_WCAP_STEREO))
3248 if (!cfg->mono_out_pin)
3249 cfg->mono_out_pin = nid;
3252 if (!assoc_line_out)
3253 assoc_line_out = assoc;
3254 else if (assoc_line_out != assoc)
3256 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3258 cfg->line_out_pins[cfg->line_outs] = nid;
3259 sequences_line_out[cfg->line_outs] = seq;
3262 case AC_JACK_SPEAKER:
3263 seq = get_defcfg_sequence(def_conf);
3264 assoc = get_defcfg_association(def_conf);
3267 if (! assoc_speaker)
3268 assoc_speaker = assoc;
3269 else if (assoc_speaker != assoc)
3271 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3273 cfg->speaker_pins[cfg->speaker_outs] = nid;
3274 sequences_speaker[cfg->speaker_outs] = seq;
3275 cfg->speaker_outs++;
3277 case AC_JACK_HP_OUT:
3278 seq = get_defcfg_sequence(def_conf);
3279 assoc = get_defcfg_association(def_conf);
3280 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3282 cfg->hp_pins[cfg->hp_outs] = nid;
3283 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3286 case AC_JACK_MIC_IN: {
3288 if (loc == AC_JACK_LOC_FRONT) {
3289 preferred = AUTO_PIN_FRONT_MIC;
3292 preferred = AUTO_PIN_MIC;
3293 alt = AUTO_PIN_FRONT_MIC;
3295 if (!cfg->input_pins[preferred])
3296 cfg->input_pins[preferred] = nid;
3297 else if (!cfg->input_pins[alt])
3298 cfg->input_pins[alt] = nid;
3301 case AC_JACK_LINE_IN:
3302 if (loc == AC_JACK_LOC_FRONT)
3303 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3305 cfg->input_pins[AUTO_PIN_LINE] = nid;
3308 cfg->input_pins[AUTO_PIN_CD] = nid;
3311 cfg->input_pins[AUTO_PIN_AUX] = nid;
3313 case AC_JACK_SPDIF_OUT:
3314 cfg->dig_out_pin = nid;
3316 case AC_JACK_SPDIF_IN:
3317 cfg->dig_in_pin = nid;
3323 * If no line-out is defined but multiple HPs are found,
3324 * some of them might be the real line-outs.
3326 if (!cfg->line_outs && cfg->hp_outs > 1) {
3328 while (i < cfg->hp_outs) {
3329 /* The real HPs should have the sequence 0x0f */
3330 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3334 /* Move it to the line-out table */
3335 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3336 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3339 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3340 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3341 memmove(sequences_hp + i - 1, sequences_hp + i,
3342 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3346 /* sort by sequence */
3347 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3349 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3351 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3354 /* if we have only one mic, make it AUTO_PIN_MIC */
3355 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3356 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3357 cfg->input_pins[AUTO_PIN_MIC] =
3358 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3359 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3361 /* ditto for line-in */
3362 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3363 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3364 cfg->input_pins[AUTO_PIN_LINE] =
3365 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3366 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3370 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3371 * as a primary output
3373 if (!cfg->line_outs) {
3374 if (cfg->speaker_outs) {
3375 cfg->line_outs = cfg->speaker_outs;
3376 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3377 sizeof(cfg->speaker_pins));
3378 cfg->speaker_outs = 0;
3379 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3380 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3381 } else if (cfg->hp_outs) {
3382 cfg->line_outs = cfg->hp_outs;
3383 memcpy(cfg->line_out_pins, cfg->hp_pins,
3384 sizeof(cfg->hp_pins));
3386 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3387 cfg->line_out_type = AUTO_PIN_HP_OUT;
3391 /* Reorder the surround channels
3392 * ALSA sequence is front/surr/clfe/side
3394 * 4-ch: front/surr => OK as it is
3395 * 6-ch: front/clfe/surr
3396 * 8-ch: front/clfe/rear/side|fc
3398 switch (cfg->line_outs) {
3401 nid = cfg->line_out_pins[1];
3402 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3403 cfg->line_out_pins[2] = nid;
3408 * debug prints of the parsed results
3410 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3411 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3412 cfg->line_out_pins[2], cfg->line_out_pins[3],
3413 cfg->line_out_pins[4]);
3414 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3415 cfg->speaker_outs, cfg->speaker_pins[0],
3416 cfg->speaker_pins[1], cfg->speaker_pins[2],
3417 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3418 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3419 cfg->hp_outs, cfg->hp_pins[0],
3420 cfg->hp_pins[1], cfg->hp_pins[2],
3421 cfg->hp_pins[3], cfg->hp_pins[4]);
3422 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3423 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3424 " cd=0x%x, aux=0x%x\n",
3425 cfg->input_pins[AUTO_PIN_MIC],
3426 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3427 cfg->input_pins[AUTO_PIN_LINE],
3428 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3429 cfg->input_pins[AUTO_PIN_CD],
3430 cfg->input_pins[AUTO_PIN_AUX]);
3434 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3436 /* labels for input pins */
3437 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3438 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3440 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3449 * snd_hda_suspend - suspend the codecs
3451 * @state: suspsend state
3453 * Returns 0 if successful.
3455 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3457 struct hda_codec *codec;
3459 list_for_each_entry(codec, &bus->codec_list, list) {
3460 #ifdef CONFIG_SND_HDA_POWER_SAVE
3461 if (!codec->power_on)
3464 hda_call_codec_suspend(codec);
3468 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3471 * snd_hda_resume - resume the codecs
3474 * Returns 0 if successful.
3476 * This fucntion is defined only when POWER_SAVE isn't set.
3477 * In the power-save mode, the codec is resumed dynamically.
3479 int snd_hda_resume(struct hda_bus *bus)
3481 struct hda_codec *codec;
3483 list_for_each_entry(codec, &bus->codec_list, list) {
3484 if (snd_hda_codec_needs_resume(codec))
3485 hda_call_codec_resume(codec);
3489 EXPORT_SYMBOL_HDA(snd_hda_resume);
3490 #endif /* CONFIG_PM */
3496 /* get a new element from the given array
3497 * if it exceeds the pre-allocated array size, re-allocate the array
3499 void *snd_array_new(struct snd_array *array)
3501 if (array->used >= array->alloced) {
3502 int num = array->alloced + array->alloc_align;
3504 if (snd_BUG_ON(num >= 4096))
3506 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3510 memcpy(nlist, array->list,
3511 array->elem_size * array->alloced);
3514 array->list = nlist;
3515 array->alloced = num;
3517 return snd_array_elem(array, array->used++);
3519 EXPORT_SYMBOL_HDA(snd_array_new);
3521 /* free the given array elements */
3522 void snd_array_free(struct snd_array *array)
3529 EXPORT_SYMBOL_HDA(snd_array_free);
3532 * used by hda_proc.c and hda_eld.c
3534 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3536 static unsigned int rates[] = {
3537 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3538 96000, 176400, 192000, 384000
3542 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3544 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3546 buf[j] = '\0'; /* necessary when j == 0 */
3548 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3550 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3552 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3555 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3556 if (pcm & (AC_SUPPCM_BITS_8 << i))
3557 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3559 buf[j] = '\0'; /* necessary when j == 0 */
3561 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
3563 MODULE_DESCRIPTION("HDA codec core");
3564 MODULE_LICENSE("GPL");