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" },
51 { 0x1102, "Creative" },
55 { 0x11d4, "Analog Devices" },
56 { 0x13f6, "C-Media" },
57 { 0x14f1, "Conexant" },
58 { 0x17e8, "Chrontel" },
60 { 0x1aec, "Wolfson Microelectronics" },
61 { 0x434d, "C-Media" },
63 { 0x8384, "SigmaTel" },
67 static DEFINE_MUTEX(preset_mutex);
68 static LIST_HEAD(hda_preset_tables);
70 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
72 mutex_lock(&preset_mutex);
73 list_add_tail(&preset->list, &hda_preset_tables);
74 mutex_unlock(&preset_mutex);
77 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
79 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
81 mutex_lock(&preset_mutex);
82 list_del(&preset->list);
83 mutex_unlock(&preset_mutex);
86 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
88 #ifdef CONFIG_SND_HDA_POWER_SAVE
89 static void hda_power_work(struct work_struct *work);
90 static void hda_keep_power_on(struct hda_codec *codec);
92 static inline void hda_keep_power_on(struct hda_codec *codec) {}
95 const char *snd_hda_get_jack_location(u32 cfg)
97 static char *bases[7] = {
98 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
100 static unsigned char specials_idx[] = {
105 static char *specials[] = {
106 "Rear Panel", "Drive Bar",
107 "Riser", "HDMI", "ATAPI",
108 "Mobile-In", "Mobile-Out"
111 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
112 if ((cfg & 0x0f) < 7)
113 return bases[cfg & 0x0f];
114 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
115 if (cfg == specials_idx[i])
120 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
122 const char *snd_hda_get_jack_connectivity(u32 cfg)
124 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
126 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
128 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
130 const char *snd_hda_get_jack_type(u32 cfg)
132 static char *jack_types[16] = {
133 "Line Out", "Speaker", "HP Out", "CD",
134 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
135 "Line In", "Aux", "Mic", "Telephony",
136 "SPDIF In", "Digitial In", "Reserved", "Other"
139 return jack_types[(cfg & AC_DEFCFG_DEVICE)
140 >> AC_DEFCFG_DEVICE_SHIFT];
142 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
145 * Compose a 32bit command word to be sent to the HD-audio controller
147 static inline unsigned int
148 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
149 unsigned int verb, unsigned int parm)
153 val = (u32)(codec->addr & 0x0f) << 28;
154 val |= (u32)direct << 27;
155 val |= (u32)nid << 20;
162 * snd_hda_codec_read - send a command and get the response
163 * @codec: the HDA codec
164 * @nid: NID to send the command
165 * @direct: direct flag
166 * @verb: the verb to send
167 * @parm: the parameter for the verb
169 * Send a single command and read the corresponding response.
171 * Returns the obtained response value, or -1 for an error.
173 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
175 unsigned int verb, unsigned int parm)
177 struct hda_bus *bus = codec->bus;
178 unsigned int cmd, res;
181 cmd = make_codec_cmd(codec, nid, direct, verb, parm);
182 snd_hda_power_up(codec);
183 mutex_lock(&bus->cmd_mutex);
185 if (!bus->ops.command(bus, cmd)) {
186 res = bus->ops.get_response(bus);
187 if (res == -1 && bus->rirb_error) {
188 if (repeated++ < 1) {
189 snd_printd(KERN_WARNING "hda_codec: "
190 "Trying verb 0x%08x again\n", cmd);
195 res = (unsigned int)-1;
196 mutex_unlock(&bus->cmd_mutex);
197 snd_hda_power_down(codec);
200 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
203 * snd_hda_codec_write - send a single command without waiting for response
204 * @codec: the HDA codec
205 * @nid: NID to send the command
206 * @direct: direct flag
207 * @verb: the verb to send
208 * @parm: the parameter for the verb
210 * Send a single command without waiting for response.
212 * Returns 0 if successful, or a negative error code.
214 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
215 unsigned int verb, unsigned int parm)
217 struct hda_bus *bus = codec->bus;
221 res = make_codec_cmd(codec, nid, direct, verb, parm);
222 snd_hda_power_up(codec);
223 mutex_lock(&bus->cmd_mutex);
224 err = bus->ops.command(bus, res);
225 mutex_unlock(&bus->cmd_mutex);
226 snd_hda_power_down(codec);
229 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
232 * snd_hda_sequence_write - sequence writes
233 * @codec: the HDA codec
234 * @seq: VERB array to send
236 * Send the commands sequentially from the given array.
237 * The array must be terminated with NID=0.
239 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
241 for (; seq->nid; seq++)
242 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
244 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
247 * snd_hda_get_sub_nodes - get the range of sub nodes
248 * @codec: the HDA codec
250 * @start_id: the pointer to store the start NID
252 * Parse the NID and store the start NID of its sub-nodes.
253 * Returns the number of sub-nodes.
255 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
260 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
263 *start_id = (parm >> 16) & 0x7fff;
264 return (int)(parm & 0x7fff);
266 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
269 * snd_hda_get_connections - get connection list
270 * @codec: the HDA codec
272 * @conn_list: connection list array
273 * @max_conns: max. number of connections to store
275 * Parses the connection list of the given widget and stores the list
278 * Returns the number of connections, or a negative error code.
280 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
281 hda_nid_t *conn_list, int max_conns)
284 int i, conn_len, conns;
285 unsigned int shift, num_elems, mask;
288 if (snd_BUG_ON(!conn_list || max_conns <= 0))
291 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
292 if (parm & AC_CLIST_LONG) {
301 conn_len = parm & AC_CLIST_LENGTH;
302 mask = (1 << (shift-1)) - 1;
305 return 0; /* no connection */
308 /* single connection */
309 parm = snd_hda_codec_read(codec, nid, 0,
310 AC_VERB_GET_CONNECT_LIST, 0);
311 conn_list[0] = parm & mask;
315 /* multi connection */
318 for (i = 0; i < conn_len; i++) {
322 if (i % num_elems == 0)
323 parm = snd_hda_codec_read(codec, nid, 0,
324 AC_VERB_GET_CONNECT_LIST, i);
325 range_val = !!(parm & (1 << (shift-1))); /* ranges */
329 /* ranges between the previous and this one */
330 if (!prev_nid || prev_nid >= val) {
331 snd_printk(KERN_WARNING "hda_codec: "
332 "invalid dep_range_val %x:%x\n",
336 for (n = prev_nid + 1; n <= val; n++) {
337 if (conns >= max_conns) {
339 "Too many connections\n");
342 conn_list[conns++] = n;
345 if (conns >= max_conns) {
346 snd_printk(KERN_ERR "Too many connections\n");
349 conn_list[conns++] = val;
355 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
359 * snd_hda_queue_unsol_event - add an unsolicited event to queue
361 * @res: unsolicited event (lower 32bit of RIRB entry)
362 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
364 * Adds the given event to the queue. The events are processed in
365 * the workqueue asynchronously. Call this function in the interrupt
366 * hanlder when RIRB receives an unsolicited event.
368 * Returns 0 if successful, or a negative error code.
370 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
372 struct hda_bus_unsolicited *unsol;
379 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
383 unsol->queue[wp] = res;
384 unsol->queue[wp + 1] = res_ex;
386 queue_work(bus->workq, &unsol->work);
390 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
393 * process queued unsolicited events
395 static void process_unsol_events(struct work_struct *work)
397 struct hda_bus_unsolicited *unsol =
398 container_of(work, struct hda_bus_unsolicited, work);
399 struct hda_bus *bus = unsol->bus;
400 struct hda_codec *codec;
401 unsigned int rp, caddr, res;
403 while (unsol->rp != unsol->wp) {
404 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
407 res = unsol->queue[rp];
408 caddr = unsol->queue[rp + 1];
409 if (!(caddr & (1 << 4))) /* no unsolicited event? */
411 codec = bus->caddr_tbl[caddr & 0x0f];
412 if (codec && codec->patch_ops.unsol_event)
413 codec->patch_ops.unsol_event(codec, res);
418 * initialize unsolicited queue
420 static int init_unsol_queue(struct hda_bus *bus)
422 struct hda_bus_unsolicited *unsol;
424 if (bus->unsol) /* already initialized */
427 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
429 snd_printk(KERN_ERR "hda_codec: "
430 "can't allocate unsolicited queue\n");
433 INIT_WORK(&unsol->work, process_unsol_events);
442 static void snd_hda_codec_free(struct hda_codec *codec);
444 static int snd_hda_bus_free(struct hda_bus *bus)
446 struct hda_codec *codec, *n;
451 flush_workqueue(bus->workq);
454 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
455 snd_hda_codec_free(codec);
457 if (bus->ops.private_free)
458 bus->ops.private_free(bus);
460 destroy_workqueue(bus->workq);
465 static int snd_hda_bus_dev_free(struct snd_device *device)
467 struct hda_bus *bus = device->device_data;
469 return snd_hda_bus_free(bus);
472 #ifdef CONFIG_SND_HDA_HWDEP
473 static int snd_hda_bus_dev_register(struct snd_device *device)
475 struct hda_bus *bus = device->device_data;
476 struct hda_codec *codec;
477 list_for_each_entry(codec, &bus->codec_list, list) {
478 snd_hda_hwdep_add_sysfs(codec);
483 #define snd_hda_bus_dev_register NULL
487 * snd_hda_bus_new - create a HDA bus
488 * @card: the card entry
489 * @temp: the template for hda_bus information
490 * @busp: the pointer to store the created bus instance
492 * Returns 0 if successful, or a negative error code.
494 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
495 const struct hda_bus_template *temp,
496 struct hda_bus **busp)
500 static struct snd_device_ops dev_ops = {
501 .dev_register = snd_hda_bus_dev_register,
502 .dev_free = snd_hda_bus_dev_free,
505 if (snd_BUG_ON(!temp))
507 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
513 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
515 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
520 bus->private_data = temp->private_data;
521 bus->pci = temp->pci;
522 bus->modelname = temp->modelname;
523 bus->power_save = temp->power_save;
524 bus->ops = temp->ops;
526 mutex_init(&bus->cmd_mutex);
527 INIT_LIST_HEAD(&bus->codec_list);
529 snprintf(bus->workq_name, sizeof(bus->workq_name),
530 "hd-audio%d", card->number);
531 bus->workq = create_singlethread_workqueue(bus->workq_name);
533 snd_printk(KERN_ERR "cannot create workqueue %s\n",
539 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
541 snd_hda_bus_free(bus);
548 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
550 #ifdef CONFIG_SND_HDA_GENERIC
551 #define is_generic_config(codec) \
552 (codec->modelname && !strcmp(codec->modelname, "generic"))
554 #define is_generic_config(codec) 0
558 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
560 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
564 * find a matching codec preset
566 static const struct hda_codec_preset *
567 find_codec_preset(struct hda_codec *codec)
569 struct hda_codec_preset_list *tbl;
570 const struct hda_codec_preset *preset;
571 int mod_requested = 0;
573 if (is_generic_config(codec))
574 return NULL; /* use the generic parser */
577 mutex_lock(&preset_mutex);
578 list_for_each_entry(tbl, &hda_preset_tables, list) {
579 if (!try_module_get(tbl->owner)) {
580 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
583 for (preset = tbl->preset; preset->id; preset++) {
584 u32 mask = preset->mask;
585 if (preset->afg && preset->afg != codec->afg)
587 if (preset->mfg && preset->mfg != codec->mfg)
591 if (preset->id == (codec->vendor_id & mask) &&
593 preset->rev == codec->revision_id)) {
594 mutex_unlock(&preset_mutex);
595 codec->owner = tbl->owner;
599 module_put(tbl->owner);
601 mutex_unlock(&preset_mutex);
603 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
606 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
609 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
610 (codec->vendor_id >> 16) & 0xffff);
611 request_module(name);
619 * get_codec_name - store the codec name
621 static int get_codec_name(struct hda_codec *codec)
623 const struct hda_vendor_id *c;
624 const char *vendor = NULL;
625 u16 vendor_id = codec->vendor_id >> 16;
626 char tmp[16], name[32];
628 for (c = hda_vendor_ids; c->id; c++) {
629 if (c->id == vendor_id) {
635 sprintf(tmp, "Generic %04x", vendor_id);
638 if (codec->preset && codec->preset->name)
639 snprintf(name, sizeof(name), "%s %s", vendor,
640 codec->preset->name);
642 snprintf(name, sizeof(name), "%s ID %x", vendor,
643 codec->vendor_id & 0xffff);
644 codec->name = kstrdup(name, GFP_KERNEL);
651 * look for an AFG and MFG nodes
653 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
655 int i, total_nodes, function_id;
658 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
659 for (i = 0; i < total_nodes; i++, nid++) {
660 function_id = snd_hda_param_read(codec, nid,
661 AC_PAR_FUNCTION_TYPE) & 0xff;
662 switch (function_id) {
663 case AC_GRP_AUDIO_FUNCTION:
665 codec->function_id = function_id;
667 case AC_GRP_MODEM_FUNCTION:
669 codec->function_id = function_id;
678 * read widget caps for each widget and store in cache
680 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
685 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
687 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
690 nid = codec->start_nid;
691 for (i = 0; i < codec->num_nodes; i++, nid++)
692 codec->wcaps[i] = snd_hda_param_read(codec, nid,
693 AC_PAR_AUDIO_WIDGET_CAP);
697 /* read all pin default configurations and save codec->init_pins */
698 static int read_pin_defaults(struct hda_codec *codec)
701 hda_nid_t nid = codec->start_nid;
703 for (i = 0; i < codec->num_nodes; i++, nid++) {
704 struct hda_pincfg *pin;
705 unsigned int wcaps = get_wcaps(codec, nid);
706 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
708 if (wid_type != AC_WID_PIN)
710 pin = snd_array_new(&codec->init_pins);
714 pin->cfg = snd_hda_codec_read(codec, nid, 0,
715 AC_VERB_GET_CONFIG_DEFAULT, 0);
720 /* look up the given pin config list and return the item matching with NID */
721 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
722 struct snd_array *array,
726 for (i = 0; i < array->used; i++) {
727 struct hda_pincfg *pin = snd_array_elem(array, i);
734 /* write a config value for the given NID */
735 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
739 for (i = 0; i < 4; i++) {
740 snd_hda_codec_write(codec, nid, 0,
741 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
747 /* set the current pin config value for the given NID.
748 * the value is cached, and read via snd_hda_codec_get_pincfg()
750 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
751 hda_nid_t nid, unsigned int cfg)
753 struct hda_pincfg *pin;
756 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
757 pin = look_up_pincfg(codec, list, nid);
759 pin = snd_array_new(list);
766 /* change only when needed; e.g. if the pincfg is already present
767 * in user_pins[], don't write it
769 cfg = snd_hda_codec_get_pincfg(codec, nid);
771 set_pincfg(codec, nid, cfg);
775 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
776 hda_nid_t nid, unsigned int cfg)
778 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
780 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
782 /* get the current pin config value of the given pin NID */
783 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
785 struct hda_pincfg *pin;
787 #ifdef CONFIG_SND_HDA_HWDEP
788 pin = look_up_pincfg(codec, &codec->user_pins, nid);
792 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
795 pin = look_up_pincfg(codec, &codec->init_pins, nid);
800 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
802 /* restore all current pin configs */
803 static void restore_pincfgs(struct hda_codec *codec)
806 for (i = 0; i < codec->init_pins.used; i++) {
807 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
808 set_pincfg(codec, pin->nid,
809 snd_hda_codec_get_pincfg(codec, pin->nid));
813 static void init_hda_cache(struct hda_cache_rec *cache,
814 unsigned int record_size);
815 static void free_hda_cache(struct hda_cache_rec *cache);
817 /* restore the initial pin cfgs and release all pincfg lists */
818 static void restore_init_pincfgs(struct hda_codec *codec)
820 /* first free driver_pins and user_pins, then call restore_pincfg
821 * so that only the values in init_pins are restored
823 snd_array_free(&codec->driver_pins);
824 #ifdef CONFIG_SND_HDA_HWDEP
825 snd_array_free(&codec->user_pins);
827 restore_pincfgs(codec);
828 snd_array_free(&codec->init_pins);
834 static void snd_hda_codec_free(struct hda_codec *codec)
838 restore_init_pincfgs(codec);
839 #ifdef CONFIG_SND_HDA_POWER_SAVE
840 cancel_delayed_work(&codec->power_work);
841 flush_workqueue(codec->bus->workq);
843 list_del(&codec->list);
844 snd_array_free(&codec->mixers);
845 codec->bus->caddr_tbl[codec->addr] = NULL;
846 if (codec->patch_ops.free)
847 codec->patch_ops.free(codec);
848 module_put(codec->owner);
849 free_hda_cache(&codec->amp_cache);
850 free_hda_cache(&codec->cmd_cache);
852 kfree(codec->modelname);
857 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
858 unsigned int power_state);
861 * snd_hda_codec_new - create a HDA codec
862 * @bus: the bus to assign
863 * @codec_addr: the codec address
864 * @codecp: the pointer to store the generated codec
866 * Returns 0 if successful, or a negative error code.
868 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
869 int do_init, struct hda_codec **codecp)
871 struct hda_codec *codec;
875 if (snd_BUG_ON(!bus))
877 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
880 if (bus->caddr_tbl[codec_addr]) {
881 snd_printk(KERN_ERR "hda_codec: "
882 "address 0x%x is already occupied\n", codec_addr);
886 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
888 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
893 codec->addr = codec_addr;
894 mutex_init(&codec->spdif_mutex);
895 mutex_init(&codec->control_mutex);
896 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
897 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
898 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
899 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
900 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
901 if (codec->bus->modelname) {
902 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
903 if (!codec->modelname) {
904 snd_hda_codec_free(codec);
909 #ifdef CONFIG_SND_HDA_POWER_SAVE
910 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
911 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
912 * the caller has to power down appropriatley after initialization
915 hda_keep_power_on(codec);
918 list_add_tail(&codec->list, &bus->codec_list);
919 bus->caddr_tbl[codec_addr] = codec;
921 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
923 if (codec->vendor_id == -1)
924 /* read again, hopefully the access method was corrected
925 * in the last read...
927 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
929 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
930 AC_PAR_SUBSYSTEM_ID);
931 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
934 setup_fg_nodes(codec);
935 if (!codec->afg && !codec->mfg) {
936 snd_printdd("hda_codec: no AFG or MFG node found\n");
941 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
943 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
946 err = read_pin_defaults(codec);
950 if (!codec->subsystem_id) {
951 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
952 codec->subsystem_id =
953 snd_hda_codec_read(codec, nid, 0,
954 AC_VERB_GET_SUBSYSTEM_ID, 0);
957 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
959 /* power-up all before initialization */
960 hda_set_power_state(codec,
961 codec->afg ? codec->afg : codec->mfg,
965 err = snd_hda_codec_configure(codec);
969 snd_hda_codec_proc_new(codec);
971 snd_hda_create_hwdep(codec);
973 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
974 codec->subsystem_id, codec->revision_id);
975 snd_component_add(codec->bus->card, component);
982 snd_hda_codec_free(codec);
985 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
987 int snd_hda_codec_configure(struct hda_codec *codec)
991 codec->preset = find_codec_preset(codec);
993 err = get_codec_name(codec);
997 /* audio codec should override the mixer name */
998 if (codec->afg || !*codec->bus->card->mixername)
999 strlcpy(codec->bus->card->mixername, codec->name,
1000 sizeof(codec->bus->card->mixername));
1002 if (is_generic_config(codec)) {
1003 err = snd_hda_parse_generic_codec(codec);
1006 if (codec->preset && codec->preset->patch) {
1007 err = codec->preset->patch(codec);
1011 /* call the default parser */
1012 err = snd_hda_parse_generic_codec(codec);
1014 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1017 if (!err && codec->patch_ops.unsol_event)
1018 err = init_unsol_queue(codec->bus);
1023 * snd_hda_codec_setup_stream - set up the codec for streaming
1024 * @codec: the CODEC to set up
1025 * @nid: the NID to set up
1026 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1027 * @channel_id: channel id to pass, zero based.
1028 * @format: stream format.
1030 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1032 int channel_id, int format)
1037 snd_printdd("hda_codec_setup_stream: "
1038 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1039 nid, stream_tag, channel_id, format);
1040 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1041 (stream_tag << 4) | channel_id);
1043 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1045 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1047 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1052 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1053 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1054 #if 0 /* keep the format */
1056 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1059 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
1062 * amp access functions
1065 /* FIXME: more better hash key? */
1066 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1067 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1068 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1069 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1070 #define INFO_AMP_CAPS (1<<0)
1071 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1073 /* initialize the hash table */
1074 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1075 unsigned int record_size)
1077 memset(cache, 0, sizeof(*cache));
1078 memset(cache->hash, 0xff, sizeof(cache->hash));
1079 snd_array_init(&cache->buf, record_size, 64);
1082 static void free_hda_cache(struct hda_cache_rec *cache)
1084 snd_array_free(&cache->buf);
1087 /* query the hash. allocate an entry if not found. */
1088 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1091 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1092 u16 cur = cache->hash[idx];
1093 struct hda_cache_head *info;
1095 while (cur != 0xffff) {
1096 info = snd_array_elem(&cache->buf, cur);
1097 if (info->key == key)
1102 /* add a new hash entry */
1103 info = snd_array_new(&cache->buf);
1106 cur = snd_array_index(&cache->buf, info);
1109 info->next = cache->hash[idx];
1110 cache->hash[idx] = cur;
1115 /* query and allocate an amp hash entry */
1116 static inline struct hda_amp_info *
1117 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1119 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1123 * query AMP capabilities for the given widget and direction
1125 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1127 struct hda_amp_info *info;
1129 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1132 if (!(info->head.val & INFO_AMP_CAPS)) {
1133 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1135 info->amp_caps = snd_hda_param_read(codec, nid,
1136 direction == HDA_OUTPUT ?
1137 AC_PAR_AMP_OUT_CAP :
1140 info->head.val |= INFO_AMP_CAPS;
1142 return info->amp_caps;
1144 EXPORT_SYMBOL_HDA(query_amp_caps);
1146 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1149 struct hda_amp_info *info;
1151 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1154 info->amp_caps = caps;
1155 info->head.val |= INFO_AMP_CAPS;
1158 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1161 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1162 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1164 struct hda_amp_info *info;
1166 info = get_alloc_amp_hash(codec, key);
1169 if (!info->head.val) {
1170 info->head.val |= INFO_AMP_CAPS;
1171 info->amp_caps = func(codec, nid);
1173 return info->amp_caps;
1176 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1178 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1181 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1183 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1186 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1189 * read the current volume to info
1190 * if the cache exists, read the cache value.
1192 static unsigned int get_vol_mute(struct hda_codec *codec,
1193 struct hda_amp_info *info, hda_nid_t nid,
1194 int ch, int direction, int index)
1198 if (info->head.val & INFO_AMP_VOL(ch))
1199 return info->vol[ch];
1201 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1202 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1204 val = snd_hda_codec_read(codec, nid, 0,
1205 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1206 info->vol[ch] = val & 0xff;
1207 info->head.val |= INFO_AMP_VOL(ch);
1208 return info->vol[ch];
1212 * write the current volume in info to the h/w and update the cache
1214 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1215 hda_nid_t nid, int ch, int direction, int index,
1220 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1221 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1222 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1224 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1225 info->vol[ch] = val;
1229 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1231 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1232 int direction, int index)
1234 struct hda_amp_info *info;
1235 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1238 return get_vol_mute(codec, info, nid, ch, direction, index);
1240 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1243 * update the AMP value, mask = bit mask to set, val = the value
1245 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1246 int direction, int idx, int mask, int val)
1248 struct hda_amp_info *info;
1250 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1254 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1255 if (info->vol[ch] == val)
1257 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1260 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1263 * update the AMP stereo with the same mask and value
1265 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1266 int direction, int idx, int mask, int val)
1269 for (ch = 0; ch < 2; ch++)
1270 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1274 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1276 #ifdef SND_HDA_NEEDS_RESUME
1277 /* resume the all amp commands from the cache */
1278 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1280 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1283 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1284 u32 key = buffer->head.key;
1286 unsigned int idx, dir, ch;
1290 idx = (key >> 16) & 0xff;
1291 dir = (key >> 24) & 0xff;
1292 for (ch = 0; ch < 2; ch++) {
1293 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1295 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1300 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1301 #endif /* SND_HDA_NEEDS_RESUME */
1304 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1305 struct snd_ctl_elem_info *uinfo)
1307 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1308 u16 nid = get_amp_nid(kcontrol);
1309 u8 chs = get_amp_channels(kcontrol);
1310 int dir = get_amp_direction(kcontrol);
1311 unsigned int ofs = get_amp_offset(kcontrol);
1314 caps = query_amp_caps(codec, nid, dir);
1316 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1318 printk(KERN_WARNING "hda_codec: "
1319 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1325 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1326 uinfo->count = chs == 3 ? 2 : 1;
1327 uinfo->value.integer.min = 0;
1328 uinfo->value.integer.max = caps;
1331 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1334 static inline unsigned int
1335 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1336 int ch, int dir, int idx, unsigned int ofs)
1339 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1340 val &= HDA_AMP_VOLMASK;
1349 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1350 int ch, int dir, int idx, unsigned int ofs,
1355 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1356 HDA_AMP_VOLMASK, val);
1359 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1360 struct snd_ctl_elem_value *ucontrol)
1362 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1363 hda_nid_t nid = get_amp_nid(kcontrol);
1364 int chs = get_amp_channels(kcontrol);
1365 int dir = get_amp_direction(kcontrol);
1366 int idx = get_amp_index(kcontrol);
1367 unsigned int ofs = get_amp_offset(kcontrol);
1368 long *valp = ucontrol->value.integer.value;
1371 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1373 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1376 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1378 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1379 struct snd_ctl_elem_value *ucontrol)
1381 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1382 hda_nid_t nid = get_amp_nid(kcontrol);
1383 int chs = get_amp_channels(kcontrol);
1384 int dir = get_amp_direction(kcontrol);
1385 int idx = get_amp_index(kcontrol);
1386 unsigned int ofs = get_amp_offset(kcontrol);
1387 long *valp = ucontrol->value.integer.value;
1390 snd_hda_power_up(codec);
1392 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1396 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1397 snd_hda_power_down(codec);
1400 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1402 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1403 unsigned int size, unsigned int __user *_tlv)
1405 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1406 hda_nid_t nid = get_amp_nid(kcontrol);
1407 int dir = get_amp_direction(kcontrol);
1408 unsigned int ofs = get_amp_offset(kcontrol);
1409 u32 caps, val1, val2;
1411 if (size < 4 * sizeof(unsigned int))
1413 caps = query_amp_caps(codec, nid, dir);
1414 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1415 val2 = (val2 + 1) * 25;
1416 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1418 val1 = ((int)val1) * ((int)val2);
1419 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1421 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1423 if (put_user(val1, _tlv + 2))
1425 if (put_user(val2, _tlv + 3))
1429 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1432 * set (static) TLV for virtual master volume; recalculated as max 0dB
1434 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1440 caps = query_amp_caps(codec, nid, dir);
1441 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1442 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1443 step = (step + 1) * 25;
1444 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1445 tlv[1] = 2 * sizeof(unsigned int);
1446 tlv[2] = -nums * step;
1449 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1451 /* find a mixer control element with the given name */
1452 static struct snd_kcontrol *
1453 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1454 const char *name, int idx)
1456 struct snd_ctl_elem_id id;
1457 memset(&id, 0, sizeof(id));
1458 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1460 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1462 strcpy(id.name, name);
1463 return snd_ctl_find_id(codec->bus->card, &id);
1466 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1469 return _snd_hda_find_mixer_ctl(codec, name, 0);
1471 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1473 /* Add a control element and assign to the codec */
1474 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1477 struct snd_kcontrol **knewp;
1479 err = snd_ctl_add(codec->bus->card, kctl);
1482 knewp = snd_array_new(&codec->mixers);
1488 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1490 /* Clear all controls assigned to the given codec */
1491 void snd_hda_ctls_clear(struct hda_codec *codec)
1494 struct snd_kcontrol **kctls = codec->mixers.list;
1495 for (i = 0; i < codec->mixers.used; i++)
1496 snd_ctl_remove(codec->bus->card, kctls[i]);
1497 snd_array_free(&codec->mixers);
1500 /* pseudo device locking
1501 * toggle card->shutdown to allow/disallow the device access (as a hack)
1503 static int hda_lock_devices(struct snd_card *card)
1505 spin_lock(&card->files_lock);
1506 if (card->shutdown) {
1507 spin_unlock(&card->files_lock);
1511 spin_unlock(&card->files_lock);
1515 static void hda_unlock_devices(struct snd_card *card)
1517 spin_lock(&card->files_lock);
1519 spin_unlock(&card->files_lock);
1522 int snd_hda_codec_reset(struct hda_codec *codec)
1524 struct snd_card *card = codec->bus->card;
1527 if (hda_lock_devices(card) < 0)
1529 /* check whether the codec isn't used by any mixer or PCM streams */
1530 if (!list_empty(&card->ctl_files)) {
1531 hda_unlock_devices(card);
1534 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1535 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1538 if (cpcm->pcm->streams[0].substream_opened ||
1539 cpcm->pcm->streams[1].substream_opened) {
1540 hda_unlock_devices(card);
1545 /* OK, let it free */
1547 #ifdef CONFIG_SND_HDA_POWER_SAVE
1548 cancel_delayed_work(&codec->power_work);
1549 flush_workqueue(codec->bus->workq);
1551 snd_hda_ctls_clear(codec);
1553 for (i = 0; i < codec->num_pcms; i++) {
1554 if (codec->pcm_info[i].pcm) {
1555 snd_device_free(card, codec->pcm_info[i].pcm);
1556 clear_bit(codec->pcm_info[i].device,
1557 codec->bus->pcm_dev_bits);
1560 if (codec->patch_ops.free)
1561 codec->patch_ops.free(codec);
1562 codec->proc_widget_hook = NULL;
1564 free_hda_cache(&codec->amp_cache);
1565 free_hda_cache(&codec->cmd_cache);
1566 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1567 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1568 /* free only driver_pins so that init_pins + user_pins are restored */
1569 snd_array_free(&codec->driver_pins);
1570 restore_pincfgs(codec);
1571 codec->num_pcms = 0;
1572 codec->pcm_info = NULL;
1573 codec->preset = NULL;
1574 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1575 codec->slave_dig_outs = NULL;
1576 codec->spdif_status_reset = 0;
1577 module_put(codec->owner);
1578 codec->owner = NULL;
1580 /* allow device access again */
1581 hda_unlock_devices(card);
1585 /* create a virtual master control and add slaves */
1586 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1587 unsigned int *tlv, const char **slaves)
1589 struct snd_kcontrol *kctl;
1593 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1596 snd_printdd("No slave found for %s\n", name);
1599 kctl = snd_ctl_make_virtual_master(name, tlv);
1602 err = snd_hda_ctl_add(codec, kctl);
1606 for (s = slaves; *s; s++) {
1607 struct snd_kcontrol *sctl;
1610 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1613 snd_printdd("Cannot find slave %s, "
1617 err = snd_ctl_add_slave(kctl, sctl);
1625 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1628 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1629 struct snd_ctl_elem_info *uinfo)
1631 int chs = get_amp_channels(kcontrol);
1633 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1634 uinfo->count = chs == 3 ? 2 : 1;
1635 uinfo->value.integer.min = 0;
1636 uinfo->value.integer.max = 1;
1639 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1641 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1642 struct snd_ctl_elem_value *ucontrol)
1644 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1645 hda_nid_t nid = get_amp_nid(kcontrol);
1646 int chs = get_amp_channels(kcontrol);
1647 int dir = get_amp_direction(kcontrol);
1648 int idx = get_amp_index(kcontrol);
1649 long *valp = ucontrol->value.integer.value;
1652 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1653 HDA_AMP_MUTE) ? 0 : 1;
1655 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1656 HDA_AMP_MUTE) ? 0 : 1;
1659 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1661 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1662 struct snd_ctl_elem_value *ucontrol)
1664 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1665 hda_nid_t nid = get_amp_nid(kcontrol);
1666 int chs = get_amp_channels(kcontrol);
1667 int dir = get_amp_direction(kcontrol);
1668 int idx = get_amp_index(kcontrol);
1669 long *valp = ucontrol->value.integer.value;
1672 snd_hda_power_up(codec);
1674 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1676 *valp ? 0 : HDA_AMP_MUTE);
1680 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1682 *valp ? 0 : HDA_AMP_MUTE);
1683 #ifdef CONFIG_SND_HDA_POWER_SAVE
1684 if (codec->patch_ops.check_power_status)
1685 codec->patch_ops.check_power_status(codec, nid);
1687 snd_hda_power_down(codec);
1690 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1693 * bound volume controls
1695 * bind multiple volumes (# indices, from 0)
1698 #define AMP_VAL_IDX_SHIFT 19
1699 #define AMP_VAL_IDX_MASK (0x0f<<19)
1701 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1702 struct snd_ctl_elem_value *ucontrol)
1704 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1708 mutex_lock(&codec->control_mutex);
1709 pval = kcontrol->private_value;
1710 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1711 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1712 kcontrol->private_value = pval;
1713 mutex_unlock(&codec->control_mutex);
1716 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1718 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1719 struct snd_ctl_elem_value *ucontrol)
1721 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1723 int i, indices, err = 0, change = 0;
1725 mutex_lock(&codec->control_mutex);
1726 pval = kcontrol->private_value;
1727 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1728 for (i = 0; i < indices; i++) {
1729 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1730 (i << AMP_VAL_IDX_SHIFT);
1731 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1736 kcontrol->private_value = pval;
1737 mutex_unlock(&codec->control_mutex);
1738 return err < 0 ? err : change;
1740 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1743 * generic bound volume/swtich controls
1745 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1746 struct snd_ctl_elem_info *uinfo)
1748 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1749 struct hda_bind_ctls *c;
1752 mutex_lock(&codec->control_mutex);
1753 c = (struct hda_bind_ctls *)kcontrol->private_value;
1754 kcontrol->private_value = *c->values;
1755 err = c->ops->info(kcontrol, uinfo);
1756 kcontrol->private_value = (long)c;
1757 mutex_unlock(&codec->control_mutex);
1760 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1762 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1763 struct snd_ctl_elem_value *ucontrol)
1765 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1766 struct hda_bind_ctls *c;
1769 mutex_lock(&codec->control_mutex);
1770 c = (struct hda_bind_ctls *)kcontrol->private_value;
1771 kcontrol->private_value = *c->values;
1772 err = c->ops->get(kcontrol, ucontrol);
1773 kcontrol->private_value = (long)c;
1774 mutex_unlock(&codec->control_mutex);
1777 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1779 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1780 struct snd_ctl_elem_value *ucontrol)
1782 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1783 struct hda_bind_ctls *c;
1784 unsigned long *vals;
1785 int err = 0, change = 0;
1787 mutex_lock(&codec->control_mutex);
1788 c = (struct hda_bind_ctls *)kcontrol->private_value;
1789 for (vals = c->values; *vals; vals++) {
1790 kcontrol->private_value = *vals;
1791 err = c->ops->put(kcontrol, ucontrol);
1796 kcontrol->private_value = (long)c;
1797 mutex_unlock(&codec->control_mutex);
1798 return err < 0 ? err : change;
1800 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1802 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1803 unsigned int size, unsigned int __user *tlv)
1805 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1806 struct hda_bind_ctls *c;
1809 mutex_lock(&codec->control_mutex);
1810 c = (struct hda_bind_ctls *)kcontrol->private_value;
1811 kcontrol->private_value = *c->values;
1812 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1813 kcontrol->private_value = (long)c;
1814 mutex_unlock(&codec->control_mutex);
1817 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1819 struct hda_ctl_ops snd_hda_bind_vol = {
1820 .info = snd_hda_mixer_amp_volume_info,
1821 .get = snd_hda_mixer_amp_volume_get,
1822 .put = snd_hda_mixer_amp_volume_put,
1823 .tlv = snd_hda_mixer_amp_tlv
1825 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1827 struct hda_ctl_ops snd_hda_bind_sw = {
1828 .info = snd_hda_mixer_amp_switch_info,
1829 .get = snd_hda_mixer_amp_switch_get,
1830 .put = snd_hda_mixer_amp_switch_put,
1831 .tlv = snd_hda_mixer_amp_tlv
1833 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1836 * SPDIF out controls
1839 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1840 struct snd_ctl_elem_info *uinfo)
1842 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1847 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1848 struct snd_ctl_elem_value *ucontrol)
1850 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1851 IEC958_AES0_NONAUDIO |
1852 IEC958_AES0_CON_EMPHASIS_5015 |
1853 IEC958_AES0_CON_NOT_COPYRIGHT;
1854 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1855 IEC958_AES1_CON_ORIGINAL;
1859 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1860 struct snd_ctl_elem_value *ucontrol)
1862 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1863 IEC958_AES0_NONAUDIO |
1864 IEC958_AES0_PRO_EMPHASIS_5015;
1868 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1869 struct snd_ctl_elem_value *ucontrol)
1871 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1873 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1874 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1875 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1876 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1881 /* convert from SPDIF status bits to HDA SPDIF bits
1882 * bit 0 (DigEn) is always set zero (to be filled later)
1884 static unsigned short convert_from_spdif_status(unsigned int sbits)
1886 unsigned short val = 0;
1888 if (sbits & IEC958_AES0_PROFESSIONAL)
1889 val |= AC_DIG1_PROFESSIONAL;
1890 if (sbits & IEC958_AES0_NONAUDIO)
1891 val |= AC_DIG1_NONAUDIO;
1892 if (sbits & IEC958_AES0_PROFESSIONAL) {
1893 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1894 IEC958_AES0_PRO_EMPHASIS_5015)
1895 val |= AC_DIG1_EMPHASIS;
1897 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1898 IEC958_AES0_CON_EMPHASIS_5015)
1899 val |= AC_DIG1_EMPHASIS;
1900 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1901 val |= AC_DIG1_COPYRIGHT;
1902 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1903 val |= AC_DIG1_LEVEL;
1904 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1909 /* convert to SPDIF status bits from HDA SPDIF bits
1911 static unsigned int convert_to_spdif_status(unsigned short val)
1913 unsigned int sbits = 0;
1915 if (val & AC_DIG1_NONAUDIO)
1916 sbits |= IEC958_AES0_NONAUDIO;
1917 if (val & AC_DIG1_PROFESSIONAL)
1918 sbits |= IEC958_AES0_PROFESSIONAL;
1919 if (sbits & IEC958_AES0_PROFESSIONAL) {
1920 if (sbits & AC_DIG1_EMPHASIS)
1921 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1923 if (val & AC_DIG1_EMPHASIS)
1924 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1925 if (!(val & AC_DIG1_COPYRIGHT))
1926 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1927 if (val & AC_DIG1_LEVEL)
1928 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1929 sbits |= val & (0x7f << 8);
1934 /* set digital convert verbs both for the given NID and its slaves */
1935 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1940 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1941 d = codec->slave_dig_outs;
1945 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1948 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1952 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1954 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1957 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1958 struct snd_ctl_elem_value *ucontrol)
1960 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1961 hda_nid_t nid = kcontrol->private_value;
1965 mutex_lock(&codec->spdif_mutex);
1966 codec->spdif_status = ucontrol->value.iec958.status[0] |
1967 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1968 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1969 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1970 val = convert_from_spdif_status(codec->spdif_status);
1971 val |= codec->spdif_ctls & 1;
1972 change = codec->spdif_ctls != val;
1973 codec->spdif_ctls = val;
1976 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1978 mutex_unlock(&codec->spdif_mutex);
1982 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1984 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1985 struct snd_ctl_elem_value *ucontrol)
1987 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1989 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1993 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1994 struct snd_ctl_elem_value *ucontrol)
1996 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1997 hda_nid_t nid = kcontrol->private_value;
2001 mutex_lock(&codec->spdif_mutex);
2002 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2003 if (ucontrol->value.integer.value[0])
2004 val |= AC_DIG1_ENABLE;
2005 change = codec->spdif_ctls != val;
2007 codec->spdif_ctls = val;
2008 set_dig_out_convert(codec, nid, val & 0xff, -1);
2009 /* unmute amp switch (if any) */
2010 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2011 (val & AC_DIG1_ENABLE))
2012 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2015 mutex_unlock(&codec->spdif_mutex);
2019 static struct snd_kcontrol_new dig_mixes[] = {
2021 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2022 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2023 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2024 .info = snd_hda_spdif_mask_info,
2025 .get = snd_hda_spdif_cmask_get,
2028 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2029 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2030 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2031 .info = snd_hda_spdif_mask_info,
2032 .get = snd_hda_spdif_pmask_get,
2035 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2036 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2037 .info = snd_hda_spdif_mask_info,
2038 .get = snd_hda_spdif_default_get,
2039 .put = snd_hda_spdif_default_put,
2042 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2043 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2044 .info = snd_hda_spdif_out_switch_info,
2045 .get = snd_hda_spdif_out_switch_get,
2046 .put = snd_hda_spdif_out_switch_put,
2051 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2054 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2055 * @codec: the HDA codec
2056 * @nid: audio out widget NID
2058 * Creates controls related with the SPDIF output.
2059 * Called from each patch supporting the SPDIF out.
2061 * Returns 0 if successful, or a negative error code.
2063 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2066 struct snd_kcontrol *kctl;
2067 struct snd_kcontrol_new *dig_mix;
2070 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2071 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2075 if (idx >= SPDIF_MAX_IDX) {
2076 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2079 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2080 kctl = snd_ctl_new1(dig_mix, codec);
2083 kctl->id.index = idx;
2084 kctl->private_value = nid;
2085 err = snd_hda_ctl_add(codec, kctl);
2090 snd_hda_codec_read(codec, nid, 0,
2091 AC_VERB_GET_DIGI_CONVERT_1, 0);
2092 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2095 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2098 * SPDIF sharing with analog output
2100 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2101 struct snd_ctl_elem_value *ucontrol)
2103 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2104 ucontrol->value.integer.value[0] = mout->share_spdif;
2108 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2109 struct snd_ctl_elem_value *ucontrol)
2111 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2112 mout->share_spdif = !!ucontrol->value.integer.value[0];
2116 static struct snd_kcontrol_new spdif_share_sw = {
2117 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2118 .name = "IEC958 Default PCM Playback Switch",
2119 .info = snd_ctl_boolean_mono_info,
2120 .get = spdif_share_sw_get,
2121 .put = spdif_share_sw_put,
2124 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2125 struct hda_multi_out *mout)
2127 if (!mout->dig_out_nid)
2129 /* ATTENTION: here mout is passed as private_data, instead of codec */
2130 return snd_hda_ctl_add(codec,
2131 snd_ctl_new1(&spdif_share_sw, mout));
2133 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2139 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2141 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2142 struct snd_ctl_elem_value *ucontrol)
2144 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2146 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2150 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2151 struct snd_ctl_elem_value *ucontrol)
2153 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2154 hda_nid_t nid = kcontrol->private_value;
2155 unsigned int val = !!ucontrol->value.integer.value[0];
2158 mutex_lock(&codec->spdif_mutex);
2159 change = codec->spdif_in_enable != val;
2161 codec->spdif_in_enable = val;
2162 snd_hda_codec_write_cache(codec, nid, 0,
2163 AC_VERB_SET_DIGI_CONVERT_1, val);
2165 mutex_unlock(&codec->spdif_mutex);
2169 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2170 struct snd_ctl_elem_value *ucontrol)
2172 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2173 hda_nid_t nid = kcontrol->private_value;
2177 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2178 sbits = convert_to_spdif_status(val);
2179 ucontrol->value.iec958.status[0] = sbits;
2180 ucontrol->value.iec958.status[1] = sbits >> 8;
2181 ucontrol->value.iec958.status[2] = sbits >> 16;
2182 ucontrol->value.iec958.status[3] = sbits >> 24;
2186 static struct snd_kcontrol_new dig_in_ctls[] = {
2188 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2189 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2190 .info = snd_hda_spdif_in_switch_info,
2191 .get = snd_hda_spdif_in_switch_get,
2192 .put = snd_hda_spdif_in_switch_put,
2195 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2196 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2197 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2198 .info = snd_hda_spdif_mask_info,
2199 .get = snd_hda_spdif_in_status_get,
2205 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2206 * @codec: the HDA codec
2207 * @nid: audio in widget NID
2209 * Creates controls related with the SPDIF input.
2210 * Called from each patch supporting the SPDIF in.
2212 * Returns 0 if successful, or a negative error code.
2214 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2217 struct snd_kcontrol *kctl;
2218 struct snd_kcontrol_new *dig_mix;
2221 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2222 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2226 if (idx >= SPDIF_MAX_IDX) {
2227 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2230 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2231 kctl = snd_ctl_new1(dig_mix, codec);
2234 kctl->private_value = nid;
2235 err = snd_hda_ctl_add(codec, kctl);
2239 codec->spdif_in_enable =
2240 snd_hda_codec_read(codec, nid, 0,
2241 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2245 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2247 #ifdef SND_HDA_NEEDS_RESUME
2252 /* build a 32bit cache key with the widget id and the command parameter */
2253 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2254 #define get_cmd_cache_nid(key) ((key) & 0xff)
2255 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2258 * snd_hda_codec_write_cache - send a single command with caching
2259 * @codec: the HDA codec
2260 * @nid: NID to send the command
2261 * @direct: direct flag
2262 * @verb: the verb to send
2263 * @parm: the parameter for the verb
2265 * Send a single command without waiting for response.
2267 * Returns 0 if successful, or a negative error code.
2269 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2270 int direct, unsigned int verb, unsigned int parm)
2272 struct hda_bus *bus = codec->bus;
2276 res = make_codec_cmd(codec, nid, direct, verb, parm);
2277 snd_hda_power_up(codec);
2278 mutex_lock(&bus->cmd_mutex);
2279 err = bus->ops.command(bus, res);
2281 struct hda_cache_head *c;
2283 /* parm may contain the verb stuff for get/set amp */
2284 verb = verb | (parm >> 8);
2286 key = build_cmd_cache_key(nid, verb);
2287 c = get_alloc_hash(&codec->cmd_cache, key);
2291 mutex_unlock(&bus->cmd_mutex);
2292 snd_hda_power_down(codec);
2295 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2297 /* resume the all commands from the cache */
2298 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2300 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2303 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2304 u32 key = buffer->key;
2307 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2308 get_cmd_cache_cmd(key), buffer->val);
2311 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2314 * snd_hda_sequence_write_cache - sequence writes with caching
2315 * @codec: the HDA codec
2316 * @seq: VERB array to send
2318 * Send the commands sequentially from the given array.
2319 * Thte commands are recorded on cache for power-save and resume.
2320 * The array must be terminated with NID=0.
2322 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2323 const struct hda_verb *seq)
2325 for (; seq->nid; seq++)
2326 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2329 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2330 #endif /* SND_HDA_NEEDS_RESUME */
2333 * set power state of the codec
2335 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2336 unsigned int power_state)
2341 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2343 msleep(10); /* partial workaround for "azx_get_response timeout" */
2345 nid = codec->start_nid;
2346 for (i = 0; i < codec->num_nodes; i++, nid++) {
2347 unsigned int wcaps = get_wcaps(codec, nid);
2348 if (wcaps & AC_WCAP_POWER) {
2349 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2351 if (power_state == AC_PWRST_D3 &&
2352 wid_type == AC_WID_PIN) {
2353 unsigned int pincap;
2355 * don't power down the widget if it controls
2356 * eapd and EAPD_BTLENABLE is set.
2358 pincap = snd_hda_query_pin_caps(codec, nid);
2359 if (pincap & AC_PINCAP_EAPD) {
2360 int eapd = snd_hda_codec_read(codec,
2362 AC_VERB_GET_EAPD_BTLENABLE, 0);
2368 snd_hda_codec_write(codec, nid, 0,
2369 AC_VERB_SET_POWER_STATE,
2374 if (power_state == AC_PWRST_D0) {
2375 unsigned long end_time;
2378 /* wait until the codec reachs to D0 */
2379 end_time = jiffies + msecs_to_jiffies(500);
2381 state = snd_hda_codec_read(codec, fg, 0,
2382 AC_VERB_GET_POWER_STATE, 0);
2383 if (state == power_state)
2386 } while (time_after_eq(end_time, jiffies));
2390 #ifdef CONFIG_SND_HDA_HWDEP
2391 /* execute additional init verbs */
2392 static void hda_exec_init_verbs(struct hda_codec *codec)
2394 if (codec->init_verbs.list)
2395 snd_hda_sequence_write(codec, codec->init_verbs.list);
2398 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2401 #ifdef SND_HDA_NEEDS_RESUME
2403 * call suspend and power-down; used both from PM and power-save
2405 static void hda_call_codec_suspend(struct hda_codec *codec)
2407 if (codec->patch_ops.suspend)
2408 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2409 hda_set_power_state(codec,
2410 codec->afg ? codec->afg : codec->mfg,
2412 #ifdef CONFIG_SND_HDA_POWER_SAVE
2413 cancel_delayed_work(&codec->power_work);
2414 codec->power_on = 0;
2415 codec->power_transition = 0;
2420 * kick up codec; used both from PM and power-save
2422 static void hda_call_codec_resume(struct hda_codec *codec)
2424 hda_set_power_state(codec,
2425 codec->afg ? codec->afg : codec->mfg,
2427 restore_pincfgs(codec); /* restore all current pin configs */
2428 hda_exec_init_verbs(codec);
2429 if (codec->patch_ops.resume)
2430 codec->patch_ops.resume(codec);
2432 if (codec->patch_ops.init)
2433 codec->patch_ops.init(codec);
2434 snd_hda_codec_resume_amp(codec);
2435 snd_hda_codec_resume_cache(codec);
2438 #endif /* SND_HDA_NEEDS_RESUME */
2442 * snd_hda_build_controls - build mixer controls
2445 * Creates mixer controls for each codec included in the bus.
2447 * Returns 0 if successful, otherwise a negative error code.
2449 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2451 struct hda_codec *codec;
2453 list_for_each_entry(codec, &bus->codec_list, list) {
2454 int err = snd_hda_codec_build_controls(codec);
2456 printk(KERN_ERR "hda_codec: cannot build controls"
2457 "for #%d (error %d)\n", codec->addr, err);
2458 err = snd_hda_codec_reset(codec);
2461 "hda_codec: cannot revert codec\n");
2468 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2470 int snd_hda_codec_build_controls(struct hda_codec *codec)
2473 hda_exec_init_verbs(codec);
2474 /* continue to initialize... */
2475 if (codec->patch_ops.init)
2476 err = codec->patch_ops.init(codec);
2477 if (!err && codec->patch_ops.build_controls)
2478 err = codec->patch_ops.build_controls(codec);
2487 struct hda_rate_tbl {
2489 unsigned int alsa_bits;
2490 unsigned int hda_fmt;
2493 static struct hda_rate_tbl rate_bits[] = {
2494 /* rate in Hz, ALSA rate bitmask, HDA format value */
2496 /* autodetected value used in snd_hda_query_supported_pcm */
2497 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2498 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2499 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2500 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2501 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2502 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2503 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2504 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2505 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2506 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2507 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2508 #define AC_PAR_PCM_RATE_BITS 11
2509 /* up to bits 10, 384kHZ isn't supported properly */
2511 /* not autodetected value */
2512 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2514 { 0 } /* terminator */
2518 * snd_hda_calc_stream_format - calculate format bitset
2519 * @rate: the sample rate
2520 * @channels: the number of channels
2521 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2522 * @maxbps: the max. bps
2524 * Calculate the format bitset from the given rate, channels and th PCM format.
2526 * Return zero if invalid.
2528 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2529 unsigned int channels,
2530 unsigned int format,
2531 unsigned int maxbps)
2534 unsigned int val = 0;
2536 for (i = 0; rate_bits[i].hz; i++)
2537 if (rate_bits[i].hz == rate) {
2538 val = rate_bits[i].hda_fmt;
2541 if (!rate_bits[i].hz) {
2542 snd_printdd("invalid rate %d\n", rate);
2546 if (channels == 0 || channels > 8) {
2547 snd_printdd("invalid channels %d\n", channels);
2550 val |= channels - 1;
2552 switch (snd_pcm_format_width(format)) {
2553 case 8: val |= 0x00; break;
2554 case 16: val |= 0x10; break;
2560 else if (maxbps >= 24)
2566 snd_printdd("invalid format width %d\n",
2567 snd_pcm_format_width(format));
2573 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2575 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2577 unsigned int val = 0;
2578 if (nid != codec->afg &&
2579 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2580 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2581 if (!val || val == -1)
2582 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2583 if (!val || val == -1)
2588 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2590 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2594 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2596 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2597 if (!streams || streams == -1)
2598 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2599 if (!streams || streams == -1)
2604 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2606 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2611 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2612 * @codec: the HDA codec
2613 * @nid: NID to query
2614 * @ratesp: the pointer to store the detected rate bitflags
2615 * @formatsp: the pointer to store the detected formats
2616 * @bpsp: the pointer to store the detected format widths
2618 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2619 * or @bsps argument is ignored.
2621 * Returns 0 if successful, otherwise a negative error code.
2623 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2624 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2626 unsigned int i, val, wcaps;
2628 wcaps = get_wcaps(codec, nid);
2629 val = query_pcm_param(codec, nid);
2633 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2635 rates |= rate_bits[i].alsa_bits;
2638 snd_printk(KERN_ERR "hda_codec: rates == 0 "
2639 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2641 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2647 if (formatsp || bpsp) {
2649 unsigned int streams, bps;
2651 streams = query_stream_param(codec, nid);
2656 if (streams & AC_SUPFMT_PCM) {
2657 if (val & AC_SUPPCM_BITS_8) {
2658 formats |= SNDRV_PCM_FMTBIT_U8;
2661 if (val & AC_SUPPCM_BITS_16) {
2662 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2665 if (wcaps & AC_WCAP_DIGITAL) {
2666 if (val & AC_SUPPCM_BITS_32)
2667 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2668 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2669 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2670 if (val & AC_SUPPCM_BITS_24)
2672 else if (val & AC_SUPPCM_BITS_20)
2674 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2675 AC_SUPPCM_BITS_32)) {
2676 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2677 if (val & AC_SUPPCM_BITS_32)
2679 else if (val & AC_SUPPCM_BITS_24)
2681 else if (val & AC_SUPPCM_BITS_20)
2685 else if (streams == AC_SUPFMT_FLOAT32) {
2686 /* should be exclusive */
2687 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2689 } else if (streams == AC_SUPFMT_AC3) {
2690 /* should be exclusive */
2691 /* temporary hack: we have still no proper support
2692 * for the direct AC3 stream...
2694 formats |= SNDRV_PCM_FMTBIT_U8;
2698 snd_printk(KERN_ERR "hda_codec: formats == 0 "
2699 "(nid=0x%x, val=0x%x, ovrd=%i, "
2702 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2707 *formatsp = formats;
2716 * snd_hda_is_supported_format - check whether the given node supports
2719 * Returns 1 if supported, 0 if not.
2721 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2722 unsigned int format)
2725 unsigned int val = 0, rate, stream;
2727 val = query_pcm_param(codec, nid);
2731 rate = format & 0xff00;
2732 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2733 if (rate_bits[i].hda_fmt == rate) {
2738 if (i >= AC_PAR_PCM_RATE_BITS)
2741 stream = query_stream_param(codec, nid);
2745 if (stream & AC_SUPFMT_PCM) {
2746 switch (format & 0xf0) {
2748 if (!(val & AC_SUPPCM_BITS_8))
2752 if (!(val & AC_SUPPCM_BITS_16))
2756 if (!(val & AC_SUPPCM_BITS_20))
2760 if (!(val & AC_SUPPCM_BITS_24))
2764 if (!(val & AC_SUPPCM_BITS_32))
2771 /* FIXME: check for float32 and AC3? */
2776 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2781 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2782 struct hda_codec *codec,
2783 struct snd_pcm_substream *substream)
2788 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2789 struct hda_codec *codec,
2790 unsigned int stream_tag,
2791 unsigned int format,
2792 struct snd_pcm_substream *substream)
2794 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2798 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2799 struct hda_codec *codec,
2800 struct snd_pcm_substream *substream)
2802 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2806 static int set_pcm_default_values(struct hda_codec *codec,
2807 struct hda_pcm_stream *info)
2811 /* query support PCM information from the given NID */
2812 if (info->nid && (!info->rates || !info->formats)) {
2813 err = snd_hda_query_supported_pcm(codec, info->nid,
2814 info->rates ? NULL : &info->rates,
2815 info->formats ? NULL : &info->formats,
2816 info->maxbps ? NULL : &info->maxbps);
2820 if (info->ops.open == NULL)
2821 info->ops.open = hda_pcm_default_open_close;
2822 if (info->ops.close == NULL)
2823 info->ops.close = hda_pcm_default_open_close;
2824 if (info->ops.prepare == NULL) {
2825 if (snd_BUG_ON(!info->nid))
2827 info->ops.prepare = hda_pcm_default_prepare;
2829 if (info->ops.cleanup == NULL) {
2830 if (snd_BUG_ON(!info->nid))
2832 info->ops.cleanup = hda_pcm_default_cleanup;
2838 * get the empty PCM device number to assign
2840 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2842 static const char *dev_name[HDA_PCM_NTYPES] = {
2843 "Audio", "SPDIF", "HDMI", "Modem"
2845 /* starting device index for each PCM type */
2846 static int dev_idx[HDA_PCM_NTYPES] = {
2847 [HDA_PCM_TYPE_AUDIO] = 0,
2848 [HDA_PCM_TYPE_SPDIF] = 1,
2849 [HDA_PCM_TYPE_HDMI] = 3,
2850 [HDA_PCM_TYPE_MODEM] = 6
2852 /* normal audio device indices; not linear to keep compatibility */
2853 static int audio_idx[4] = { 0, 2, 4, 5 };
2857 case HDA_PCM_TYPE_AUDIO:
2858 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2860 if (!test_bit(dev, bus->pcm_dev_bits))
2863 snd_printk(KERN_WARNING "Too many audio devices\n");
2865 case HDA_PCM_TYPE_SPDIF:
2866 case HDA_PCM_TYPE_HDMI:
2867 case HDA_PCM_TYPE_MODEM:
2868 dev = dev_idx[type];
2869 if (test_bit(dev, bus->pcm_dev_bits)) {
2870 snd_printk(KERN_WARNING "%s already defined\n",
2876 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2880 set_bit(dev, bus->pcm_dev_bits);
2885 * attach a new PCM stream
2887 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2889 struct hda_bus *bus = codec->bus;
2890 struct hda_pcm_stream *info;
2893 if (snd_BUG_ON(!pcm->name))
2895 for (stream = 0; stream < 2; stream++) {
2896 info = &pcm->stream[stream];
2897 if (info->substreams) {
2898 err = set_pcm_default_values(codec, info);
2903 return bus->ops.attach_pcm(bus, codec, pcm);
2906 /* assign all PCMs of the given codec */
2907 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2912 if (!codec->num_pcms) {
2913 if (!codec->patch_ops.build_pcms)
2915 err = codec->patch_ops.build_pcms(codec);
2917 printk(KERN_ERR "hda_codec: cannot build PCMs"
2918 "for #%d (error %d)\n", codec->addr, err);
2919 err = snd_hda_codec_reset(codec);
2922 "hda_codec: cannot revert codec\n");
2927 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2928 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2931 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2932 continue; /* no substreams assigned */
2935 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2937 continue; /* no fatal error */
2939 err = snd_hda_attach_pcm(codec, cpcm);
2941 printk(KERN_ERR "hda_codec: cannot attach "
2942 "PCM stream %d for codec #%d\n",
2944 continue; /* no fatal error */
2952 * snd_hda_build_pcms - build PCM information
2955 * Create PCM information for each codec included in the bus.
2957 * The build_pcms codec patch is requested to set up codec->num_pcms and
2958 * codec->pcm_info properly. The array is referred by the top-level driver
2959 * to create its PCM instances.
2960 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2963 * At least, substreams, channels_min and channels_max must be filled for
2964 * each stream. substreams = 0 indicates that the stream doesn't exist.
2965 * When rates and/or formats are zero, the supported values are queried
2966 * from the given nid. The nid is used also by the default ops.prepare
2967 * and ops.cleanup callbacks.
2969 * The driver needs to call ops.open in its open callback. Similarly,
2970 * ops.close is supposed to be called in the close callback.
2971 * ops.prepare should be called in the prepare or hw_params callback
2972 * with the proper parameters for set up.
2973 * ops.cleanup should be called in hw_free for clean up of streams.
2975 * This function returns 0 if successfull, or a negative error code.
2977 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2979 struct hda_codec *codec;
2981 list_for_each_entry(codec, &bus->codec_list, list) {
2982 int err = snd_hda_codec_build_pcms(codec);
2988 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2991 * snd_hda_check_board_config - compare the current codec with the config table
2992 * @codec: the HDA codec
2993 * @num_configs: number of config enums
2994 * @models: array of model name strings
2995 * @tbl: configuration table, terminated by null entries
2997 * Compares the modelname or PCI subsystem id of the current codec with the
2998 * given configuration table. If a matching entry is found, returns its
2999 * config value (supposed to be 0 or positive).
3001 * If no entries are matching, the function returns a negative value.
3003 int snd_hda_check_board_config(struct hda_codec *codec,
3004 int num_configs, const char **models,
3005 const struct snd_pci_quirk *tbl)
3007 if (codec->modelname && models) {
3009 for (i = 0; i < num_configs; i++) {
3011 !strcmp(codec->modelname, models[i])) {
3012 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3013 "selected\n", models[i]);
3019 if (!codec->bus->pci || !tbl)
3022 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3025 if (tbl->value >= 0 && tbl->value < num_configs) {
3026 #ifdef CONFIG_SND_DEBUG_VERBOSE
3028 const char *model = NULL;
3030 model = models[tbl->value];
3032 sprintf(tmp, "#%d", tbl->value);
3035 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3036 "for config %x:%x (%s)\n",
3037 model, tbl->subvendor, tbl->subdevice,
3038 (tbl->name ? tbl->name : "Unknown device"));
3044 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3047 * snd_hda_check_board_codec_sid_config - compare the current codec
3048 subsystem ID with the
3051 This is important for Gateway notebooks with SB450 HDA Audio
3052 where the vendor ID of the PCI device is:
3053 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3054 and the vendor/subvendor are found only at the codec.
3056 * @codec: the HDA codec
3057 * @num_configs: number of config enums
3058 * @models: array of model name strings
3059 * @tbl: configuration table, terminated by null entries
3061 * Compares the modelname or PCI subsystem id of the current codec with the
3062 * given configuration table. If a matching entry is found, returns its
3063 * config value (supposed to be 0 or positive).
3065 * If no entries are matching, the function returns a negative value.
3067 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3068 int num_configs, const char **models,
3069 const struct snd_pci_quirk *tbl)
3071 const struct snd_pci_quirk *q;
3073 /* Search for codec ID */
3074 for (q = tbl; q->subvendor; q++) {
3075 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3077 if (vendorid == codec->subsystem_id)
3086 if (tbl->value >= 0 && tbl->value < num_configs) {
3087 #ifdef CONFIG_SND_DEBUG_DETECT
3089 const char *model = NULL;
3091 model = models[tbl->value];
3093 sprintf(tmp, "#%d", tbl->value);
3096 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3097 "for config %x:%x (%s)\n",
3098 model, tbl->subvendor, tbl->subdevice,
3099 (tbl->name ? tbl->name : "Unknown device"));
3105 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3108 * snd_hda_add_new_ctls - create controls from the array
3109 * @codec: the HDA codec
3110 * @knew: the array of struct snd_kcontrol_new
3112 * This helper function creates and add new controls in the given array.
3113 * The array must be terminated with an empty entry as terminator.
3115 * Returns 0 if successful, or a negative error code.
3117 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3121 for (; knew->name; knew++) {
3122 struct snd_kcontrol *kctl;
3123 kctl = snd_ctl_new1(knew, codec);
3126 err = snd_hda_ctl_add(codec, kctl);
3130 kctl = snd_ctl_new1(knew, codec);
3133 kctl->id.device = codec->addr;
3134 err = snd_hda_ctl_add(codec, kctl);
3141 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3143 #ifdef CONFIG_SND_HDA_POWER_SAVE
3144 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3145 unsigned int power_state);
3147 static void hda_power_work(struct work_struct *work)
3149 struct hda_codec *codec =
3150 container_of(work, struct hda_codec, power_work.work);
3151 struct hda_bus *bus = codec->bus;
3153 if (!codec->power_on || codec->power_count) {
3154 codec->power_transition = 0;
3158 hda_call_codec_suspend(codec);
3159 if (bus->ops.pm_notify)
3160 bus->ops.pm_notify(bus);
3163 static void hda_keep_power_on(struct hda_codec *codec)
3165 codec->power_count++;
3166 codec->power_on = 1;
3169 void snd_hda_power_up(struct hda_codec *codec)
3171 struct hda_bus *bus = codec->bus;
3173 codec->power_count++;
3174 if (codec->power_on || codec->power_transition)
3177 codec->power_on = 1;
3178 if (bus->ops.pm_notify)
3179 bus->ops.pm_notify(bus);
3180 hda_call_codec_resume(codec);
3181 cancel_delayed_work(&codec->power_work);
3182 codec->power_transition = 0;
3184 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3186 #define power_save(codec) \
3187 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3189 #define power_save(codec) \
3190 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3192 void snd_hda_power_down(struct hda_codec *codec)
3194 --codec->power_count;
3195 if (!codec->power_on || codec->power_count || codec->power_transition)
3197 if (power_save(codec)) {
3198 codec->power_transition = 1; /* avoid reentrance */
3199 queue_delayed_work(codec->bus->workq, &codec->power_work,
3200 msecs_to_jiffies(power_save(codec) * 1000));
3203 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3205 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3206 struct hda_loopback_check *check,
3209 struct hda_amp_list *p;
3212 if (!check->amplist)
3214 for (p = check->amplist; p->nid; p++) {
3219 return 0; /* nothing changed */
3221 for (p = check->amplist; p->nid; p++) {
3222 for (ch = 0; ch < 2; ch++) {
3223 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3225 if (!(v & HDA_AMP_MUTE) && v > 0) {
3226 if (!check->power_on) {
3227 check->power_on = 1;
3228 snd_hda_power_up(codec);
3234 if (check->power_on) {
3235 check->power_on = 0;
3236 snd_hda_power_down(codec);
3240 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3244 * Channel mode helper
3246 int snd_hda_ch_mode_info(struct hda_codec *codec,
3247 struct snd_ctl_elem_info *uinfo,
3248 const struct hda_channel_mode *chmode,
3251 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3253 uinfo->value.enumerated.items = num_chmodes;
3254 if (uinfo->value.enumerated.item >= num_chmodes)
3255 uinfo->value.enumerated.item = num_chmodes - 1;
3256 sprintf(uinfo->value.enumerated.name, "%dch",
3257 chmode[uinfo->value.enumerated.item].channels);
3260 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3262 int snd_hda_ch_mode_get(struct hda_codec *codec,
3263 struct snd_ctl_elem_value *ucontrol,
3264 const struct hda_channel_mode *chmode,
3270 for (i = 0; i < num_chmodes; i++) {
3271 if (max_channels == chmode[i].channels) {
3272 ucontrol->value.enumerated.item[0] = i;
3278 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3280 int snd_hda_ch_mode_put(struct hda_codec *codec,
3281 struct snd_ctl_elem_value *ucontrol,
3282 const struct hda_channel_mode *chmode,
3288 mode = ucontrol->value.enumerated.item[0];
3289 if (mode >= num_chmodes)
3291 if (*max_channelsp == chmode[mode].channels)
3293 /* change the current channel setting */
3294 *max_channelsp = chmode[mode].channels;
3295 if (chmode[mode].sequence)
3296 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3299 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3304 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3305 struct snd_ctl_elem_info *uinfo)
3309 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3311 uinfo->value.enumerated.items = imux->num_items;
3312 if (!imux->num_items)
3314 index = uinfo->value.enumerated.item;
3315 if (index >= imux->num_items)
3316 index = imux->num_items - 1;
3317 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3320 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3322 int snd_hda_input_mux_put(struct hda_codec *codec,
3323 const struct hda_input_mux *imux,
3324 struct snd_ctl_elem_value *ucontrol,
3326 unsigned int *cur_val)
3330 if (!imux->num_items)
3332 idx = ucontrol->value.enumerated.item[0];
3333 if (idx >= imux->num_items)
3334 idx = imux->num_items - 1;
3335 if (*cur_val == idx)
3337 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3338 imux->items[idx].index);
3342 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3346 * Multi-channel / digital-out PCM helper functions
3349 /* setup SPDIF output stream */
3350 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3351 unsigned int stream_tag, unsigned int format)
3353 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3354 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3355 set_dig_out_convert(codec, nid,
3356 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3358 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3359 if (codec->slave_dig_outs) {
3361 for (d = codec->slave_dig_outs; *d; d++)
3362 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3365 /* turn on again (if needed) */
3366 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3367 set_dig_out_convert(codec, nid,
3368 codec->spdif_ctls & 0xff, -1);
3371 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3373 snd_hda_codec_cleanup_stream(codec, nid);
3374 if (codec->slave_dig_outs) {
3376 for (d = codec->slave_dig_outs; *d; d++)
3377 snd_hda_codec_cleanup_stream(codec, *d);
3382 * open the digital out in the exclusive mode
3384 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3385 struct hda_multi_out *mout)
3387 mutex_lock(&codec->spdif_mutex);
3388 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3389 /* already opened as analog dup; reset it once */
3390 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3391 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3392 mutex_unlock(&codec->spdif_mutex);
3395 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3397 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3398 struct hda_multi_out *mout,
3399 unsigned int stream_tag,
3400 unsigned int format,
3401 struct snd_pcm_substream *substream)
3403 mutex_lock(&codec->spdif_mutex);
3404 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3405 mutex_unlock(&codec->spdif_mutex);
3408 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3410 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3411 struct hda_multi_out *mout)
3413 mutex_lock(&codec->spdif_mutex);
3414 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3415 mutex_unlock(&codec->spdif_mutex);
3418 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3421 * release the digital out
3423 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3424 struct hda_multi_out *mout)
3426 mutex_lock(&codec->spdif_mutex);
3427 mout->dig_out_used = 0;
3428 mutex_unlock(&codec->spdif_mutex);
3431 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3434 * set up more restrictions for analog out
3436 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3437 struct hda_multi_out *mout,
3438 struct snd_pcm_substream *substream,
3439 struct hda_pcm_stream *hinfo)
3441 struct snd_pcm_runtime *runtime = substream->runtime;
3442 runtime->hw.channels_max = mout->max_channels;
3443 if (mout->dig_out_nid) {
3444 if (!mout->analog_rates) {
3445 mout->analog_rates = hinfo->rates;
3446 mout->analog_formats = hinfo->formats;
3447 mout->analog_maxbps = hinfo->maxbps;
3449 runtime->hw.rates = mout->analog_rates;
3450 runtime->hw.formats = mout->analog_formats;
3451 hinfo->maxbps = mout->analog_maxbps;
3453 if (!mout->spdif_rates) {
3454 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3456 &mout->spdif_formats,
3457 &mout->spdif_maxbps);
3459 mutex_lock(&codec->spdif_mutex);
3460 if (mout->share_spdif) {
3461 runtime->hw.rates &= mout->spdif_rates;
3462 runtime->hw.formats &= mout->spdif_formats;
3463 if (mout->spdif_maxbps < hinfo->maxbps)
3464 hinfo->maxbps = mout->spdif_maxbps;
3466 mutex_unlock(&codec->spdif_mutex);
3468 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3469 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3471 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3474 * set up the i/o for analog out
3475 * when the digital out is available, copy the front out to digital out, too.
3477 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3478 struct hda_multi_out *mout,
3479 unsigned int stream_tag,
3480 unsigned int format,
3481 struct snd_pcm_substream *substream)
3483 hda_nid_t *nids = mout->dac_nids;
3484 int chs = substream->runtime->channels;
3487 mutex_lock(&codec->spdif_mutex);
3488 if (mout->dig_out_nid && mout->share_spdif &&
3489 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3491 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3493 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3494 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3495 setup_dig_out_stream(codec, mout->dig_out_nid,
3496 stream_tag, format);
3498 mout->dig_out_used = 0;
3499 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3502 mutex_unlock(&codec->spdif_mutex);
3505 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3507 if (!mout->no_share_stream &&
3508 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3509 /* headphone out will just decode front left/right (stereo) */
3510 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3512 /* extra outputs copied from front */
3513 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3514 if (!mout->no_share_stream && mout->extra_out_nid[i])
3515 snd_hda_codec_setup_stream(codec,
3516 mout->extra_out_nid[i],
3517 stream_tag, 0, format);
3520 for (i = 1; i < mout->num_dacs; i++) {
3521 if (chs >= (i + 1) * 2) /* independent out */
3522 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3524 else if (!mout->no_share_stream) /* copy front */
3525 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3530 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3533 * clean up the setting for analog out
3535 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3536 struct hda_multi_out *mout)
3538 hda_nid_t *nids = mout->dac_nids;
3541 for (i = 0; i < mout->num_dacs; i++)
3542 snd_hda_codec_cleanup_stream(codec, nids[i]);
3544 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3545 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3546 if (mout->extra_out_nid[i])
3547 snd_hda_codec_cleanup_stream(codec,
3548 mout->extra_out_nid[i]);
3549 mutex_lock(&codec->spdif_mutex);
3550 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3551 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3552 mout->dig_out_used = 0;
3554 mutex_unlock(&codec->spdif_mutex);
3557 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3560 * Helper for automatic pin configuration
3563 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3565 for (; *list; list++)
3573 * Sort an associated group of pins according to their sequence numbers.
3575 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3582 for (i = 0; i < num_pins; i++) {
3583 for (j = i + 1; j < num_pins; j++) {
3584 if (sequences[i] > sequences[j]) {
3586 sequences[i] = sequences[j];
3598 * Parse all pin widgets and store the useful pin nids to cfg
3600 * The number of line-outs or any primary output is stored in line_outs,
3601 * and the corresponding output pins are assigned to line_out_pins[],
3602 * in the order of front, rear, CLFE, side, ...
3604 * If more extra outputs (speaker and headphone) are found, the pins are
3605 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3606 * is detected, one of speaker of HP pins is assigned as the primary
3607 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3608 * if any analog output exists.
3610 * The analog input pins are assigned to input_pins array.
3611 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3614 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3615 struct auto_pin_cfg *cfg,
3616 hda_nid_t *ignore_nids)
3618 hda_nid_t nid, end_nid;
3619 short seq, assoc_line_out, assoc_speaker;
3620 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3621 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3622 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3624 memset(cfg, 0, sizeof(*cfg));
3626 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3627 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3628 memset(sequences_hp, 0, sizeof(sequences_hp));
3629 assoc_line_out = assoc_speaker = 0;
3631 end_nid = codec->start_nid + codec->num_nodes;
3632 for (nid = codec->start_nid; nid < end_nid; nid++) {
3633 unsigned int wid_caps = get_wcaps(codec, nid);
3634 unsigned int wid_type =
3635 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3636 unsigned int def_conf;
3639 /* read all default configuration for pin complex */
3640 if (wid_type != AC_WID_PIN)
3642 /* ignore the given nids (e.g. pc-beep returns error) */
3643 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3646 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3647 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3649 loc = get_defcfg_location(def_conf);
3650 switch (get_defcfg_device(def_conf)) {
3651 case AC_JACK_LINE_OUT:
3652 seq = get_defcfg_sequence(def_conf);
3653 assoc = get_defcfg_association(def_conf);
3655 if (!(wid_caps & AC_WCAP_STEREO))
3656 if (!cfg->mono_out_pin)
3657 cfg->mono_out_pin = nid;
3660 if (!assoc_line_out)
3661 assoc_line_out = assoc;
3662 else if (assoc_line_out != assoc)
3664 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3666 cfg->line_out_pins[cfg->line_outs] = nid;
3667 sequences_line_out[cfg->line_outs] = seq;
3670 case AC_JACK_SPEAKER:
3671 seq = get_defcfg_sequence(def_conf);
3672 assoc = get_defcfg_association(def_conf);
3675 if (! assoc_speaker)
3676 assoc_speaker = assoc;
3677 else if (assoc_speaker != assoc)
3679 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3681 cfg->speaker_pins[cfg->speaker_outs] = nid;
3682 sequences_speaker[cfg->speaker_outs] = seq;
3683 cfg->speaker_outs++;
3685 case AC_JACK_HP_OUT:
3686 seq = get_defcfg_sequence(def_conf);
3687 assoc = get_defcfg_association(def_conf);
3688 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3690 cfg->hp_pins[cfg->hp_outs] = nid;
3691 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3694 case AC_JACK_MIC_IN: {
3696 if (loc == AC_JACK_LOC_FRONT) {
3697 preferred = AUTO_PIN_FRONT_MIC;
3700 preferred = AUTO_PIN_MIC;
3701 alt = AUTO_PIN_FRONT_MIC;
3703 if (!cfg->input_pins[preferred])
3704 cfg->input_pins[preferred] = nid;
3705 else if (!cfg->input_pins[alt])
3706 cfg->input_pins[alt] = nid;
3709 case AC_JACK_LINE_IN:
3710 if (loc == AC_JACK_LOC_FRONT)
3711 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3713 cfg->input_pins[AUTO_PIN_LINE] = nid;
3716 cfg->input_pins[AUTO_PIN_CD] = nid;
3719 cfg->input_pins[AUTO_PIN_AUX] = nid;
3721 case AC_JACK_SPDIF_OUT:
3722 case AC_JACK_DIG_OTHER_OUT:
3723 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3725 cfg->dig_out_pins[cfg->dig_outs] = nid;
3726 cfg->dig_out_type[cfg->dig_outs] =
3727 (loc == AC_JACK_LOC_HDMI) ?
3728 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3731 case AC_JACK_SPDIF_IN:
3732 case AC_JACK_DIG_OTHER_IN:
3733 cfg->dig_in_pin = nid;
3734 if (loc == AC_JACK_LOC_HDMI)
3735 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3737 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
3743 * If no line-out is defined but multiple HPs are found,
3744 * some of them might be the real line-outs.
3746 if (!cfg->line_outs && cfg->hp_outs > 1) {
3748 while (i < cfg->hp_outs) {
3749 /* The real HPs should have the sequence 0x0f */
3750 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3754 /* Move it to the line-out table */
3755 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3756 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3759 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3760 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3761 memmove(sequences_hp + i - 1, sequences_hp + i,
3762 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3766 /* sort by sequence */
3767 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3769 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3771 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3774 /* if we have only one mic, make it AUTO_PIN_MIC */
3775 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3776 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3777 cfg->input_pins[AUTO_PIN_MIC] =
3778 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3779 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3781 /* ditto for line-in */
3782 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3783 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3784 cfg->input_pins[AUTO_PIN_LINE] =
3785 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3786 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3790 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3791 * as a primary output
3793 if (!cfg->line_outs) {
3794 if (cfg->speaker_outs) {
3795 cfg->line_outs = cfg->speaker_outs;
3796 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3797 sizeof(cfg->speaker_pins));
3798 cfg->speaker_outs = 0;
3799 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3800 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3801 } else if (cfg->hp_outs) {
3802 cfg->line_outs = cfg->hp_outs;
3803 memcpy(cfg->line_out_pins, cfg->hp_pins,
3804 sizeof(cfg->hp_pins));
3806 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3807 cfg->line_out_type = AUTO_PIN_HP_OUT;
3811 /* Reorder the surround channels
3812 * ALSA sequence is front/surr/clfe/side
3814 * 4-ch: front/surr => OK as it is
3815 * 6-ch: front/clfe/surr
3816 * 8-ch: front/clfe/rear/side|fc
3818 switch (cfg->line_outs) {
3821 nid = cfg->line_out_pins[1];
3822 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3823 cfg->line_out_pins[2] = nid;
3828 * debug prints of the parsed results
3830 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3831 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3832 cfg->line_out_pins[2], cfg->line_out_pins[3],
3833 cfg->line_out_pins[4]);
3834 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3835 cfg->speaker_outs, cfg->speaker_pins[0],
3836 cfg->speaker_pins[1], cfg->speaker_pins[2],
3837 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3838 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3839 cfg->hp_outs, cfg->hp_pins[0],
3840 cfg->hp_pins[1], cfg->hp_pins[2],
3841 cfg->hp_pins[3], cfg->hp_pins[4]);
3842 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3844 snd_printd(" dig-out=0x%x/0x%x\n",
3845 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
3846 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3847 " cd=0x%x, aux=0x%x\n",
3848 cfg->input_pins[AUTO_PIN_MIC],
3849 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3850 cfg->input_pins[AUTO_PIN_LINE],
3851 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3852 cfg->input_pins[AUTO_PIN_CD],
3853 cfg->input_pins[AUTO_PIN_AUX]);
3854 if (cfg->dig_in_pin)
3855 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
3859 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3861 /* labels for input pins */
3862 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3863 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3865 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3874 * snd_hda_suspend - suspend the codecs
3876 * @state: suspsend state
3878 * Returns 0 if successful.
3880 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3882 struct hda_codec *codec;
3884 list_for_each_entry(codec, &bus->codec_list, list) {
3885 #ifdef CONFIG_SND_HDA_POWER_SAVE
3886 if (!codec->power_on)
3889 hda_call_codec_suspend(codec);
3893 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3896 * snd_hda_resume - resume the codecs
3899 * Returns 0 if successful.
3901 * This fucntion is defined only when POWER_SAVE isn't set.
3902 * In the power-save mode, the codec is resumed dynamically.
3904 int snd_hda_resume(struct hda_bus *bus)
3906 struct hda_codec *codec;
3908 list_for_each_entry(codec, &bus->codec_list, list) {
3909 if (snd_hda_codec_needs_resume(codec))
3910 hda_call_codec_resume(codec);
3914 EXPORT_SYMBOL_HDA(snd_hda_resume);
3915 #endif /* CONFIG_PM */
3921 /* get a new element from the given array
3922 * if it exceeds the pre-allocated array size, re-allocate the array
3924 void *snd_array_new(struct snd_array *array)
3926 if (array->used >= array->alloced) {
3927 int num = array->alloced + array->alloc_align;
3929 if (snd_BUG_ON(num >= 4096))
3931 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3935 memcpy(nlist, array->list,
3936 array->elem_size * array->alloced);
3939 array->list = nlist;
3940 array->alloced = num;
3942 return snd_array_elem(array, array->used++);
3944 EXPORT_SYMBOL_HDA(snd_array_new);
3946 /* free the given array elements */
3947 void snd_array_free(struct snd_array *array)
3954 EXPORT_SYMBOL_HDA(snd_array_free);
3957 * used by hda_proc.c and hda_eld.c
3959 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3961 static unsigned int rates[] = {
3962 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3963 96000, 176400, 192000, 384000
3967 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3969 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3971 buf[j] = '\0'; /* necessary when j == 0 */
3973 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3975 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3977 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3980 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3981 if (pcm & (AC_SUPPCM_BITS_8 << i))
3982 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3984 buf[j] = '\0'; /* necessary when j == 0 */
3986 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
3988 MODULE_DESCRIPTION("HDA codec core");
3989 MODULE_LICENSE("GPL");