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" },
50 { 0x10ec, "Realtek" },
54 { 0x11d4, "Analog Devices" },
55 { 0x13f6, "C-Media" },
56 { 0x14f1, "Conexant" },
57 { 0x17e8, "Chrontel" },
59 { 0x1aec, "Wolfson Microelectronics" },
60 { 0x434d, "C-Media" },
62 { 0x8384, "SigmaTel" },
66 static DEFINE_MUTEX(preset_mutex);
67 static LIST_HEAD(hda_preset_tables);
69 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
71 mutex_lock(&preset_mutex);
72 list_add_tail(&preset->list, &hda_preset_tables);
73 mutex_unlock(&preset_mutex);
76 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
78 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
80 mutex_lock(&preset_mutex);
81 list_del(&preset->list);
82 mutex_unlock(&preset_mutex);
85 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
87 #ifdef CONFIG_SND_HDA_POWER_SAVE
88 static void hda_power_work(struct work_struct *work);
89 static void hda_keep_power_on(struct hda_codec *codec);
91 static inline void hda_keep_power_on(struct hda_codec *codec) {}
94 const char *snd_hda_get_jack_location(u32 cfg)
96 static char *bases[7] = {
97 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
99 static unsigned char specials_idx[] = {
104 static char *specials[] = {
105 "Rear Panel", "Drive Bar",
106 "Riser", "HDMI", "ATAPI",
107 "Mobile-In", "Mobile-Out"
110 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
111 if ((cfg & 0x0f) < 7)
112 return bases[cfg & 0x0f];
113 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
114 if (cfg == specials_idx[i])
119 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
121 const char *snd_hda_get_jack_connectivity(u32 cfg)
123 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
125 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
127 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
129 const char *snd_hda_get_jack_type(u32 cfg)
131 static char *jack_types[16] = {
132 "Line Out", "Speaker", "HP Out", "CD",
133 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
134 "Line In", "Aux", "Mic", "Telephony",
135 "SPDIF In", "Digitial In", "Reserved", "Other"
138 return jack_types[(cfg & AC_DEFCFG_DEVICE)
139 >> AC_DEFCFG_DEVICE_SHIFT];
141 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
144 * Compose a 32bit command word to be sent to the HD-audio controller
146 static inline unsigned int
147 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
148 unsigned int verb, unsigned int parm)
152 val = (u32)(codec->addr & 0x0f) << 28;
153 val |= (u32)direct << 27;
154 val |= (u32)nid << 20;
161 * snd_hda_codec_read - send a command and get the response
162 * @codec: the HDA codec
163 * @nid: NID to send the command
164 * @direct: direct flag
165 * @verb: the verb to send
166 * @parm: the parameter for the verb
168 * Send a single command and read the corresponding response.
170 * Returns the obtained response value, or -1 for an error.
172 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
174 unsigned int verb, unsigned int parm)
176 struct hda_bus *bus = codec->bus;
179 res = make_codec_cmd(codec, nid, direct, verb, parm);
180 snd_hda_power_up(codec);
181 mutex_lock(&bus->cmd_mutex);
182 if (!bus->ops.command(bus, res))
183 res = bus->ops.get_response(bus);
185 res = (unsigned int)-1;
186 mutex_unlock(&bus->cmd_mutex);
187 snd_hda_power_down(codec);
190 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
193 * snd_hda_codec_write - send a single command without waiting for response
194 * @codec: the HDA codec
195 * @nid: NID to send the command
196 * @direct: direct flag
197 * @verb: the verb to send
198 * @parm: the parameter for the verb
200 * Send a single command without waiting for response.
202 * Returns 0 if successful, or a negative error code.
204 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
205 unsigned int verb, unsigned int parm)
207 struct hda_bus *bus = codec->bus;
211 res = make_codec_cmd(codec, nid, direct, verb, parm);
212 snd_hda_power_up(codec);
213 mutex_lock(&bus->cmd_mutex);
214 err = bus->ops.command(bus, res);
215 mutex_unlock(&bus->cmd_mutex);
216 snd_hda_power_down(codec);
219 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
222 * snd_hda_sequence_write - sequence writes
223 * @codec: the HDA codec
224 * @seq: VERB array to send
226 * Send the commands sequentially from the given array.
227 * The array must be terminated with NID=0.
229 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
231 for (; seq->nid; seq++)
232 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
234 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
237 * snd_hda_get_sub_nodes - get the range of sub nodes
238 * @codec: the HDA codec
240 * @start_id: the pointer to store the start NID
242 * Parse the NID and store the start NID of its sub-nodes.
243 * Returns the number of sub-nodes.
245 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
250 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
253 *start_id = (parm >> 16) & 0x7fff;
254 return (int)(parm & 0x7fff);
256 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
259 * snd_hda_get_connections - get connection list
260 * @codec: the HDA codec
262 * @conn_list: connection list array
263 * @max_conns: max. number of connections to store
265 * Parses the connection list of the given widget and stores the list
268 * Returns the number of connections, or a negative error code.
270 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
271 hda_nid_t *conn_list, int max_conns)
274 int i, conn_len, conns;
275 unsigned int shift, num_elems, mask;
278 if (snd_BUG_ON(!conn_list || max_conns <= 0))
281 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
282 if (parm & AC_CLIST_LONG) {
291 conn_len = parm & AC_CLIST_LENGTH;
292 mask = (1 << (shift-1)) - 1;
295 return 0; /* no connection */
298 /* single connection */
299 parm = snd_hda_codec_read(codec, nid, 0,
300 AC_VERB_GET_CONNECT_LIST, 0);
301 conn_list[0] = parm & mask;
305 /* multi connection */
308 for (i = 0; i < conn_len; i++) {
312 if (i % num_elems == 0)
313 parm = snd_hda_codec_read(codec, nid, 0,
314 AC_VERB_GET_CONNECT_LIST, i);
315 range_val = !!(parm & (1 << (shift-1))); /* ranges */
319 /* ranges between the previous and this one */
320 if (!prev_nid || prev_nid >= val) {
321 snd_printk(KERN_WARNING "hda_codec: "
322 "invalid dep_range_val %x:%x\n",
326 for (n = prev_nid + 1; n <= val; n++) {
327 if (conns >= max_conns) {
329 "Too many connections\n");
332 conn_list[conns++] = n;
335 if (conns >= max_conns) {
336 snd_printk(KERN_ERR "Too many connections\n");
339 conn_list[conns++] = val;
345 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
349 * snd_hda_queue_unsol_event - add an unsolicited event to queue
351 * @res: unsolicited event (lower 32bit of RIRB entry)
352 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
354 * Adds the given event to the queue. The events are processed in
355 * the workqueue asynchronously. Call this function in the interrupt
356 * hanlder when RIRB receives an unsolicited event.
358 * Returns 0 if successful, or a negative error code.
360 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
362 struct hda_bus_unsolicited *unsol;
369 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
373 unsol->queue[wp] = res;
374 unsol->queue[wp + 1] = res_ex;
376 schedule_work(&unsol->work);
380 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
383 * process queued unsolicited events
385 static void process_unsol_events(struct work_struct *work)
387 struct hda_bus_unsolicited *unsol =
388 container_of(work, struct hda_bus_unsolicited, work);
389 struct hda_bus *bus = unsol->bus;
390 struct hda_codec *codec;
391 unsigned int rp, caddr, res;
393 while (unsol->rp != unsol->wp) {
394 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
397 res = unsol->queue[rp];
398 caddr = unsol->queue[rp + 1];
399 if (!(caddr & (1 << 4))) /* no unsolicited event? */
401 codec = bus->caddr_tbl[caddr & 0x0f];
402 if (codec && codec->patch_ops.unsol_event)
403 codec->patch_ops.unsol_event(codec, res);
408 * initialize unsolicited queue
410 static int init_unsol_queue(struct hda_bus *bus)
412 struct hda_bus_unsolicited *unsol;
414 if (bus->unsol) /* already initialized */
417 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
419 snd_printk(KERN_ERR "hda_codec: "
420 "can't allocate unsolicited queue\n");
423 INIT_WORK(&unsol->work, process_unsol_events);
432 static void snd_hda_codec_free(struct hda_codec *codec);
434 static int snd_hda_bus_free(struct hda_bus *bus)
436 struct hda_codec *codec, *n;
441 flush_scheduled_work();
444 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
445 snd_hda_codec_free(codec);
447 if (bus->ops.private_free)
448 bus->ops.private_free(bus);
453 static int snd_hda_bus_dev_free(struct snd_device *device)
455 struct hda_bus *bus = device->device_data;
457 return snd_hda_bus_free(bus);
460 #ifdef CONFIG_SND_HDA_HWDEP
461 static int snd_hda_bus_dev_register(struct snd_device *device)
463 struct hda_bus *bus = device->device_data;
464 struct hda_codec *codec;
465 list_for_each_entry(codec, &bus->codec_list, list) {
466 snd_hda_hwdep_add_sysfs(codec);
471 #define snd_hda_bus_dev_register NULL
475 * snd_hda_bus_new - create a HDA bus
476 * @card: the card entry
477 * @temp: the template for hda_bus information
478 * @busp: the pointer to store the created bus instance
480 * Returns 0 if successful, or a negative error code.
482 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
483 const struct hda_bus_template *temp,
484 struct hda_bus **busp)
488 static struct snd_device_ops dev_ops = {
489 .dev_register = snd_hda_bus_dev_register,
490 .dev_free = snd_hda_bus_dev_free,
493 if (snd_BUG_ON(!temp))
495 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
501 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
503 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
508 bus->private_data = temp->private_data;
509 bus->pci = temp->pci;
510 bus->modelname = temp->modelname;
511 bus->power_save = temp->power_save;
512 bus->ops = temp->ops;
514 mutex_init(&bus->cmd_mutex);
515 INIT_LIST_HEAD(&bus->codec_list);
517 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
519 snd_hda_bus_free(bus);
526 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
528 #ifdef CONFIG_SND_HDA_GENERIC
529 #define is_generic_config(codec) \
530 (codec->modelname && !strcmp(codec->modelname, "generic"))
532 #define is_generic_config(codec) 0
536 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
538 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
542 * find a matching codec preset
544 static const struct hda_codec_preset *
545 find_codec_preset(struct hda_codec *codec)
547 struct hda_codec_preset_list *tbl;
548 const struct hda_codec_preset *preset;
549 int mod_requested = 0;
551 if (is_generic_config(codec))
552 return NULL; /* use the generic parser */
555 mutex_lock(&preset_mutex);
556 list_for_each_entry(tbl, &hda_preset_tables, list) {
557 if (!try_module_get(tbl->owner)) {
558 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
561 for (preset = tbl->preset; preset->id; preset++) {
562 u32 mask = preset->mask;
563 if (preset->afg && preset->afg != codec->afg)
565 if (preset->mfg && preset->mfg != codec->mfg)
569 if (preset->id == (codec->vendor_id & mask) &&
571 preset->rev == codec->revision_id)) {
572 mutex_unlock(&preset_mutex);
573 codec->owner = tbl->owner;
577 module_put(tbl->owner);
579 mutex_unlock(&preset_mutex);
581 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
584 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
587 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
588 (codec->vendor_id >> 16) & 0xffff);
589 request_module(name);
597 * get_codec_name - store the codec name
599 static int get_codec_name(struct hda_codec *codec)
601 const struct hda_vendor_id *c;
602 const char *vendor = NULL;
603 u16 vendor_id = codec->vendor_id >> 16;
604 char tmp[16], name[32];
606 for (c = hda_vendor_ids; c->id; c++) {
607 if (c->id == vendor_id) {
613 sprintf(tmp, "Generic %04x", vendor_id);
616 if (codec->preset && codec->preset->name)
617 snprintf(name, sizeof(name), "%s %s", vendor,
618 codec->preset->name);
620 snprintf(name, sizeof(name), "%s ID %x", vendor,
621 codec->vendor_id & 0xffff);
622 codec->name = kstrdup(name, GFP_KERNEL);
629 * look for an AFG and MFG nodes
631 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
636 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
637 for (i = 0; i < total_nodes; i++, nid++) {
639 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
640 switch (func & 0xff) {
641 case AC_GRP_AUDIO_FUNCTION:
644 case AC_GRP_MODEM_FUNCTION:
654 * read widget caps for each widget and store in cache
656 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
661 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
663 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
666 nid = codec->start_nid;
667 for (i = 0; i < codec->num_nodes; i++, nid++)
668 codec->wcaps[i] = snd_hda_param_read(codec, nid,
669 AC_PAR_AUDIO_WIDGET_CAP);
674 static void init_hda_cache(struct hda_cache_rec *cache,
675 unsigned int record_size);
676 static void free_hda_cache(struct hda_cache_rec *cache);
681 static void snd_hda_codec_free(struct hda_codec *codec)
685 #ifdef CONFIG_SND_HDA_POWER_SAVE
686 cancel_delayed_work(&codec->power_work);
687 flush_scheduled_work();
689 list_del(&codec->list);
690 snd_array_free(&codec->mixers);
691 codec->bus->caddr_tbl[codec->addr] = NULL;
692 if (codec->patch_ops.free)
693 codec->patch_ops.free(codec);
694 module_put(codec->owner);
695 free_hda_cache(&codec->amp_cache);
696 free_hda_cache(&codec->cmd_cache);
698 kfree(codec->modelname);
704 * snd_hda_codec_new - create a HDA codec
705 * @bus: the bus to assign
706 * @codec_addr: the codec address
707 * @codecp: the pointer to store the generated codec
709 * Returns 0 if successful, or a negative error code.
711 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
712 int do_init, struct hda_codec **codecp)
714 struct hda_codec *codec;
718 if (snd_BUG_ON(!bus))
720 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
723 if (bus->caddr_tbl[codec_addr]) {
724 snd_printk(KERN_ERR "hda_codec: "
725 "address 0x%x is already occupied\n", codec_addr);
729 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
731 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
736 codec->addr = codec_addr;
737 mutex_init(&codec->spdif_mutex);
738 mutex_init(&codec->control_mutex);
739 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
740 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
741 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
742 if (codec->bus->modelname) {
743 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
744 if (!codec->modelname) {
745 snd_hda_codec_free(codec);
750 #ifdef CONFIG_SND_HDA_POWER_SAVE
751 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
752 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
753 * the caller has to power down appropriatley after initialization
756 hda_keep_power_on(codec);
759 list_add_tail(&codec->list, &bus->codec_list);
760 bus->caddr_tbl[codec_addr] = codec;
762 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
764 if (codec->vendor_id == -1)
765 /* read again, hopefully the access method was corrected
766 * in the last read...
768 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
770 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
771 AC_PAR_SUBSYSTEM_ID);
772 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
775 setup_fg_nodes(codec);
776 if (!codec->afg && !codec->mfg) {
777 snd_printdd("hda_codec: no AFG or MFG node found\n");
778 snd_hda_codec_free(codec);
782 if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) {
783 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
784 snd_hda_codec_free(codec);
788 if (!codec->subsystem_id) {
789 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
790 codec->subsystem_id =
791 snd_hda_codec_read(codec, nid, 0,
792 AC_VERB_GET_SUBSYSTEM_ID, 0);
795 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
798 err = snd_hda_codec_configure(codec);
800 snd_hda_codec_free(codec);
804 snd_hda_codec_proc_new(codec);
806 snd_hda_create_hwdep(codec);
808 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
809 codec->subsystem_id, codec->revision_id);
810 snd_component_add(codec->bus->card, component);
816 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
818 int snd_hda_codec_configure(struct hda_codec *codec)
822 codec->preset = find_codec_preset(codec);
824 err = get_codec_name(codec);
828 /* audio codec should override the mixer name */
829 if (codec->afg || !*codec->bus->card->mixername)
830 strlcpy(codec->bus->card->mixername, codec->name,
831 sizeof(codec->bus->card->mixername));
833 if (is_generic_config(codec)) {
834 err = snd_hda_parse_generic_codec(codec);
837 if (codec->preset && codec->preset->patch) {
838 err = codec->preset->patch(codec);
842 /* call the default parser */
843 err = snd_hda_parse_generic_codec(codec);
845 printk(KERN_ERR "hda-codec: No codec parser is available\n");
848 if (!err && codec->patch_ops.unsol_event)
849 err = init_unsol_queue(codec->bus);
854 * snd_hda_codec_setup_stream - set up the codec for streaming
855 * @codec: the CODEC to set up
856 * @nid: the NID to set up
857 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
858 * @channel_id: channel id to pass, zero based.
859 * @format: stream format.
861 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
863 int channel_id, int format)
868 snd_printdd("hda_codec_setup_stream: "
869 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
870 nid, stream_tag, channel_id, format);
871 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
872 (stream_tag << 4) | channel_id);
874 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
876 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
878 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
883 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
884 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
885 #if 0 /* keep the format */
887 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
890 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
893 * amp access functions
896 /* FIXME: more better hash key? */
897 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
898 #define INFO_AMP_CAPS (1<<0)
899 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
901 /* initialize the hash table */
902 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
903 unsigned int record_size)
905 memset(cache, 0, sizeof(*cache));
906 memset(cache->hash, 0xff, sizeof(cache->hash));
907 snd_array_init(&cache->buf, record_size, 64);
910 static void free_hda_cache(struct hda_cache_rec *cache)
912 snd_array_free(&cache->buf);
915 /* query the hash. allocate an entry if not found. */
916 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
919 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
920 u16 cur = cache->hash[idx];
921 struct hda_cache_head *info;
923 while (cur != 0xffff) {
924 info = snd_array_elem(&cache->buf, cur);
925 if (info->key == key)
930 /* add a new hash entry */
931 info = snd_array_new(&cache->buf);
934 cur = snd_array_index(&cache->buf, info);
937 info->next = cache->hash[idx];
938 cache->hash[idx] = cur;
943 /* query and allocate an amp hash entry */
944 static inline struct hda_amp_info *
945 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
947 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
951 * query AMP capabilities for the given widget and direction
953 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
955 struct hda_amp_info *info;
957 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
960 if (!(info->head.val & INFO_AMP_CAPS)) {
961 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
963 info->amp_caps = snd_hda_param_read(codec, nid,
964 direction == HDA_OUTPUT ?
968 info->head.val |= INFO_AMP_CAPS;
970 return info->amp_caps;
972 EXPORT_SYMBOL_HDA(query_amp_caps);
974 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
977 struct hda_amp_info *info;
979 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
982 info->amp_caps = caps;
983 info->head.val |= INFO_AMP_CAPS;
986 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
989 * read the current volume to info
990 * if the cache exists, read the cache value.
992 static unsigned int get_vol_mute(struct hda_codec *codec,
993 struct hda_amp_info *info, hda_nid_t nid,
994 int ch, int direction, int index)
998 if (info->head.val & INFO_AMP_VOL(ch))
999 return info->vol[ch];
1001 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1002 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1004 val = snd_hda_codec_read(codec, nid, 0,
1005 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1006 info->vol[ch] = val & 0xff;
1007 info->head.val |= INFO_AMP_VOL(ch);
1008 return info->vol[ch];
1012 * write the current volume in info to the h/w and update the cache
1014 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1015 hda_nid_t nid, int ch, int direction, int index,
1020 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1021 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1022 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1024 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1025 info->vol[ch] = val;
1029 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1031 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1032 int direction, int index)
1034 struct hda_amp_info *info;
1035 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1038 return get_vol_mute(codec, info, nid, ch, direction, index);
1040 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1043 * update the AMP value, mask = bit mask to set, val = the value
1045 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1046 int direction, int idx, int mask, int val)
1048 struct hda_amp_info *info;
1050 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1054 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1055 if (info->vol[ch] == val)
1057 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1060 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1063 * update the AMP stereo with the same mask and value
1065 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1066 int direction, int idx, int mask, int val)
1069 for (ch = 0; ch < 2; ch++)
1070 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1074 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1076 #ifdef SND_HDA_NEEDS_RESUME
1077 /* resume the all amp commands from the cache */
1078 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1080 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1083 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1084 u32 key = buffer->head.key;
1086 unsigned int idx, dir, ch;
1090 idx = (key >> 16) & 0xff;
1091 dir = (key >> 24) & 0xff;
1092 for (ch = 0; ch < 2; ch++) {
1093 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1095 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1100 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1101 #endif /* SND_HDA_NEEDS_RESUME */
1104 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1105 struct snd_ctl_elem_info *uinfo)
1107 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1108 u16 nid = get_amp_nid(kcontrol);
1109 u8 chs = get_amp_channels(kcontrol);
1110 int dir = get_amp_direction(kcontrol);
1113 caps = query_amp_caps(codec, nid, dir);
1115 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1117 printk(KERN_WARNING "hda_codec: "
1118 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1122 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1123 uinfo->count = chs == 3 ? 2 : 1;
1124 uinfo->value.integer.min = 0;
1125 uinfo->value.integer.max = caps;
1128 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1130 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1131 struct snd_ctl_elem_value *ucontrol)
1133 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1134 hda_nid_t nid = get_amp_nid(kcontrol);
1135 int chs = get_amp_channels(kcontrol);
1136 int dir = get_amp_direction(kcontrol);
1137 int idx = get_amp_index(kcontrol);
1138 long *valp = ucontrol->value.integer.value;
1141 *valp++ = snd_hda_codec_amp_read(codec, nid, 0, dir, idx)
1144 *valp = snd_hda_codec_amp_read(codec, nid, 1, dir, idx)
1148 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1150 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1151 struct snd_ctl_elem_value *ucontrol)
1153 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1154 hda_nid_t nid = get_amp_nid(kcontrol);
1155 int chs = get_amp_channels(kcontrol);
1156 int dir = get_amp_direction(kcontrol);
1157 int idx = get_amp_index(kcontrol);
1158 long *valp = ucontrol->value.integer.value;
1161 snd_hda_power_up(codec);
1163 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1168 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1170 snd_hda_power_down(codec);
1173 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1175 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1176 unsigned int size, unsigned int __user *_tlv)
1178 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1179 hda_nid_t nid = get_amp_nid(kcontrol);
1180 int dir = get_amp_direction(kcontrol);
1181 u32 caps, val1, val2;
1183 if (size < 4 * sizeof(unsigned int))
1185 caps = query_amp_caps(codec, nid, dir);
1186 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1187 val2 = (val2 + 1) * 25;
1188 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1189 val1 = ((int)val1) * ((int)val2);
1190 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1192 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1194 if (put_user(val1, _tlv + 2))
1196 if (put_user(val2, _tlv + 3))
1200 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1203 * set (static) TLV for virtual master volume; recalculated as max 0dB
1205 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1211 caps = query_amp_caps(codec, nid, dir);
1212 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1213 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1214 step = (step + 1) * 25;
1215 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1216 tlv[1] = 2 * sizeof(unsigned int);
1217 tlv[2] = -nums * step;
1220 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1222 /* find a mixer control element with the given name */
1223 static struct snd_kcontrol *
1224 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1225 const char *name, int idx)
1227 struct snd_ctl_elem_id id;
1228 memset(&id, 0, sizeof(id));
1229 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1231 strcpy(id.name, name);
1232 return snd_ctl_find_id(codec->bus->card, &id);
1235 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1238 return _snd_hda_find_mixer_ctl(codec, name, 0);
1240 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1242 /* Add a control element and assign to the codec */
1243 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1246 struct snd_kcontrol **knewp;
1248 err = snd_ctl_add(codec->bus->card, kctl);
1251 knewp = snd_array_new(&codec->mixers);
1257 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1259 #ifdef CONFIG_SND_HDA_RECONFIG
1260 /* Clear all controls assigned to the given codec */
1261 void snd_hda_ctls_clear(struct hda_codec *codec)
1264 struct snd_kcontrol **kctls = codec->mixers.list;
1265 for (i = 0; i < codec->mixers.used; i++)
1266 snd_ctl_remove(codec->bus->card, kctls[i]);
1267 snd_array_free(&codec->mixers);
1270 void snd_hda_codec_reset(struct hda_codec *codec)
1274 #ifdef CONFIG_SND_HDA_POWER_SAVE
1275 cancel_delayed_work(&codec->power_work);
1276 flush_scheduled_work();
1278 snd_hda_ctls_clear(codec);
1280 for (i = 0; i < codec->num_pcms; i++) {
1281 if (codec->pcm_info[i].pcm) {
1282 snd_device_free(codec->bus->card,
1283 codec->pcm_info[i].pcm);
1284 clear_bit(codec->pcm_info[i].device,
1285 codec->bus->pcm_dev_bits);
1288 if (codec->patch_ops.free)
1289 codec->patch_ops.free(codec);
1290 codec->proc_widget_hook = NULL;
1292 free_hda_cache(&codec->amp_cache);
1293 free_hda_cache(&codec->cmd_cache);
1294 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1295 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1296 codec->num_pcms = 0;
1297 codec->pcm_info = NULL;
1298 codec->preset = NULL;
1299 module_put(codec->owner);
1300 codec->owner = NULL;
1302 #endif /* CONFIG_SND_HDA_RECONFIG */
1304 /* create a virtual master control and add slaves */
1305 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1306 unsigned int *tlv, const char **slaves)
1308 struct snd_kcontrol *kctl;
1312 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1315 snd_printdd("No slave found for %s\n", name);
1318 kctl = snd_ctl_make_virtual_master(name, tlv);
1321 err = snd_hda_ctl_add(codec, kctl);
1325 for (s = slaves; *s; s++) {
1326 struct snd_kcontrol *sctl;
1328 sctl = snd_hda_find_mixer_ctl(codec, *s);
1330 snd_printdd("Cannot find slave %s, skipped\n", *s);
1333 err = snd_ctl_add_slave(kctl, sctl);
1339 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1342 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1343 struct snd_ctl_elem_info *uinfo)
1345 int chs = get_amp_channels(kcontrol);
1347 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1348 uinfo->count = chs == 3 ? 2 : 1;
1349 uinfo->value.integer.min = 0;
1350 uinfo->value.integer.max = 1;
1353 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1355 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1356 struct snd_ctl_elem_value *ucontrol)
1358 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1359 hda_nid_t nid = get_amp_nid(kcontrol);
1360 int chs = get_amp_channels(kcontrol);
1361 int dir = get_amp_direction(kcontrol);
1362 int idx = get_amp_index(kcontrol);
1363 long *valp = ucontrol->value.integer.value;
1366 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1367 HDA_AMP_MUTE) ? 0 : 1;
1369 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1370 HDA_AMP_MUTE) ? 0 : 1;
1373 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1375 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1376 struct snd_ctl_elem_value *ucontrol)
1378 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1379 hda_nid_t nid = get_amp_nid(kcontrol);
1380 int chs = get_amp_channels(kcontrol);
1381 int dir = get_amp_direction(kcontrol);
1382 int idx = get_amp_index(kcontrol);
1383 long *valp = ucontrol->value.integer.value;
1386 snd_hda_power_up(codec);
1388 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1390 *valp ? 0 : HDA_AMP_MUTE);
1394 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1396 *valp ? 0 : HDA_AMP_MUTE);
1397 #ifdef CONFIG_SND_HDA_POWER_SAVE
1398 if (codec->patch_ops.check_power_status)
1399 codec->patch_ops.check_power_status(codec, nid);
1401 snd_hda_power_down(codec);
1404 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1407 * bound volume controls
1409 * bind multiple volumes (# indices, from 0)
1412 #define AMP_VAL_IDX_SHIFT 19
1413 #define AMP_VAL_IDX_MASK (0x0f<<19)
1415 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1416 struct snd_ctl_elem_value *ucontrol)
1418 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1422 mutex_lock(&codec->control_mutex);
1423 pval = kcontrol->private_value;
1424 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1425 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1426 kcontrol->private_value = pval;
1427 mutex_unlock(&codec->control_mutex);
1430 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1432 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1433 struct snd_ctl_elem_value *ucontrol)
1435 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1437 int i, indices, err = 0, change = 0;
1439 mutex_lock(&codec->control_mutex);
1440 pval = kcontrol->private_value;
1441 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1442 for (i = 0; i < indices; i++) {
1443 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1444 (i << AMP_VAL_IDX_SHIFT);
1445 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1450 kcontrol->private_value = pval;
1451 mutex_unlock(&codec->control_mutex);
1452 return err < 0 ? err : change;
1454 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1457 * generic bound volume/swtich controls
1459 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1460 struct snd_ctl_elem_info *uinfo)
1462 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1463 struct hda_bind_ctls *c;
1466 mutex_lock(&codec->control_mutex);
1467 c = (struct hda_bind_ctls *)kcontrol->private_value;
1468 kcontrol->private_value = *c->values;
1469 err = c->ops->info(kcontrol, uinfo);
1470 kcontrol->private_value = (long)c;
1471 mutex_unlock(&codec->control_mutex);
1474 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1476 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1477 struct snd_ctl_elem_value *ucontrol)
1479 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1480 struct hda_bind_ctls *c;
1483 mutex_lock(&codec->control_mutex);
1484 c = (struct hda_bind_ctls *)kcontrol->private_value;
1485 kcontrol->private_value = *c->values;
1486 err = c->ops->get(kcontrol, ucontrol);
1487 kcontrol->private_value = (long)c;
1488 mutex_unlock(&codec->control_mutex);
1491 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1493 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1494 struct snd_ctl_elem_value *ucontrol)
1496 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1497 struct hda_bind_ctls *c;
1498 unsigned long *vals;
1499 int err = 0, change = 0;
1501 mutex_lock(&codec->control_mutex);
1502 c = (struct hda_bind_ctls *)kcontrol->private_value;
1503 for (vals = c->values; *vals; vals++) {
1504 kcontrol->private_value = *vals;
1505 err = c->ops->put(kcontrol, ucontrol);
1510 kcontrol->private_value = (long)c;
1511 mutex_unlock(&codec->control_mutex);
1512 return err < 0 ? err : change;
1514 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1516 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1517 unsigned int size, unsigned int __user *tlv)
1519 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1520 struct hda_bind_ctls *c;
1523 mutex_lock(&codec->control_mutex);
1524 c = (struct hda_bind_ctls *)kcontrol->private_value;
1525 kcontrol->private_value = *c->values;
1526 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1527 kcontrol->private_value = (long)c;
1528 mutex_unlock(&codec->control_mutex);
1531 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1533 struct hda_ctl_ops snd_hda_bind_vol = {
1534 .info = snd_hda_mixer_amp_volume_info,
1535 .get = snd_hda_mixer_amp_volume_get,
1536 .put = snd_hda_mixer_amp_volume_put,
1537 .tlv = snd_hda_mixer_amp_tlv
1539 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1541 struct hda_ctl_ops snd_hda_bind_sw = {
1542 .info = snd_hda_mixer_amp_switch_info,
1543 .get = snd_hda_mixer_amp_switch_get,
1544 .put = snd_hda_mixer_amp_switch_put,
1545 .tlv = snd_hda_mixer_amp_tlv
1547 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1550 * SPDIF out controls
1553 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1554 struct snd_ctl_elem_info *uinfo)
1556 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1561 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1562 struct snd_ctl_elem_value *ucontrol)
1564 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1565 IEC958_AES0_NONAUDIO |
1566 IEC958_AES0_CON_EMPHASIS_5015 |
1567 IEC958_AES0_CON_NOT_COPYRIGHT;
1568 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1569 IEC958_AES1_CON_ORIGINAL;
1573 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1574 struct snd_ctl_elem_value *ucontrol)
1576 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1577 IEC958_AES0_NONAUDIO |
1578 IEC958_AES0_PRO_EMPHASIS_5015;
1582 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1583 struct snd_ctl_elem_value *ucontrol)
1585 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1587 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1588 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1589 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1590 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1595 /* convert from SPDIF status bits to HDA SPDIF bits
1596 * bit 0 (DigEn) is always set zero (to be filled later)
1598 static unsigned short convert_from_spdif_status(unsigned int sbits)
1600 unsigned short val = 0;
1602 if (sbits & IEC958_AES0_PROFESSIONAL)
1603 val |= AC_DIG1_PROFESSIONAL;
1604 if (sbits & IEC958_AES0_NONAUDIO)
1605 val |= AC_DIG1_NONAUDIO;
1606 if (sbits & IEC958_AES0_PROFESSIONAL) {
1607 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1608 IEC958_AES0_PRO_EMPHASIS_5015)
1609 val |= AC_DIG1_EMPHASIS;
1611 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1612 IEC958_AES0_CON_EMPHASIS_5015)
1613 val |= AC_DIG1_EMPHASIS;
1614 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1615 val |= AC_DIG1_COPYRIGHT;
1616 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1617 val |= AC_DIG1_LEVEL;
1618 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1623 /* convert to SPDIF status bits from HDA SPDIF bits
1625 static unsigned int convert_to_spdif_status(unsigned short val)
1627 unsigned int sbits = 0;
1629 if (val & AC_DIG1_NONAUDIO)
1630 sbits |= IEC958_AES0_NONAUDIO;
1631 if (val & AC_DIG1_PROFESSIONAL)
1632 sbits |= IEC958_AES0_PROFESSIONAL;
1633 if (sbits & IEC958_AES0_PROFESSIONAL) {
1634 if (sbits & AC_DIG1_EMPHASIS)
1635 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1637 if (val & AC_DIG1_EMPHASIS)
1638 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1639 if (!(val & AC_DIG1_COPYRIGHT))
1640 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1641 if (val & AC_DIG1_LEVEL)
1642 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1643 sbits |= val & (0x7f << 8);
1648 /* set digital convert verbs both for the given NID and its slaves */
1649 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1654 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1655 d = codec->slave_dig_outs;
1659 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1662 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1666 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1668 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1671 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1672 struct snd_ctl_elem_value *ucontrol)
1674 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1675 hda_nid_t nid = kcontrol->private_value;
1679 mutex_lock(&codec->spdif_mutex);
1680 codec->spdif_status = ucontrol->value.iec958.status[0] |
1681 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1682 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1683 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1684 val = convert_from_spdif_status(codec->spdif_status);
1685 val |= codec->spdif_ctls & 1;
1686 change = codec->spdif_ctls != val;
1687 codec->spdif_ctls = val;
1690 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1692 mutex_unlock(&codec->spdif_mutex);
1696 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1698 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1699 struct snd_ctl_elem_value *ucontrol)
1701 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1703 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1707 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1708 struct snd_ctl_elem_value *ucontrol)
1710 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1711 hda_nid_t nid = kcontrol->private_value;
1715 mutex_lock(&codec->spdif_mutex);
1716 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1717 if (ucontrol->value.integer.value[0])
1718 val |= AC_DIG1_ENABLE;
1719 change = codec->spdif_ctls != val;
1721 codec->spdif_ctls = val;
1722 set_dig_out_convert(codec, nid, val & 0xff, -1);
1723 /* unmute amp switch (if any) */
1724 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1725 (val & AC_DIG1_ENABLE))
1726 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1729 mutex_unlock(&codec->spdif_mutex);
1733 static struct snd_kcontrol_new dig_mixes[] = {
1735 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1736 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1737 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1738 .info = snd_hda_spdif_mask_info,
1739 .get = snd_hda_spdif_cmask_get,
1742 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1743 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1744 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1745 .info = snd_hda_spdif_mask_info,
1746 .get = snd_hda_spdif_pmask_get,
1749 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1750 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1751 .info = snd_hda_spdif_mask_info,
1752 .get = snd_hda_spdif_default_get,
1753 .put = snd_hda_spdif_default_put,
1756 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1757 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1758 .info = snd_hda_spdif_out_switch_info,
1759 .get = snd_hda_spdif_out_switch_get,
1760 .put = snd_hda_spdif_out_switch_put,
1765 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1768 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1769 * @codec: the HDA codec
1770 * @nid: audio out widget NID
1772 * Creates controls related with the SPDIF output.
1773 * Called from each patch supporting the SPDIF out.
1775 * Returns 0 if successful, or a negative error code.
1777 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1780 struct snd_kcontrol *kctl;
1781 struct snd_kcontrol_new *dig_mix;
1784 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1785 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1789 if (idx >= SPDIF_MAX_IDX) {
1790 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1793 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1794 kctl = snd_ctl_new1(dig_mix, codec);
1797 kctl->id.index = idx;
1798 kctl->private_value = nid;
1799 err = snd_hda_ctl_add(codec, kctl);
1804 snd_hda_codec_read(codec, nid, 0,
1805 AC_VERB_GET_DIGI_CONVERT_1, 0);
1806 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1809 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1812 * SPDIF sharing with analog output
1814 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1815 struct snd_ctl_elem_value *ucontrol)
1817 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1818 ucontrol->value.integer.value[0] = mout->share_spdif;
1822 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1823 struct snd_ctl_elem_value *ucontrol)
1825 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1826 mout->share_spdif = !!ucontrol->value.integer.value[0];
1830 static struct snd_kcontrol_new spdif_share_sw = {
1831 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1832 .name = "IEC958 Default PCM Playback Switch",
1833 .info = snd_ctl_boolean_mono_info,
1834 .get = spdif_share_sw_get,
1835 .put = spdif_share_sw_put,
1838 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
1839 struct hda_multi_out *mout)
1841 if (!mout->dig_out_nid)
1843 /* ATTENTION: here mout is passed as private_data, instead of codec */
1844 return snd_hda_ctl_add(codec,
1845 snd_ctl_new1(&spdif_share_sw, mout));
1847 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
1853 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
1855 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
1856 struct snd_ctl_elem_value *ucontrol)
1858 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1860 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
1864 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
1865 struct snd_ctl_elem_value *ucontrol)
1867 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1868 hda_nid_t nid = kcontrol->private_value;
1869 unsigned int val = !!ucontrol->value.integer.value[0];
1872 mutex_lock(&codec->spdif_mutex);
1873 change = codec->spdif_in_enable != val;
1875 codec->spdif_in_enable = val;
1876 snd_hda_codec_write_cache(codec, nid, 0,
1877 AC_VERB_SET_DIGI_CONVERT_1, val);
1879 mutex_unlock(&codec->spdif_mutex);
1883 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
1884 struct snd_ctl_elem_value *ucontrol)
1886 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1887 hda_nid_t nid = kcontrol->private_value;
1891 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1892 sbits = convert_to_spdif_status(val);
1893 ucontrol->value.iec958.status[0] = sbits;
1894 ucontrol->value.iec958.status[1] = sbits >> 8;
1895 ucontrol->value.iec958.status[2] = sbits >> 16;
1896 ucontrol->value.iec958.status[3] = sbits >> 24;
1900 static struct snd_kcontrol_new dig_in_ctls[] = {
1902 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1903 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
1904 .info = snd_hda_spdif_in_switch_info,
1905 .get = snd_hda_spdif_in_switch_get,
1906 .put = snd_hda_spdif_in_switch_put,
1909 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1910 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1911 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1912 .info = snd_hda_spdif_mask_info,
1913 .get = snd_hda_spdif_in_status_get,
1919 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1920 * @codec: the HDA codec
1921 * @nid: audio in widget NID
1923 * Creates controls related with the SPDIF input.
1924 * Called from each patch supporting the SPDIF in.
1926 * Returns 0 if successful, or a negative error code.
1928 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1931 struct snd_kcontrol *kctl;
1932 struct snd_kcontrol_new *dig_mix;
1935 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1936 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
1940 if (idx >= SPDIF_MAX_IDX) {
1941 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
1944 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
1945 kctl = snd_ctl_new1(dig_mix, codec);
1946 kctl->private_value = nid;
1947 err = snd_hda_ctl_add(codec, kctl);
1951 codec->spdif_in_enable =
1952 snd_hda_codec_read(codec, nid, 0,
1953 AC_VERB_GET_DIGI_CONVERT_1, 0) &
1957 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
1959 #ifdef SND_HDA_NEEDS_RESUME
1964 /* build a 32bit cache key with the widget id and the command parameter */
1965 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
1966 #define get_cmd_cache_nid(key) ((key) & 0xff)
1967 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
1970 * snd_hda_codec_write_cache - send a single command with caching
1971 * @codec: the HDA codec
1972 * @nid: NID to send the command
1973 * @direct: direct flag
1974 * @verb: the verb to send
1975 * @parm: the parameter for the verb
1977 * Send a single command without waiting for response.
1979 * Returns 0 if successful, or a negative error code.
1981 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
1982 int direct, unsigned int verb, unsigned int parm)
1984 struct hda_bus *bus = codec->bus;
1988 res = make_codec_cmd(codec, nid, direct, verb, parm);
1989 snd_hda_power_up(codec);
1990 mutex_lock(&bus->cmd_mutex);
1991 err = bus->ops.command(bus, res);
1993 struct hda_cache_head *c;
1994 u32 key = build_cmd_cache_key(nid, verb);
1995 c = get_alloc_hash(&codec->cmd_cache, key);
1999 mutex_unlock(&bus->cmd_mutex);
2000 snd_hda_power_down(codec);
2003 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2005 /* resume the all commands from the cache */
2006 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2008 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2011 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2012 u32 key = buffer->key;
2015 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2016 get_cmd_cache_cmd(key), buffer->val);
2019 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2022 * snd_hda_sequence_write_cache - sequence writes with caching
2023 * @codec: the HDA codec
2024 * @seq: VERB array to send
2026 * Send the commands sequentially from the given array.
2027 * Thte commands are recorded on cache for power-save and resume.
2028 * The array must be terminated with NID=0.
2030 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2031 const struct hda_verb *seq)
2033 for (; seq->nid; seq++)
2034 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2037 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2038 #endif /* SND_HDA_NEEDS_RESUME */
2041 * set power state of the codec
2043 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2044 unsigned int power_state)
2049 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2051 msleep(10); /* partial workaround for "azx_get_response timeout" */
2053 nid = codec->start_nid;
2054 for (i = 0; i < codec->num_nodes; i++, nid++) {
2055 unsigned int wcaps = get_wcaps(codec, nid);
2056 if (wcaps & AC_WCAP_POWER) {
2057 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2059 if (wid_type == AC_WID_PIN) {
2060 unsigned int pincap;
2062 * don't power down the widget if it controls
2063 * eapd and EAPD_BTLENABLE is set.
2065 pincap = snd_hda_param_read(codec, nid,
2067 if (pincap & AC_PINCAP_EAPD) {
2068 int eapd = snd_hda_codec_read(codec,
2070 AC_VERB_GET_EAPD_BTLENABLE, 0);
2072 if (power_state == AC_PWRST_D3 && eapd)
2076 snd_hda_codec_write(codec, nid, 0,
2077 AC_VERB_SET_POWER_STATE,
2082 if (power_state == AC_PWRST_D0) {
2083 unsigned long end_time;
2086 /* wait until the codec reachs to D0 */
2087 end_time = jiffies + msecs_to_jiffies(500);
2089 state = snd_hda_codec_read(codec, fg, 0,
2090 AC_VERB_GET_POWER_STATE, 0);
2091 if (state == power_state)
2094 } while (time_after_eq(end_time, jiffies));
2098 #ifdef CONFIG_SND_HDA_HWDEP
2099 /* execute additional init verbs */
2100 static void hda_exec_init_verbs(struct hda_codec *codec)
2102 if (codec->init_verbs.list)
2103 snd_hda_sequence_write(codec, codec->init_verbs.list);
2106 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2109 #ifdef SND_HDA_NEEDS_RESUME
2111 * call suspend and power-down; used both from PM and power-save
2113 static void hda_call_codec_suspend(struct hda_codec *codec)
2115 if (codec->patch_ops.suspend)
2116 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2117 hda_set_power_state(codec,
2118 codec->afg ? codec->afg : codec->mfg,
2120 #ifdef CONFIG_SND_HDA_POWER_SAVE
2121 cancel_delayed_work(&codec->power_work);
2122 codec->power_on = 0;
2123 codec->power_transition = 0;
2128 * kick up codec; used both from PM and power-save
2130 static void hda_call_codec_resume(struct hda_codec *codec)
2132 hda_set_power_state(codec,
2133 codec->afg ? codec->afg : codec->mfg,
2135 hda_exec_init_verbs(codec);
2136 if (codec->patch_ops.resume)
2137 codec->patch_ops.resume(codec);
2139 if (codec->patch_ops.init)
2140 codec->patch_ops.init(codec);
2141 snd_hda_codec_resume_amp(codec);
2142 snd_hda_codec_resume_cache(codec);
2145 #endif /* SND_HDA_NEEDS_RESUME */
2149 * snd_hda_build_controls - build mixer controls
2152 * Creates mixer controls for each codec included in the bus.
2154 * Returns 0 if successful, otherwise a negative error code.
2156 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2158 struct hda_codec *codec;
2160 list_for_each_entry(codec, &bus->codec_list, list) {
2161 int err = snd_hda_codec_build_controls(codec);
2167 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2169 int snd_hda_codec_build_controls(struct hda_codec *codec)
2172 /* fake as if already powered-on */
2173 hda_keep_power_on(codec);
2175 hda_set_power_state(codec,
2176 codec->afg ? codec->afg : codec->mfg,
2178 hda_exec_init_verbs(codec);
2179 /* continue to initialize... */
2180 if (codec->patch_ops.init)
2181 err = codec->patch_ops.init(codec);
2182 if (!err && codec->patch_ops.build_controls)
2183 err = codec->patch_ops.build_controls(codec);
2184 snd_hda_power_down(codec);
2193 struct hda_rate_tbl {
2195 unsigned int alsa_bits;
2196 unsigned int hda_fmt;
2199 static struct hda_rate_tbl rate_bits[] = {
2200 /* rate in Hz, ALSA rate bitmask, HDA format value */
2202 /* autodetected value used in snd_hda_query_supported_pcm */
2203 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2204 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2205 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2206 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2207 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2208 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2209 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2210 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2211 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2212 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2213 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2214 #define AC_PAR_PCM_RATE_BITS 11
2215 /* up to bits 10, 384kHZ isn't supported properly */
2217 /* not autodetected value */
2218 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2220 { 0 } /* terminator */
2224 * snd_hda_calc_stream_format - calculate format bitset
2225 * @rate: the sample rate
2226 * @channels: the number of channels
2227 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2228 * @maxbps: the max. bps
2230 * Calculate the format bitset from the given rate, channels and th PCM format.
2232 * Return zero if invalid.
2234 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2235 unsigned int channels,
2236 unsigned int format,
2237 unsigned int maxbps)
2240 unsigned int val = 0;
2242 for (i = 0; rate_bits[i].hz; i++)
2243 if (rate_bits[i].hz == rate) {
2244 val = rate_bits[i].hda_fmt;
2247 if (!rate_bits[i].hz) {
2248 snd_printdd("invalid rate %d\n", rate);
2252 if (channels == 0 || channels > 8) {
2253 snd_printdd("invalid channels %d\n", channels);
2256 val |= channels - 1;
2258 switch (snd_pcm_format_width(format)) {
2259 case 8: val |= 0x00; break;
2260 case 16: val |= 0x10; break;
2266 else if (maxbps >= 24)
2272 snd_printdd("invalid format width %d\n",
2273 snd_pcm_format_width(format));
2279 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2282 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2283 * @codec: the HDA codec
2284 * @nid: NID to query
2285 * @ratesp: the pointer to store the detected rate bitflags
2286 * @formatsp: the pointer to store the detected formats
2287 * @bpsp: the pointer to store the detected format widths
2289 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2290 * or @bsps argument is ignored.
2292 * Returns 0 if successful, otherwise a negative error code.
2294 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2295 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2298 unsigned int val, streams;
2301 if (nid != codec->afg &&
2302 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2303 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2308 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2312 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2314 rates |= rate_bits[i].alsa_bits;
2319 if (formatsp || bpsp) {
2324 wcaps = get_wcaps(codec, nid);
2325 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2329 streams = snd_hda_param_read(codec, codec->afg,
2336 if (streams & AC_SUPFMT_PCM) {
2337 if (val & AC_SUPPCM_BITS_8) {
2338 formats |= SNDRV_PCM_FMTBIT_U8;
2341 if (val & AC_SUPPCM_BITS_16) {
2342 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2345 if (wcaps & AC_WCAP_DIGITAL) {
2346 if (val & AC_SUPPCM_BITS_32)
2347 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2348 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2349 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2350 if (val & AC_SUPPCM_BITS_24)
2352 else if (val & AC_SUPPCM_BITS_20)
2354 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2355 AC_SUPPCM_BITS_32)) {
2356 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2357 if (val & AC_SUPPCM_BITS_32)
2359 else if (val & AC_SUPPCM_BITS_24)
2361 else if (val & AC_SUPPCM_BITS_20)
2365 else if (streams == AC_SUPFMT_FLOAT32) {
2366 /* should be exclusive */
2367 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2369 } else if (streams == AC_SUPFMT_AC3) {
2370 /* should be exclusive */
2371 /* temporary hack: we have still no proper support
2372 * for the direct AC3 stream...
2374 formats |= SNDRV_PCM_FMTBIT_U8;
2378 *formatsp = formats;
2387 * snd_hda_is_supported_format - check whether the given node supports
2390 * Returns 1 if supported, 0 if not.
2392 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2393 unsigned int format)
2396 unsigned int val = 0, rate, stream;
2398 if (nid != codec->afg &&
2399 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2400 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2405 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2410 rate = format & 0xff00;
2411 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2412 if (rate_bits[i].hda_fmt == rate) {
2417 if (i >= AC_PAR_PCM_RATE_BITS)
2420 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2423 if (!stream && nid != codec->afg)
2424 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2425 if (!stream || stream == -1)
2428 if (stream & AC_SUPFMT_PCM) {
2429 switch (format & 0xf0) {
2431 if (!(val & AC_SUPPCM_BITS_8))
2435 if (!(val & AC_SUPPCM_BITS_16))
2439 if (!(val & AC_SUPPCM_BITS_20))
2443 if (!(val & AC_SUPPCM_BITS_24))
2447 if (!(val & AC_SUPPCM_BITS_32))
2454 /* FIXME: check for float32 and AC3? */
2459 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2464 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2465 struct hda_codec *codec,
2466 struct snd_pcm_substream *substream)
2471 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2472 struct hda_codec *codec,
2473 unsigned int stream_tag,
2474 unsigned int format,
2475 struct snd_pcm_substream *substream)
2477 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2481 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2482 struct hda_codec *codec,
2483 struct snd_pcm_substream *substream)
2485 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2489 static int set_pcm_default_values(struct hda_codec *codec,
2490 struct hda_pcm_stream *info)
2492 /* query support PCM information from the given NID */
2493 if (info->nid && (!info->rates || !info->formats)) {
2494 snd_hda_query_supported_pcm(codec, info->nid,
2495 info->rates ? NULL : &info->rates,
2496 info->formats ? NULL : &info->formats,
2497 info->maxbps ? NULL : &info->maxbps);
2499 if (info->ops.open == NULL)
2500 info->ops.open = hda_pcm_default_open_close;
2501 if (info->ops.close == NULL)
2502 info->ops.close = hda_pcm_default_open_close;
2503 if (info->ops.prepare == NULL) {
2504 if (snd_BUG_ON(!info->nid))
2506 info->ops.prepare = hda_pcm_default_prepare;
2508 if (info->ops.cleanup == NULL) {
2509 if (snd_BUG_ON(!info->nid))
2511 info->ops.cleanup = hda_pcm_default_cleanup;
2517 * get the empty PCM device number to assign
2519 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2521 static const char *dev_name[HDA_PCM_NTYPES] = {
2522 "Audio", "SPDIF", "HDMI", "Modem"
2524 /* starting device index for each PCM type */
2525 static int dev_idx[HDA_PCM_NTYPES] = {
2526 [HDA_PCM_TYPE_AUDIO] = 0,
2527 [HDA_PCM_TYPE_SPDIF] = 1,
2528 [HDA_PCM_TYPE_HDMI] = 3,
2529 [HDA_PCM_TYPE_MODEM] = 6
2531 /* normal audio device indices; not linear to keep compatibility */
2532 static int audio_idx[4] = { 0, 2, 4, 5 };
2536 case HDA_PCM_TYPE_AUDIO:
2537 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2539 if (!test_bit(dev, bus->pcm_dev_bits))
2542 if (i >= ARRAY_SIZE(audio_idx)) {
2543 snd_printk(KERN_WARNING "Too many audio devices\n");
2547 case HDA_PCM_TYPE_SPDIF:
2548 case HDA_PCM_TYPE_HDMI:
2549 case HDA_PCM_TYPE_MODEM:
2550 dev = dev_idx[type];
2551 if (test_bit(dev, bus->pcm_dev_bits)) {
2552 snd_printk(KERN_WARNING "%s already defined\n",
2558 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2561 set_bit(dev, bus->pcm_dev_bits);
2566 * attach a new PCM stream
2568 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2570 struct hda_bus *bus = codec->bus;
2571 struct hda_pcm_stream *info;
2574 if (snd_BUG_ON(!pcm->name))
2576 for (stream = 0; stream < 2; stream++) {
2577 info = &pcm->stream[stream];
2578 if (info->substreams) {
2579 err = set_pcm_default_values(codec, info);
2584 return bus->ops.attach_pcm(bus, codec, pcm);
2587 /* assign all PCMs of the given codec */
2588 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2593 if (!codec->num_pcms) {
2594 if (!codec->patch_ops.build_pcms)
2596 err = codec->patch_ops.build_pcms(codec);
2600 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2601 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2604 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2605 return 0; /* no substreams assigned */
2608 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2612 err = snd_hda_attach_pcm(codec, cpcm);
2621 * snd_hda_build_pcms - build PCM information
2624 * Create PCM information for each codec included in the bus.
2626 * The build_pcms codec patch is requested to set up codec->num_pcms and
2627 * codec->pcm_info properly. The array is referred by the top-level driver
2628 * to create its PCM instances.
2629 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2632 * At least, substreams, channels_min and channels_max must be filled for
2633 * each stream. substreams = 0 indicates that the stream doesn't exist.
2634 * When rates and/or formats are zero, the supported values are queried
2635 * from the given nid. The nid is used also by the default ops.prepare
2636 * and ops.cleanup callbacks.
2638 * The driver needs to call ops.open in its open callback. Similarly,
2639 * ops.close is supposed to be called in the close callback.
2640 * ops.prepare should be called in the prepare or hw_params callback
2641 * with the proper parameters for set up.
2642 * ops.cleanup should be called in hw_free for clean up of streams.
2644 * This function returns 0 if successfull, or a negative error code.
2646 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2648 struct hda_codec *codec;
2650 list_for_each_entry(codec, &bus->codec_list, list) {
2651 int err = snd_hda_codec_build_pcms(codec);
2657 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2660 * snd_hda_check_board_config - compare the current codec with the config table
2661 * @codec: the HDA codec
2662 * @num_configs: number of config enums
2663 * @models: array of model name strings
2664 * @tbl: configuration table, terminated by null entries
2666 * Compares the modelname or PCI subsystem id of the current codec with the
2667 * given configuration table. If a matching entry is found, returns its
2668 * config value (supposed to be 0 or positive).
2670 * If no entries are matching, the function returns a negative value.
2672 int snd_hda_check_board_config(struct hda_codec *codec,
2673 int num_configs, const char **models,
2674 const struct snd_pci_quirk *tbl)
2676 if (codec->modelname && models) {
2678 for (i = 0; i < num_configs; i++) {
2680 !strcmp(codec->modelname, models[i])) {
2681 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2682 "selected\n", models[i]);
2688 if (!codec->bus->pci || !tbl)
2691 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2694 if (tbl->value >= 0 && tbl->value < num_configs) {
2695 #ifdef CONFIG_SND_DEBUG_VERBOSE
2697 const char *model = NULL;
2699 model = models[tbl->value];
2701 sprintf(tmp, "#%d", tbl->value);
2704 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2705 "for config %x:%x (%s)\n",
2706 model, tbl->subvendor, tbl->subdevice,
2707 (tbl->name ? tbl->name : "Unknown device"));
2713 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
2716 * snd_hda_add_new_ctls - create controls from the array
2717 * @codec: the HDA codec
2718 * @knew: the array of struct snd_kcontrol_new
2720 * This helper function creates and add new controls in the given array.
2721 * The array must be terminated with an empty entry as terminator.
2723 * Returns 0 if successful, or a negative error code.
2725 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
2729 for (; knew->name; knew++) {
2730 struct snd_kcontrol *kctl;
2731 kctl = snd_ctl_new1(knew, codec);
2734 err = snd_hda_ctl_add(codec, kctl);
2738 kctl = snd_ctl_new1(knew, codec);
2741 kctl->id.device = codec->addr;
2742 err = snd_hda_ctl_add(codec, kctl);
2749 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
2751 #ifdef CONFIG_SND_HDA_POWER_SAVE
2752 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2753 unsigned int power_state);
2755 static void hda_power_work(struct work_struct *work)
2757 struct hda_codec *codec =
2758 container_of(work, struct hda_codec, power_work.work);
2759 struct hda_bus *bus = codec->bus;
2761 if (!codec->power_on || codec->power_count) {
2762 codec->power_transition = 0;
2766 hda_call_codec_suspend(codec);
2767 if (bus->ops.pm_notify)
2768 bus->ops.pm_notify(bus);
2771 static void hda_keep_power_on(struct hda_codec *codec)
2773 codec->power_count++;
2774 codec->power_on = 1;
2777 void snd_hda_power_up(struct hda_codec *codec)
2779 struct hda_bus *bus = codec->bus;
2781 codec->power_count++;
2782 if (codec->power_on || codec->power_transition)
2785 codec->power_on = 1;
2786 if (bus->ops.pm_notify)
2787 bus->ops.pm_notify(bus);
2788 hda_call_codec_resume(codec);
2789 cancel_delayed_work(&codec->power_work);
2790 codec->power_transition = 0;
2792 EXPORT_SYMBOL_HDA(snd_hda_power_up);
2794 #define power_save(codec) \
2795 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2797 #define power_save(codec) \
2798 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2800 void snd_hda_power_down(struct hda_codec *codec)
2802 --codec->power_count;
2803 if (!codec->power_on || codec->power_count || codec->power_transition)
2805 if (power_save(codec)) {
2806 codec->power_transition = 1; /* avoid reentrance */
2807 schedule_delayed_work(&codec->power_work,
2808 msecs_to_jiffies(power_save(codec) * 1000));
2811 EXPORT_SYMBOL_HDA(snd_hda_power_down);
2813 int snd_hda_check_amp_list_power(struct hda_codec *codec,
2814 struct hda_loopback_check *check,
2817 struct hda_amp_list *p;
2820 if (!check->amplist)
2822 for (p = check->amplist; p->nid; p++) {
2827 return 0; /* nothing changed */
2829 for (p = check->amplist; p->nid; p++) {
2830 for (ch = 0; ch < 2; ch++) {
2831 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
2833 if (!(v & HDA_AMP_MUTE) && v > 0) {
2834 if (!check->power_on) {
2835 check->power_on = 1;
2836 snd_hda_power_up(codec);
2842 if (check->power_on) {
2843 check->power_on = 0;
2844 snd_hda_power_down(codec);
2848 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
2852 * Channel mode helper
2854 int snd_hda_ch_mode_info(struct hda_codec *codec,
2855 struct snd_ctl_elem_info *uinfo,
2856 const struct hda_channel_mode *chmode,
2859 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2861 uinfo->value.enumerated.items = num_chmodes;
2862 if (uinfo->value.enumerated.item >= num_chmodes)
2863 uinfo->value.enumerated.item = num_chmodes - 1;
2864 sprintf(uinfo->value.enumerated.name, "%dch",
2865 chmode[uinfo->value.enumerated.item].channels);
2868 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
2870 int snd_hda_ch_mode_get(struct hda_codec *codec,
2871 struct snd_ctl_elem_value *ucontrol,
2872 const struct hda_channel_mode *chmode,
2878 for (i = 0; i < num_chmodes; i++) {
2879 if (max_channels == chmode[i].channels) {
2880 ucontrol->value.enumerated.item[0] = i;
2886 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
2888 int snd_hda_ch_mode_put(struct hda_codec *codec,
2889 struct snd_ctl_elem_value *ucontrol,
2890 const struct hda_channel_mode *chmode,
2896 mode = ucontrol->value.enumerated.item[0];
2897 if (mode >= num_chmodes)
2899 if (*max_channelsp == chmode[mode].channels)
2901 /* change the current channel setting */
2902 *max_channelsp = chmode[mode].channels;
2903 if (chmode[mode].sequence)
2904 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
2907 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
2912 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
2913 struct snd_ctl_elem_info *uinfo)
2917 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2919 uinfo->value.enumerated.items = imux->num_items;
2920 if (!imux->num_items)
2922 index = uinfo->value.enumerated.item;
2923 if (index >= imux->num_items)
2924 index = imux->num_items - 1;
2925 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
2928 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
2930 int snd_hda_input_mux_put(struct hda_codec *codec,
2931 const struct hda_input_mux *imux,
2932 struct snd_ctl_elem_value *ucontrol,
2934 unsigned int *cur_val)
2938 if (!imux->num_items)
2940 idx = ucontrol->value.enumerated.item[0];
2941 if (idx >= imux->num_items)
2942 idx = imux->num_items - 1;
2943 if (*cur_val == idx)
2945 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
2946 imux->items[idx].index);
2950 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
2954 * Multi-channel / digital-out PCM helper functions
2957 /* setup SPDIF output stream */
2958 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
2959 unsigned int stream_tag, unsigned int format)
2961 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
2962 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2963 set_dig_out_convert(codec, nid,
2964 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
2966 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2967 if (codec->slave_dig_outs) {
2969 for (d = codec->slave_dig_outs; *d; d++)
2970 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
2973 /* turn on again (if needed) */
2974 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2975 set_dig_out_convert(codec, nid,
2976 codec->spdif_ctls & 0xff, -1);
2979 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
2981 snd_hda_codec_cleanup_stream(codec, nid);
2982 if (codec->slave_dig_outs) {
2984 for (d = codec->slave_dig_outs; *d; d++)
2985 snd_hda_codec_cleanup_stream(codec, *d);
2990 * open the digital out in the exclusive mode
2992 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
2993 struct hda_multi_out *mout)
2995 mutex_lock(&codec->spdif_mutex);
2996 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
2997 /* already opened as analog dup; reset it once */
2998 cleanup_dig_out_stream(codec, mout->dig_out_nid);
2999 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3000 mutex_unlock(&codec->spdif_mutex);
3003 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3005 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3006 struct hda_multi_out *mout,
3007 unsigned int stream_tag,
3008 unsigned int format,
3009 struct snd_pcm_substream *substream)
3011 mutex_lock(&codec->spdif_mutex);
3012 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3013 mutex_unlock(&codec->spdif_mutex);
3016 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3019 * release the digital out
3021 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3022 struct hda_multi_out *mout)
3024 mutex_lock(&codec->spdif_mutex);
3025 mout->dig_out_used = 0;
3026 mutex_unlock(&codec->spdif_mutex);
3029 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3032 * set up more restrictions for analog out
3034 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3035 struct hda_multi_out *mout,
3036 struct snd_pcm_substream *substream,
3037 struct hda_pcm_stream *hinfo)
3039 struct snd_pcm_runtime *runtime = substream->runtime;
3040 runtime->hw.channels_max = mout->max_channels;
3041 if (mout->dig_out_nid) {
3042 if (!mout->analog_rates) {
3043 mout->analog_rates = hinfo->rates;
3044 mout->analog_formats = hinfo->formats;
3045 mout->analog_maxbps = hinfo->maxbps;
3047 runtime->hw.rates = mout->analog_rates;
3048 runtime->hw.formats = mout->analog_formats;
3049 hinfo->maxbps = mout->analog_maxbps;
3051 if (!mout->spdif_rates) {
3052 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3054 &mout->spdif_formats,
3055 &mout->spdif_maxbps);
3057 mutex_lock(&codec->spdif_mutex);
3058 if (mout->share_spdif) {
3059 runtime->hw.rates &= mout->spdif_rates;
3060 runtime->hw.formats &= mout->spdif_formats;
3061 if (mout->spdif_maxbps < hinfo->maxbps)
3062 hinfo->maxbps = mout->spdif_maxbps;
3064 mutex_unlock(&codec->spdif_mutex);
3066 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3067 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3069 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3072 * set up the i/o for analog out
3073 * when the digital out is available, copy the front out to digital out, too.
3075 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3076 struct hda_multi_out *mout,
3077 unsigned int stream_tag,
3078 unsigned int format,
3079 struct snd_pcm_substream *substream)
3081 hda_nid_t *nids = mout->dac_nids;
3082 int chs = substream->runtime->channels;
3085 mutex_lock(&codec->spdif_mutex);
3086 if (mout->dig_out_nid && mout->share_spdif &&
3087 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3089 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3091 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3092 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3093 setup_dig_out_stream(codec, mout->dig_out_nid,
3094 stream_tag, format);
3096 mout->dig_out_used = 0;
3097 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3100 mutex_unlock(&codec->spdif_mutex);
3103 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3105 if (!mout->no_share_stream &&
3106 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3107 /* headphone out will just decode front left/right (stereo) */
3108 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3110 /* extra outputs copied from front */
3111 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3112 if (!mout->no_share_stream && mout->extra_out_nid[i])
3113 snd_hda_codec_setup_stream(codec,
3114 mout->extra_out_nid[i],
3115 stream_tag, 0, format);
3118 for (i = 1; i < mout->num_dacs; i++) {
3119 if (chs >= (i + 1) * 2) /* independent out */
3120 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3122 else if (!mout->no_share_stream) /* copy front */
3123 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3128 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3131 * clean up the setting for analog out
3133 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3134 struct hda_multi_out *mout)
3136 hda_nid_t *nids = mout->dac_nids;
3139 for (i = 0; i < mout->num_dacs; i++)
3140 snd_hda_codec_cleanup_stream(codec, nids[i]);
3142 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3143 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3144 if (mout->extra_out_nid[i])
3145 snd_hda_codec_cleanup_stream(codec,
3146 mout->extra_out_nid[i]);
3147 mutex_lock(&codec->spdif_mutex);
3148 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3149 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3150 mout->dig_out_used = 0;
3152 mutex_unlock(&codec->spdif_mutex);
3155 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3158 * Helper for automatic pin configuration
3161 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3163 for (; *list; list++)
3171 * Sort an associated group of pins according to their sequence numbers.
3173 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3180 for (i = 0; i < num_pins; i++) {
3181 for (j = i + 1; j < num_pins; j++) {
3182 if (sequences[i] > sequences[j]) {
3184 sequences[i] = sequences[j];
3196 * Parse all pin widgets and store the useful pin nids to cfg
3198 * The number of line-outs or any primary output is stored in line_outs,
3199 * and the corresponding output pins are assigned to line_out_pins[],
3200 * in the order of front, rear, CLFE, side, ...
3202 * If more extra outputs (speaker and headphone) are found, the pins are
3203 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3204 * is detected, one of speaker of HP pins is assigned as the primary
3205 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3206 * if any analog output exists.
3208 * The analog input pins are assigned to input_pins array.
3209 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3212 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3213 struct auto_pin_cfg *cfg,
3214 hda_nid_t *ignore_nids)
3216 hda_nid_t nid, end_nid;
3217 short seq, assoc_line_out, assoc_speaker;
3218 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3219 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3220 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3222 memset(cfg, 0, sizeof(*cfg));
3224 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3225 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3226 memset(sequences_hp, 0, sizeof(sequences_hp));
3227 assoc_line_out = assoc_speaker = 0;
3229 end_nid = codec->start_nid + codec->num_nodes;
3230 for (nid = codec->start_nid; nid < end_nid; nid++) {
3231 unsigned int wid_caps = get_wcaps(codec, nid);
3232 unsigned int wid_type =
3233 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3234 unsigned int def_conf;
3237 /* read all default configuration for pin complex */
3238 if (wid_type != AC_WID_PIN)
3240 /* ignore the given nids (e.g. pc-beep returns error) */
3241 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3244 def_conf = snd_hda_codec_read(codec, nid, 0,
3245 AC_VERB_GET_CONFIG_DEFAULT, 0);
3246 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3248 loc = get_defcfg_location(def_conf);
3249 switch (get_defcfg_device(def_conf)) {
3250 case AC_JACK_LINE_OUT:
3251 seq = get_defcfg_sequence(def_conf);
3252 assoc = get_defcfg_association(def_conf);
3254 if (!(wid_caps & AC_WCAP_STEREO))
3255 if (!cfg->mono_out_pin)
3256 cfg->mono_out_pin = nid;
3259 if (!assoc_line_out)
3260 assoc_line_out = assoc;
3261 else if (assoc_line_out != assoc)
3263 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3265 cfg->line_out_pins[cfg->line_outs] = nid;
3266 sequences_line_out[cfg->line_outs] = seq;
3269 case AC_JACK_SPEAKER:
3270 seq = get_defcfg_sequence(def_conf);
3271 assoc = get_defcfg_association(def_conf);
3274 if (! assoc_speaker)
3275 assoc_speaker = assoc;
3276 else if (assoc_speaker != assoc)
3278 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3280 cfg->speaker_pins[cfg->speaker_outs] = nid;
3281 sequences_speaker[cfg->speaker_outs] = seq;
3282 cfg->speaker_outs++;
3284 case AC_JACK_HP_OUT:
3285 seq = get_defcfg_sequence(def_conf);
3286 assoc = get_defcfg_association(def_conf);
3287 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3289 cfg->hp_pins[cfg->hp_outs] = nid;
3290 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3293 case AC_JACK_MIC_IN: {
3295 if (loc == AC_JACK_LOC_FRONT) {
3296 preferred = AUTO_PIN_FRONT_MIC;
3299 preferred = AUTO_PIN_MIC;
3300 alt = AUTO_PIN_FRONT_MIC;
3302 if (!cfg->input_pins[preferred])
3303 cfg->input_pins[preferred] = nid;
3304 else if (!cfg->input_pins[alt])
3305 cfg->input_pins[alt] = nid;
3308 case AC_JACK_LINE_IN:
3309 if (loc == AC_JACK_LOC_FRONT)
3310 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3312 cfg->input_pins[AUTO_PIN_LINE] = nid;
3315 cfg->input_pins[AUTO_PIN_CD] = nid;
3318 cfg->input_pins[AUTO_PIN_AUX] = nid;
3320 case AC_JACK_SPDIF_OUT:
3321 cfg->dig_out_pin = nid;
3323 case AC_JACK_SPDIF_IN:
3324 cfg->dig_in_pin = nid;
3330 * If no line-out is defined but multiple HPs are found,
3331 * some of them might be the real line-outs.
3333 if (!cfg->line_outs && cfg->hp_outs > 1) {
3335 while (i < cfg->hp_outs) {
3336 /* The real HPs should have the sequence 0x0f */
3337 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3341 /* Move it to the line-out table */
3342 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3343 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3346 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3347 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3348 memmove(sequences_hp + i - 1, sequences_hp + i,
3349 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3353 /* sort by sequence */
3354 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3356 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3358 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3361 /* if we have only one mic, make it AUTO_PIN_MIC */
3362 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3363 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3364 cfg->input_pins[AUTO_PIN_MIC] =
3365 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3366 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3368 /* ditto for line-in */
3369 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3370 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3371 cfg->input_pins[AUTO_PIN_LINE] =
3372 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3373 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3377 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3378 * as a primary output
3380 if (!cfg->line_outs) {
3381 if (cfg->speaker_outs) {
3382 cfg->line_outs = cfg->speaker_outs;
3383 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3384 sizeof(cfg->speaker_pins));
3385 cfg->speaker_outs = 0;
3386 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3387 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3388 } else if (cfg->hp_outs) {
3389 cfg->line_outs = cfg->hp_outs;
3390 memcpy(cfg->line_out_pins, cfg->hp_pins,
3391 sizeof(cfg->hp_pins));
3393 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3394 cfg->line_out_type = AUTO_PIN_HP_OUT;
3398 /* Reorder the surround channels
3399 * ALSA sequence is front/surr/clfe/side
3401 * 4-ch: front/surr => OK as it is
3402 * 6-ch: front/clfe/surr
3403 * 8-ch: front/clfe/rear/side|fc
3405 switch (cfg->line_outs) {
3408 nid = cfg->line_out_pins[1];
3409 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3410 cfg->line_out_pins[2] = nid;
3415 * debug prints of the parsed results
3417 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3418 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3419 cfg->line_out_pins[2], cfg->line_out_pins[3],
3420 cfg->line_out_pins[4]);
3421 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3422 cfg->speaker_outs, cfg->speaker_pins[0],
3423 cfg->speaker_pins[1], cfg->speaker_pins[2],
3424 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3425 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3426 cfg->hp_outs, cfg->hp_pins[0],
3427 cfg->hp_pins[1], cfg->hp_pins[2],
3428 cfg->hp_pins[3], cfg->hp_pins[4]);
3429 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3430 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3431 " cd=0x%x, aux=0x%x\n",
3432 cfg->input_pins[AUTO_PIN_MIC],
3433 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3434 cfg->input_pins[AUTO_PIN_LINE],
3435 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3436 cfg->input_pins[AUTO_PIN_CD],
3437 cfg->input_pins[AUTO_PIN_AUX]);
3441 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3443 /* labels for input pins */
3444 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3445 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3447 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3456 * snd_hda_suspend - suspend the codecs
3458 * @state: suspsend state
3460 * Returns 0 if successful.
3462 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3464 struct hda_codec *codec;
3466 list_for_each_entry(codec, &bus->codec_list, list) {
3467 #ifdef CONFIG_SND_HDA_POWER_SAVE
3468 if (!codec->power_on)
3471 hda_call_codec_suspend(codec);
3475 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3478 * snd_hda_resume - resume the codecs
3481 * Returns 0 if successful.
3483 * This fucntion is defined only when POWER_SAVE isn't set.
3484 * In the power-save mode, the codec is resumed dynamically.
3486 int snd_hda_resume(struct hda_bus *bus)
3488 struct hda_codec *codec;
3490 list_for_each_entry(codec, &bus->codec_list, list) {
3491 if (snd_hda_codec_needs_resume(codec))
3492 hda_call_codec_resume(codec);
3496 EXPORT_SYMBOL_HDA(snd_hda_resume);
3497 #endif /* CONFIG_PM */
3503 /* get a new element from the given array
3504 * if it exceeds the pre-allocated array size, re-allocate the array
3506 void *snd_array_new(struct snd_array *array)
3508 if (array->used >= array->alloced) {
3509 int num = array->alloced + array->alloc_align;
3511 if (snd_BUG_ON(num >= 4096))
3513 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3517 memcpy(nlist, array->list,
3518 array->elem_size * array->alloced);
3521 array->list = nlist;
3522 array->alloced = num;
3524 return snd_array_elem(array, array->used++);
3526 EXPORT_SYMBOL_HDA(snd_array_new);
3528 /* free the given array elements */
3529 void snd_array_free(struct snd_array *array)
3536 EXPORT_SYMBOL_HDA(snd_array_free);
3539 * used by hda_proc.c and hda_eld.c
3541 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3543 static unsigned int rates[] = {
3544 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3545 96000, 176400, 192000, 384000
3549 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3551 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3553 buf[j] = '\0'; /* necessary when j == 0 */
3555 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3557 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3559 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3562 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3563 if (pcm & (AC_SUPPCM_BITS_8 << i))
3564 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3566 buf[j] = '\0'; /* necessary when j == 0 */
3568 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
3570 MODULE_DESCRIPTION("HDA codec core");
3571 MODULE_LICENSE("GPL");