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 (wid_type == AC_WID_PIN) {
2352 unsigned int pincap;
2354 * don't power down the widget if it controls
2355 * eapd and EAPD_BTLENABLE is set.
2357 pincap = snd_hda_query_pin_caps(codec, nid);
2358 if (pincap & AC_PINCAP_EAPD) {
2359 int eapd = snd_hda_codec_read(codec,
2361 AC_VERB_GET_EAPD_BTLENABLE, 0);
2363 if (power_state == AC_PWRST_D3 && eapd)
2367 snd_hda_codec_write(codec, nid, 0,
2368 AC_VERB_SET_POWER_STATE,
2373 if (power_state == AC_PWRST_D0) {
2374 unsigned long end_time;
2377 /* wait until the codec reachs to D0 */
2378 end_time = jiffies + msecs_to_jiffies(500);
2380 state = snd_hda_codec_read(codec, fg, 0,
2381 AC_VERB_GET_POWER_STATE, 0);
2382 if (state == power_state)
2385 } while (time_after_eq(end_time, jiffies));
2389 #ifdef CONFIG_SND_HDA_HWDEP
2390 /* execute additional init verbs */
2391 static void hda_exec_init_verbs(struct hda_codec *codec)
2393 if (codec->init_verbs.list)
2394 snd_hda_sequence_write(codec, codec->init_verbs.list);
2397 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2400 #ifdef SND_HDA_NEEDS_RESUME
2402 * call suspend and power-down; used both from PM and power-save
2404 static void hda_call_codec_suspend(struct hda_codec *codec)
2406 if (codec->patch_ops.suspend)
2407 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2408 hda_set_power_state(codec,
2409 codec->afg ? codec->afg : codec->mfg,
2411 #ifdef CONFIG_SND_HDA_POWER_SAVE
2412 cancel_delayed_work(&codec->power_work);
2413 codec->power_on = 0;
2414 codec->power_transition = 0;
2419 * kick up codec; used both from PM and power-save
2421 static void hda_call_codec_resume(struct hda_codec *codec)
2423 hda_set_power_state(codec,
2424 codec->afg ? codec->afg : codec->mfg,
2426 restore_pincfgs(codec); /* restore all current pin configs */
2427 hda_exec_init_verbs(codec);
2428 if (codec->patch_ops.resume)
2429 codec->patch_ops.resume(codec);
2431 if (codec->patch_ops.init)
2432 codec->patch_ops.init(codec);
2433 snd_hda_codec_resume_amp(codec);
2434 snd_hda_codec_resume_cache(codec);
2437 #endif /* SND_HDA_NEEDS_RESUME */
2441 * snd_hda_build_controls - build mixer controls
2444 * Creates mixer controls for each codec included in the bus.
2446 * Returns 0 if successful, otherwise a negative error code.
2448 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2450 struct hda_codec *codec;
2452 list_for_each_entry(codec, &bus->codec_list, list) {
2453 int err = snd_hda_codec_build_controls(codec);
2455 printk(KERN_ERR "hda_codec: cannot build controls"
2456 "for #%d (error %d)\n", codec->addr, err);
2457 err = snd_hda_codec_reset(codec);
2460 "hda_codec: cannot revert codec\n");
2467 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2469 int snd_hda_codec_build_controls(struct hda_codec *codec)
2472 hda_exec_init_verbs(codec);
2473 /* continue to initialize... */
2474 if (codec->patch_ops.init)
2475 err = codec->patch_ops.init(codec);
2476 if (!err && codec->patch_ops.build_controls)
2477 err = codec->patch_ops.build_controls(codec);
2486 struct hda_rate_tbl {
2488 unsigned int alsa_bits;
2489 unsigned int hda_fmt;
2492 static struct hda_rate_tbl rate_bits[] = {
2493 /* rate in Hz, ALSA rate bitmask, HDA format value */
2495 /* autodetected value used in snd_hda_query_supported_pcm */
2496 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2497 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2498 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2499 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2500 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2501 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2502 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2503 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2504 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2505 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2506 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2507 #define AC_PAR_PCM_RATE_BITS 11
2508 /* up to bits 10, 384kHZ isn't supported properly */
2510 /* not autodetected value */
2511 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2513 { 0 } /* terminator */
2517 * snd_hda_calc_stream_format - calculate format bitset
2518 * @rate: the sample rate
2519 * @channels: the number of channels
2520 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2521 * @maxbps: the max. bps
2523 * Calculate the format bitset from the given rate, channels and th PCM format.
2525 * Return zero if invalid.
2527 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2528 unsigned int channels,
2529 unsigned int format,
2530 unsigned int maxbps)
2533 unsigned int val = 0;
2535 for (i = 0; rate_bits[i].hz; i++)
2536 if (rate_bits[i].hz == rate) {
2537 val = rate_bits[i].hda_fmt;
2540 if (!rate_bits[i].hz) {
2541 snd_printdd("invalid rate %d\n", rate);
2545 if (channels == 0 || channels > 8) {
2546 snd_printdd("invalid channels %d\n", channels);
2549 val |= channels - 1;
2551 switch (snd_pcm_format_width(format)) {
2552 case 8: val |= 0x00; break;
2553 case 16: val |= 0x10; break;
2559 else if (maxbps >= 24)
2565 snd_printdd("invalid format width %d\n",
2566 snd_pcm_format_width(format));
2572 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2574 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2576 unsigned int val = 0;
2577 if (nid != codec->afg &&
2578 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2579 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2580 if (!val || val == -1)
2581 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2582 if (!val || val == -1)
2587 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2589 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2593 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2595 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2596 if (!streams || streams == -1)
2597 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2598 if (!streams || streams == -1)
2603 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2605 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2610 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2611 * @codec: the HDA codec
2612 * @nid: NID to query
2613 * @ratesp: the pointer to store the detected rate bitflags
2614 * @formatsp: the pointer to store the detected formats
2615 * @bpsp: the pointer to store the detected format widths
2617 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2618 * or @bsps argument is ignored.
2620 * Returns 0 if successful, otherwise a negative error code.
2622 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2623 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2625 unsigned int i, val, wcaps;
2627 wcaps = get_wcaps(codec, nid);
2628 val = query_pcm_param(codec, nid);
2632 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2634 rates |= rate_bits[i].alsa_bits;
2637 snd_printk(KERN_ERR "hda_codec: rates == 0 "
2638 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2640 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2646 if (formatsp || bpsp) {
2648 unsigned int streams, bps;
2650 streams = query_stream_param(codec, nid);
2655 if (streams & AC_SUPFMT_PCM) {
2656 if (val & AC_SUPPCM_BITS_8) {
2657 formats |= SNDRV_PCM_FMTBIT_U8;
2660 if (val & AC_SUPPCM_BITS_16) {
2661 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2664 if (wcaps & AC_WCAP_DIGITAL) {
2665 if (val & AC_SUPPCM_BITS_32)
2666 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2667 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2668 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2669 if (val & AC_SUPPCM_BITS_24)
2671 else if (val & AC_SUPPCM_BITS_20)
2673 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2674 AC_SUPPCM_BITS_32)) {
2675 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2676 if (val & AC_SUPPCM_BITS_32)
2678 else if (val & AC_SUPPCM_BITS_24)
2680 else if (val & AC_SUPPCM_BITS_20)
2684 else if (streams == AC_SUPFMT_FLOAT32) {
2685 /* should be exclusive */
2686 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2688 } else if (streams == AC_SUPFMT_AC3) {
2689 /* should be exclusive */
2690 /* temporary hack: we have still no proper support
2691 * for the direct AC3 stream...
2693 formats |= SNDRV_PCM_FMTBIT_U8;
2697 snd_printk(KERN_ERR "hda_codec: formats == 0 "
2698 "(nid=0x%x, val=0x%x, ovrd=%i, "
2701 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2706 *formatsp = formats;
2715 * snd_hda_is_supported_format - check whether the given node supports
2718 * Returns 1 if supported, 0 if not.
2720 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2721 unsigned int format)
2724 unsigned int val = 0, rate, stream;
2726 val = query_pcm_param(codec, nid);
2730 rate = format & 0xff00;
2731 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2732 if (rate_bits[i].hda_fmt == rate) {
2737 if (i >= AC_PAR_PCM_RATE_BITS)
2740 stream = query_stream_param(codec, nid);
2744 if (stream & AC_SUPFMT_PCM) {
2745 switch (format & 0xf0) {
2747 if (!(val & AC_SUPPCM_BITS_8))
2751 if (!(val & AC_SUPPCM_BITS_16))
2755 if (!(val & AC_SUPPCM_BITS_20))
2759 if (!(val & AC_SUPPCM_BITS_24))
2763 if (!(val & AC_SUPPCM_BITS_32))
2770 /* FIXME: check for float32 and AC3? */
2775 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2780 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2781 struct hda_codec *codec,
2782 struct snd_pcm_substream *substream)
2787 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2788 struct hda_codec *codec,
2789 unsigned int stream_tag,
2790 unsigned int format,
2791 struct snd_pcm_substream *substream)
2793 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2797 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2798 struct hda_codec *codec,
2799 struct snd_pcm_substream *substream)
2801 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2805 static int set_pcm_default_values(struct hda_codec *codec,
2806 struct hda_pcm_stream *info)
2810 /* query support PCM information from the given NID */
2811 if (info->nid && (!info->rates || !info->formats)) {
2812 err = snd_hda_query_supported_pcm(codec, info->nid,
2813 info->rates ? NULL : &info->rates,
2814 info->formats ? NULL : &info->formats,
2815 info->maxbps ? NULL : &info->maxbps);
2819 if (info->ops.open == NULL)
2820 info->ops.open = hda_pcm_default_open_close;
2821 if (info->ops.close == NULL)
2822 info->ops.close = hda_pcm_default_open_close;
2823 if (info->ops.prepare == NULL) {
2824 if (snd_BUG_ON(!info->nid))
2826 info->ops.prepare = hda_pcm_default_prepare;
2828 if (info->ops.cleanup == NULL) {
2829 if (snd_BUG_ON(!info->nid))
2831 info->ops.cleanup = hda_pcm_default_cleanup;
2837 * get the empty PCM device number to assign
2839 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2841 static const char *dev_name[HDA_PCM_NTYPES] = {
2842 "Audio", "SPDIF", "HDMI", "Modem"
2844 /* starting device index for each PCM type */
2845 static int dev_idx[HDA_PCM_NTYPES] = {
2846 [HDA_PCM_TYPE_AUDIO] = 0,
2847 [HDA_PCM_TYPE_SPDIF] = 1,
2848 [HDA_PCM_TYPE_HDMI] = 3,
2849 [HDA_PCM_TYPE_MODEM] = 6
2851 /* normal audio device indices; not linear to keep compatibility */
2852 static int audio_idx[4] = { 0, 2, 4, 5 };
2856 case HDA_PCM_TYPE_AUDIO:
2857 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2859 if (!test_bit(dev, bus->pcm_dev_bits))
2862 snd_printk(KERN_WARNING "Too many audio devices\n");
2864 case HDA_PCM_TYPE_SPDIF:
2865 case HDA_PCM_TYPE_HDMI:
2866 case HDA_PCM_TYPE_MODEM:
2867 dev = dev_idx[type];
2868 if (test_bit(dev, bus->pcm_dev_bits)) {
2869 snd_printk(KERN_WARNING "%s already defined\n",
2875 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2879 set_bit(dev, bus->pcm_dev_bits);
2884 * attach a new PCM stream
2886 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2888 struct hda_bus *bus = codec->bus;
2889 struct hda_pcm_stream *info;
2892 if (snd_BUG_ON(!pcm->name))
2894 for (stream = 0; stream < 2; stream++) {
2895 info = &pcm->stream[stream];
2896 if (info->substreams) {
2897 err = set_pcm_default_values(codec, info);
2902 return bus->ops.attach_pcm(bus, codec, pcm);
2905 /* assign all PCMs of the given codec */
2906 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2911 if (!codec->num_pcms) {
2912 if (!codec->patch_ops.build_pcms)
2914 err = codec->patch_ops.build_pcms(codec);
2916 printk(KERN_ERR "hda_codec: cannot build PCMs"
2917 "for #%d (error %d)\n", codec->addr, err);
2918 err = snd_hda_codec_reset(codec);
2921 "hda_codec: cannot revert codec\n");
2926 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2927 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2930 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2931 continue; /* no substreams assigned */
2934 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2936 continue; /* no fatal error */
2938 err = snd_hda_attach_pcm(codec, cpcm);
2940 printk(KERN_ERR "hda_codec: cannot attach "
2941 "PCM stream %d for codec #%d\n",
2943 continue; /* no fatal error */
2951 * snd_hda_build_pcms - build PCM information
2954 * Create PCM information for each codec included in the bus.
2956 * The build_pcms codec patch is requested to set up codec->num_pcms and
2957 * codec->pcm_info properly. The array is referred by the top-level driver
2958 * to create its PCM instances.
2959 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2962 * At least, substreams, channels_min and channels_max must be filled for
2963 * each stream. substreams = 0 indicates that the stream doesn't exist.
2964 * When rates and/or formats are zero, the supported values are queried
2965 * from the given nid. The nid is used also by the default ops.prepare
2966 * and ops.cleanup callbacks.
2968 * The driver needs to call ops.open in its open callback. Similarly,
2969 * ops.close is supposed to be called in the close callback.
2970 * ops.prepare should be called in the prepare or hw_params callback
2971 * with the proper parameters for set up.
2972 * ops.cleanup should be called in hw_free for clean up of streams.
2974 * This function returns 0 if successfull, or a negative error code.
2976 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2978 struct hda_codec *codec;
2980 list_for_each_entry(codec, &bus->codec_list, list) {
2981 int err = snd_hda_codec_build_pcms(codec);
2987 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2990 * snd_hda_check_board_config - compare the current codec with the config table
2991 * @codec: the HDA codec
2992 * @num_configs: number of config enums
2993 * @models: array of model name strings
2994 * @tbl: configuration table, terminated by null entries
2996 * Compares the modelname or PCI subsystem id of the current codec with the
2997 * given configuration table. If a matching entry is found, returns its
2998 * config value (supposed to be 0 or positive).
3000 * If no entries are matching, the function returns a negative value.
3002 int snd_hda_check_board_config(struct hda_codec *codec,
3003 int num_configs, const char **models,
3004 const struct snd_pci_quirk *tbl)
3006 if (codec->modelname && models) {
3008 for (i = 0; i < num_configs; i++) {
3010 !strcmp(codec->modelname, models[i])) {
3011 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3012 "selected\n", models[i]);
3018 if (!codec->bus->pci || !tbl)
3021 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3024 if (tbl->value >= 0 && tbl->value < num_configs) {
3025 #ifdef CONFIG_SND_DEBUG_VERBOSE
3027 const char *model = NULL;
3029 model = models[tbl->value];
3031 sprintf(tmp, "#%d", tbl->value);
3034 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3035 "for config %x:%x (%s)\n",
3036 model, tbl->subvendor, tbl->subdevice,
3037 (tbl->name ? tbl->name : "Unknown device"));
3043 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3046 * snd_hda_check_board_codec_sid_config - compare the current codec
3047 subsystem ID with the
3050 This is important for Gateway notebooks with SB450 HDA Audio
3051 where the vendor ID of the PCI device is:
3052 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3053 and the vendor/subvendor are found only at the codec.
3055 * @codec: the HDA codec
3056 * @num_configs: number of config enums
3057 * @models: array of model name strings
3058 * @tbl: configuration table, terminated by null entries
3060 * Compares the modelname or PCI subsystem id of the current codec with the
3061 * given configuration table. If a matching entry is found, returns its
3062 * config value (supposed to be 0 or positive).
3064 * If no entries are matching, the function returns a negative value.
3066 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3067 int num_configs, const char **models,
3068 const struct snd_pci_quirk *tbl)
3070 const struct snd_pci_quirk *q;
3072 /* Search for codec ID */
3073 for (q = tbl; q->subvendor; q++) {
3074 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3076 if (vendorid == codec->subsystem_id)
3085 if (tbl->value >= 0 && tbl->value < num_configs) {
3086 #ifdef CONFIG_SND_DEBUG_DETECT
3088 const char *model = NULL;
3090 model = models[tbl->value];
3092 sprintf(tmp, "#%d", tbl->value);
3095 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3096 "for config %x:%x (%s)\n",
3097 model, tbl->subvendor, tbl->subdevice,
3098 (tbl->name ? tbl->name : "Unknown device"));
3104 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3107 * snd_hda_add_new_ctls - create controls from the array
3108 * @codec: the HDA codec
3109 * @knew: the array of struct snd_kcontrol_new
3111 * This helper function creates and add new controls in the given array.
3112 * The array must be terminated with an empty entry as terminator.
3114 * Returns 0 if successful, or a negative error code.
3116 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3120 for (; knew->name; knew++) {
3121 struct snd_kcontrol *kctl;
3122 kctl = snd_ctl_new1(knew, codec);
3125 err = snd_hda_ctl_add(codec, kctl);
3129 kctl = snd_ctl_new1(knew, codec);
3132 kctl->id.device = codec->addr;
3133 err = snd_hda_ctl_add(codec, kctl);
3140 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3142 #ifdef CONFIG_SND_HDA_POWER_SAVE
3143 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3144 unsigned int power_state);
3146 static void hda_power_work(struct work_struct *work)
3148 struct hda_codec *codec =
3149 container_of(work, struct hda_codec, power_work.work);
3150 struct hda_bus *bus = codec->bus;
3152 if (!codec->power_on || codec->power_count) {
3153 codec->power_transition = 0;
3157 hda_call_codec_suspend(codec);
3158 if (bus->ops.pm_notify)
3159 bus->ops.pm_notify(bus);
3162 static void hda_keep_power_on(struct hda_codec *codec)
3164 codec->power_count++;
3165 codec->power_on = 1;
3168 void snd_hda_power_up(struct hda_codec *codec)
3170 struct hda_bus *bus = codec->bus;
3172 codec->power_count++;
3173 if (codec->power_on || codec->power_transition)
3176 codec->power_on = 1;
3177 if (bus->ops.pm_notify)
3178 bus->ops.pm_notify(bus);
3179 hda_call_codec_resume(codec);
3180 cancel_delayed_work(&codec->power_work);
3181 codec->power_transition = 0;
3183 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3185 #define power_save(codec) \
3186 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3188 #define power_save(codec) \
3189 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3191 void snd_hda_power_down(struct hda_codec *codec)
3193 --codec->power_count;
3194 if (!codec->power_on || codec->power_count || codec->power_transition)
3196 if (power_save(codec)) {
3197 codec->power_transition = 1; /* avoid reentrance */
3198 queue_delayed_work(codec->bus->workq, &codec->power_work,
3199 msecs_to_jiffies(power_save(codec) * 1000));
3202 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3204 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3205 struct hda_loopback_check *check,
3208 struct hda_amp_list *p;
3211 if (!check->amplist)
3213 for (p = check->amplist; p->nid; p++) {
3218 return 0; /* nothing changed */
3220 for (p = check->amplist; p->nid; p++) {
3221 for (ch = 0; ch < 2; ch++) {
3222 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3224 if (!(v & HDA_AMP_MUTE) && v > 0) {
3225 if (!check->power_on) {
3226 check->power_on = 1;
3227 snd_hda_power_up(codec);
3233 if (check->power_on) {
3234 check->power_on = 0;
3235 snd_hda_power_down(codec);
3239 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3243 * Channel mode helper
3245 int snd_hda_ch_mode_info(struct hda_codec *codec,
3246 struct snd_ctl_elem_info *uinfo,
3247 const struct hda_channel_mode *chmode,
3250 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3252 uinfo->value.enumerated.items = num_chmodes;
3253 if (uinfo->value.enumerated.item >= num_chmodes)
3254 uinfo->value.enumerated.item = num_chmodes - 1;
3255 sprintf(uinfo->value.enumerated.name, "%dch",
3256 chmode[uinfo->value.enumerated.item].channels);
3259 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3261 int snd_hda_ch_mode_get(struct hda_codec *codec,
3262 struct snd_ctl_elem_value *ucontrol,
3263 const struct hda_channel_mode *chmode,
3269 for (i = 0; i < num_chmodes; i++) {
3270 if (max_channels == chmode[i].channels) {
3271 ucontrol->value.enumerated.item[0] = i;
3277 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3279 int snd_hda_ch_mode_put(struct hda_codec *codec,
3280 struct snd_ctl_elem_value *ucontrol,
3281 const struct hda_channel_mode *chmode,
3287 mode = ucontrol->value.enumerated.item[0];
3288 if (mode >= num_chmodes)
3290 if (*max_channelsp == chmode[mode].channels)
3292 /* change the current channel setting */
3293 *max_channelsp = chmode[mode].channels;
3294 if (chmode[mode].sequence)
3295 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3298 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3303 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3304 struct snd_ctl_elem_info *uinfo)
3308 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3310 uinfo->value.enumerated.items = imux->num_items;
3311 if (!imux->num_items)
3313 index = uinfo->value.enumerated.item;
3314 if (index >= imux->num_items)
3315 index = imux->num_items - 1;
3316 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3319 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3321 int snd_hda_input_mux_put(struct hda_codec *codec,
3322 const struct hda_input_mux *imux,
3323 struct snd_ctl_elem_value *ucontrol,
3325 unsigned int *cur_val)
3329 if (!imux->num_items)
3331 idx = ucontrol->value.enumerated.item[0];
3332 if (idx >= imux->num_items)
3333 idx = imux->num_items - 1;
3334 if (*cur_val == idx)
3336 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3337 imux->items[idx].index);
3341 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3345 * Multi-channel / digital-out PCM helper functions
3348 /* setup SPDIF output stream */
3349 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3350 unsigned int stream_tag, unsigned int format)
3352 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3353 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3354 set_dig_out_convert(codec, nid,
3355 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3357 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3358 if (codec->slave_dig_outs) {
3360 for (d = codec->slave_dig_outs; *d; d++)
3361 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3364 /* turn on again (if needed) */
3365 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3366 set_dig_out_convert(codec, nid,
3367 codec->spdif_ctls & 0xff, -1);
3370 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3372 snd_hda_codec_cleanup_stream(codec, nid);
3373 if (codec->slave_dig_outs) {
3375 for (d = codec->slave_dig_outs; *d; d++)
3376 snd_hda_codec_cleanup_stream(codec, *d);
3381 * open the digital out in the exclusive mode
3383 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3384 struct hda_multi_out *mout)
3386 mutex_lock(&codec->spdif_mutex);
3387 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3388 /* already opened as analog dup; reset it once */
3389 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3390 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3391 mutex_unlock(&codec->spdif_mutex);
3394 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3396 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3397 struct hda_multi_out *mout,
3398 unsigned int stream_tag,
3399 unsigned int format,
3400 struct snd_pcm_substream *substream)
3402 mutex_lock(&codec->spdif_mutex);
3403 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3404 mutex_unlock(&codec->spdif_mutex);
3407 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3409 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3410 struct hda_multi_out *mout)
3412 mutex_lock(&codec->spdif_mutex);
3413 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3414 mutex_unlock(&codec->spdif_mutex);
3417 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3420 * release the digital out
3422 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3423 struct hda_multi_out *mout)
3425 mutex_lock(&codec->spdif_mutex);
3426 mout->dig_out_used = 0;
3427 mutex_unlock(&codec->spdif_mutex);
3430 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3433 * set up more restrictions for analog out
3435 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3436 struct hda_multi_out *mout,
3437 struct snd_pcm_substream *substream,
3438 struct hda_pcm_stream *hinfo)
3440 struct snd_pcm_runtime *runtime = substream->runtime;
3441 runtime->hw.channels_max = mout->max_channels;
3442 if (mout->dig_out_nid) {
3443 if (!mout->analog_rates) {
3444 mout->analog_rates = hinfo->rates;
3445 mout->analog_formats = hinfo->formats;
3446 mout->analog_maxbps = hinfo->maxbps;
3448 runtime->hw.rates = mout->analog_rates;
3449 runtime->hw.formats = mout->analog_formats;
3450 hinfo->maxbps = mout->analog_maxbps;
3452 if (!mout->spdif_rates) {
3453 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3455 &mout->spdif_formats,
3456 &mout->spdif_maxbps);
3458 mutex_lock(&codec->spdif_mutex);
3459 if (mout->share_spdif) {
3460 runtime->hw.rates &= mout->spdif_rates;
3461 runtime->hw.formats &= mout->spdif_formats;
3462 if (mout->spdif_maxbps < hinfo->maxbps)
3463 hinfo->maxbps = mout->spdif_maxbps;
3465 mutex_unlock(&codec->spdif_mutex);
3467 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3468 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3470 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3473 * set up the i/o for analog out
3474 * when the digital out is available, copy the front out to digital out, too.
3476 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3477 struct hda_multi_out *mout,
3478 unsigned int stream_tag,
3479 unsigned int format,
3480 struct snd_pcm_substream *substream)
3482 hda_nid_t *nids = mout->dac_nids;
3483 int chs = substream->runtime->channels;
3486 mutex_lock(&codec->spdif_mutex);
3487 if (mout->dig_out_nid && mout->share_spdif &&
3488 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3490 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3492 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3493 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3494 setup_dig_out_stream(codec, mout->dig_out_nid,
3495 stream_tag, format);
3497 mout->dig_out_used = 0;
3498 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3501 mutex_unlock(&codec->spdif_mutex);
3504 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3506 if (!mout->no_share_stream &&
3507 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3508 /* headphone out will just decode front left/right (stereo) */
3509 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3511 /* extra outputs copied from front */
3512 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3513 if (!mout->no_share_stream && mout->extra_out_nid[i])
3514 snd_hda_codec_setup_stream(codec,
3515 mout->extra_out_nid[i],
3516 stream_tag, 0, format);
3519 for (i = 1; i < mout->num_dacs; i++) {
3520 if (chs >= (i + 1) * 2) /* independent out */
3521 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3523 else if (!mout->no_share_stream) /* copy front */
3524 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3529 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3532 * clean up the setting for analog out
3534 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3535 struct hda_multi_out *mout)
3537 hda_nid_t *nids = mout->dac_nids;
3540 for (i = 0; i < mout->num_dacs; i++)
3541 snd_hda_codec_cleanup_stream(codec, nids[i]);
3543 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3544 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3545 if (mout->extra_out_nid[i])
3546 snd_hda_codec_cleanup_stream(codec,
3547 mout->extra_out_nid[i]);
3548 mutex_lock(&codec->spdif_mutex);
3549 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3550 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3551 mout->dig_out_used = 0;
3553 mutex_unlock(&codec->spdif_mutex);
3556 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3559 * Helper for automatic pin configuration
3562 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3564 for (; *list; list++)
3572 * Sort an associated group of pins according to their sequence numbers.
3574 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3581 for (i = 0; i < num_pins; i++) {
3582 for (j = i + 1; j < num_pins; j++) {
3583 if (sequences[i] > sequences[j]) {
3585 sequences[i] = sequences[j];
3597 * Parse all pin widgets and store the useful pin nids to cfg
3599 * The number of line-outs or any primary output is stored in line_outs,
3600 * and the corresponding output pins are assigned to line_out_pins[],
3601 * in the order of front, rear, CLFE, side, ...
3603 * If more extra outputs (speaker and headphone) are found, the pins are
3604 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3605 * is detected, one of speaker of HP pins is assigned as the primary
3606 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3607 * if any analog output exists.
3609 * The analog input pins are assigned to input_pins array.
3610 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3613 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3614 struct auto_pin_cfg *cfg,
3615 hda_nid_t *ignore_nids)
3617 hda_nid_t nid, end_nid;
3618 short seq, assoc_line_out, assoc_speaker;
3619 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3620 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3621 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3623 memset(cfg, 0, sizeof(*cfg));
3625 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3626 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3627 memset(sequences_hp, 0, sizeof(sequences_hp));
3628 assoc_line_out = assoc_speaker = 0;
3630 end_nid = codec->start_nid + codec->num_nodes;
3631 for (nid = codec->start_nid; nid < end_nid; nid++) {
3632 unsigned int wid_caps = get_wcaps(codec, nid);
3633 unsigned int wid_type =
3634 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3635 unsigned int def_conf;
3638 /* read all default configuration for pin complex */
3639 if (wid_type != AC_WID_PIN)
3641 /* ignore the given nids (e.g. pc-beep returns error) */
3642 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3645 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3646 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3648 loc = get_defcfg_location(def_conf);
3649 switch (get_defcfg_device(def_conf)) {
3650 case AC_JACK_LINE_OUT:
3651 seq = get_defcfg_sequence(def_conf);
3652 assoc = get_defcfg_association(def_conf);
3654 if (!(wid_caps & AC_WCAP_STEREO))
3655 if (!cfg->mono_out_pin)
3656 cfg->mono_out_pin = nid;
3659 if (!assoc_line_out)
3660 assoc_line_out = assoc;
3661 else if (assoc_line_out != assoc)
3663 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3665 cfg->line_out_pins[cfg->line_outs] = nid;
3666 sequences_line_out[cfg->line_outs] = seq;
3669 case AC_JACK_SPEAKER:
3670 seq = get_defcfg_sequence(def_conf);
3671 assoc = get_defcfg_association(def_conf);
3674 if (! assoc_speaker)
3675 assoc_speaker = assoc;
3676 else if (assoc_speaker != assoc)
3678 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3680 cfg->speaker_pins[cfg->speaker_outs] = nid;
3681 sequences_speaker[cfg->speaker_outs] = seq;
3682 cfg->speaker_outs++;
3684 case AC_JACK_HP_OUT:
3685 seq = get_defcfg_sequence(def_conf);
3686 assoc = get_defcfg_association(def_conf);
3687 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3689 cfg->hp_pins[cfg->hp_outs] = nid;
3690 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3693 case AC_JACK_MIC_IN: {
3695 if (loc == AC_JACK_LOC_FRONT) {
3696 preferred = AUTO_PIN_FRONT_MIC;
3699 preferred = AUTO_PIN_MIC;
3700 alt = AUTO_PIN_FRONT_MIC;
3702 if (!cfg->input_pins[preferred])
3703 cfg->input_pins[preferred] = nid;
3704 else if (!cfg->input_pins[alt])
3705 cfg->input_pins[alt] = nid;
3708 case AC_JACK_LINE_IN:
3709 if (loc == AC_JACK_LOC_FRONT)
3710 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3712 cfg->input_pins[AUTO_PIN_LINE] = nid;
3715 cfg->input_pins[AUTO_PIN_CD] = nid;
3718 cfg->input_pins[AUTO_PIN_AUX] = nid;
3720 case AC_JACK_SPDIF_OUT:
3721 case AC_JACK_DIG_OTHER_OUT:
3722 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3724 cfg->dig_out_pins[cfg->dig_outs] = nid;
3725 cfg->dig_out_type[cfg->dig_outs] =
3726 (loc == AC_JACK_LOC_HDMI) ?
3727 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3730 case AC_JACK_SPDIF_IN:
3731 case AC_JACK_DIG_OTHER_IN:
3732 cfg->dig_in_pin = nid;
3733 if (loc == AC_JACK_LOC_HDMI)
3734 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3736 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
3742 * If no line-out is defined but multiple HPs are found,
3743 * some of them might be the real line-outs.
3745 if (!cfg->line_outs && cfg->hp_outs > 1) {
3747 while (i < cfg->hp_outs) {
3748 /* The real HPs should have the sequence 0x0f */
3749 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3753 /* Move it to the line-out table */
3754 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3755 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3758 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3759 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3760 memmove(sequences_hp + i - 1, sequences_hp + i,
3761 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3765 /* sort by sequence */
3766 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3768 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3770 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3773 /* if we have only one mic, make it AUTO_PIN_MIC */
3774 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3775 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3776 cfg->input_pins[AUTO_PIN_MIC] =
3777 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3778 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3780 /* ditto for line-in */
3781 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3782 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3783 cfg->input_pins[AUTO_PIN_LINE] =
3784 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3785 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3789 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3790 * as a primary output
3792 if (!cfg->line_outs) {
3793 if (cfg->speaker_outs) {
3794 cfg->line_outs = cfg->speaker_outs;
3795 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3796 sizeof(cfg->speaker_pins));
3797 cfg->speaker_outs = 0;
3798 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3799 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3800 } else if (cfg->hp_outs) {
3801 cfg->line_outs = cfg->hp_outs;
3802 memcpy(cfg->line_out_pins, cfg->hp_pins,
3803 sizeof(cfg->hp_pins));
3805 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3806 cfg->line_out_type = AUTO_PIN_HP_OUT;
3810 /* Reorder the surround channels
3811 * ALSA sequence is front/surr/clfe/side
3813 * 4-ch: front/surr => OK as it is
3814 * 6-ch: front/clfe/surr
3815 * 8-ch: front/clfe/rear/side|fc
3817 switch (cfg->line_outs) {
3820 nid = cfg->line_out_pins[1];
3821 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3822 cfg->line_out_pins[2] = nid;
3827 * debug prints of the parsed results
3829 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3830 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3831 cfg->line_out_pins[2], cfg->line_out_pins[3],
3832 cfg->line_out_pins[4]);
3833 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3834 cfg->speaker_outs, cfg->speaker_pins[0],
3835 cfg->speaker_pins[1], cfg->speaker_pins[2],
3836 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3837 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3838 cfg->hp_outs, cfg->hp_pins[0],
3839 cfg->hp_pins[1], cfg->hp_pins[2],
3840 cfg->hp_pins[3], cfg->hp_pins[4]);
3841 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3843 snd_printd(" dig-out=0x%x/0x%x\n",
3844 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
3845 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3846 " cd=0x%x, aux=0x%x\n",
3847 cfg->input_pins[AUTO_PIN_MIC],
3848 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3849 cfg->input_pins[AUTO_PIN_LINE],
3850 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3851 cfg->input_pins[AUTO_PIN_CD],
3852 cfg->input_pins[AUTO_PIN_AUX]);
3853 if (cfg->dig_in_pin)
3854 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
3858 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3860 /* labels for input pins */
3861 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3862 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3864 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3873 * snd_hda_suspend - suspend the codecs
3875 * @state: suspsend state
3877 * Returns 0 if successful.
3879 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3881 struct hda_codec *codec;
3883 list_for_each_entry(codec, &bus->codec_list, list) {
3884 #ifdef CONFIG_SND_HDA_POWER_SAVE
3885 if (!codec->power_on)
3888 hda_call_codec_suspend(codec);
3892 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3895 * snd_hda_resume - resume the codecs
3898 * Returns 0 if successful.
3900 * This fucntion is defined only when POWER_SAVE isn't set.
3901 * In the power-save mode, the codec is resumed dynamically.
3903 int snd_hda_resume(struct hda_bus *bus)
3905 struct hda_codec *codec;
3907 list_for_each_entry(codec, &bus->codec_list, list) {
3908 if (snd_hda_codec_needs_resume(codec))
3909 hda_call_codec_resume(codec);
3913 EXPORT_SYMBOL_HDA(snd_hda_resume);
3914 #endif /* CONFIG_PM */
3920 /* get a new element from the given array
3921 * if it exceeds the pre-allocated array size, re-allocate the array
3923 void *snd_array_new(struct snd_array *array)
3925 if (array->used >= array->alloced) {
3926 int num = array->alloced + array->alloc_align;
3928 if (snd_BUG_ON(num >= 4096))
3930 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3934 memcpy(nlist, array->list,
3935 array->elem_size * array->alloced);
3938 array->list = nlist;
3939 array->alloced = num;
3941 return snd_array_elem(array, array->used++);
3943 EXPORT_SYMBOL_HDA(snd_array_new);
3945 /* free the given array elements */
3946 void snd_array_free(struct snd_array *array)
3953 EXPORT_SYMBOL_HDA(snd_array_free);
3956 * used by hda_proc.c and hda_eld.c
3958 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3960 static unsigned int rates[] = {
3961 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3962 96000, 176400, 192000, 384000
3966 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3968 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3970 buf[j] = '\0'; /* necessary when j == 0 */
3972 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3974 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3976 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3979 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3980 if (pcm & (AC_SUPPCM_BITS_8 << i))
3981 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3983 buf[j] = '\0'; /* necessary when j == 0 */
3985 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
3987 MODULE_DESCRIPTION("HDA codec core");
3988 MODULE_LICENSE("GPL");