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;
628 if (codec->vendor_name)
631 for (c = hda_vendor_ids; c->id; c++) {
632 if (c->id == vendor_id) {
638 sprintf(tmp, "Generic %04x", vendor_id);
641 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
642 if (!codec->vendor_name)
646 if (codec->chip_name)
649 if (codec->preset && codec->preset->name)
650 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
652 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
653 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
655 if (!codec->chip_name)
661 * look for an AFG and MFG nodes
663 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
665 int i, total_nodes, function_id;
668 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
669 for (i = 0; i < total_nodes; i++, nid++) {
670 function_id = snd_hda_param_read(codec, nid,
671 AC_PAR_FUNCTION_TYPE) & 0xff;
672 switch (function_id) {
673 case AC_GRP_AUDIO_FUNCTION:
675 codec->function_id = function_id;
677 case AC_GRP_MODEM_FUNCTION:
679 codec->function_id = function_id;
688 * read widget caps for each widget and store in cache
690 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
695 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
697 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
700 nid = codec->start_nid;
701 for (i = 0; i < codec->num_nodes; i++, nid++)
702 codec->wcaps[i] = snd_hda_param_read(codec, nid,
703 AC_PAR_AUDIO_WIDGET_CAP);
707 /* read all pin default configurations and save codec->init_pins */
708 static int read_pin_defaults(struct hda_codec *codec)
711 hda_nid_t nid = codec->start_nid;
713 for (i = 0; i < codec->num_nodes; i++, nid++) {
714 struct hda_pincfg *pin;
715 unsigned int wcaps = get_wcaps(codec, nid);
716 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
718 if (wid_type != AC_WID_PIN)
720 pin = snd_array_new(&codec->init_pins);
724 pin->cfg = snd_hda_codec_read(codec, nid, 0,
725 AC_VERB_GET_CONFIG_DEFAULT, 0);
730 /* look up the given pin config list and return the item matching with NID */
731 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
732 struct snd_array *array,
736 for (i = 0; i < array->used; i++) {
737 struct hda_pincfg *pin = snd_array_elem(array, i);
744 /* write a config value for the given NID */
745 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
749 for (i = 0; i < 4; i++) {
750 snd_hda_codec_write(codec, nid, 0,
751 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
757 /* set the current pin config value for the given NID.
758 * the value is cached, and read via snd_hda_codec_get_pincfg()
760 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
761 hda_nid_t nid, unsigned int cfg)
763 struct hda_pincfg *pin;
766 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
767 pin = look_up_pincfg(codec, list, nid);
769 pin = snd_array_new(list);
776 /* change only when needed; e.g. if the pincfg is already present
777 * in user_pins[], don't write it
779 cfg = snd_hda_codec_get_pincfg(codec, nid);
781 set_pincfg(codec, nid, cfg);
785 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
786 hda_nid_t nid, unsigned int cfg)
788 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
790 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
792 /* get the current pin config value of the given pin NID */
793 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
795 struct hda_pincfg *pin;
797 #ifdef CONFIG_SND_HDA_HWDEP
798 pin = look_up_pincfg(codec, &codec->user_pins, nid);
802 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
805 pin = look_up_pincfg(codec, &codec->init_pins, nid);
810 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
812 /* restore all current pin configs */
813 static void restore_pincfgs(struct hda_codec *codec)
816 for (i = 0; i < codec->init_pins.used; i++) {
817 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
818 set_pincfg(codec, pin->nid,
819 snd_hda_codec_get_pincfg(codec, pin->nid));
823 static void init_hda_cache(struct hda_cache_rec *cache,
824 unsigned int record_size);
825 static void free_hda_cache(struct hda_cache_rec *cache);
827 /* restore the initial pin cfgs and release all pincfg lists */
828 static void restore_init_pincfgs(struct hda_codec *codec)
830 /* first free driver_pins and user_pins, then call restore_pincfg
831 * so that only the values in init_pins are restored
833 snd_array_free(&codec->driver_pins);
834 #ifdef CONFIG_SND_HDA_HWDEP
835 snd_array_free(&codec->user_pins);
837 restore_pincfgs(codec);
838 snd_array_free(&codec->init_pins);
844 static void snd_hda_codec_free(struct hda_codec *codec)
848 restore_init_pincfgs(codec);
849 #ifdef CONFIG_SND_HDA_POWER_SAVE
850 cancel_delayed_work(&codec->power_work);
851 flush_workqueue(codec->bus->workq);
853 list_del(&codec->list);
854 snd_array_free(&codec->mixers);
855 codec->bus->caddr_tbl[codec->addr] = NULL;
856 if (codec->patch_ops.free)
857 codec->patch_ops.free(codec);
858 module_put(codec->owner);
859 free_hda_cache(&codec->amp_cache);
860 free_hda_cache(&codec->cmd_cache);
861 kfree(codec->vendor_name);
862 kfree(codec->chip_name);
863 kfree(codec->modelname);
868 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
869 unsigned int power_state);
872 * snd_hda_codec_new - create a HDA codec
873 * @bus: the bus to assign
874 * @codec_addr: the codec address
875 * @codecp: the pointer to store the generated codec
877 * Returns 0 if successful, or a negative error code.
879 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
880 int do_init, struct hda_codec **codecp)
882 struct hda_codec *codec;
886 if (snd_BUG_ON(!bus))
888 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
891 if (bus->caddr_tbl[codec_addr]) {
892 snd_printk(KERN_ERR "hda_codec: "
893 "address 0x%x is already occupied\n", codec_addr);
897 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
899 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
904 codec->addr = codec_addr;
905 mutex_init(&codec->spdif_mutex);
906 mutex_init(&codec->control_mutex);
907 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
908 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
909 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
910 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
911 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
912 if (codec->bus->modelname) {
913 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
914 if (!codec->modelname) {
915 snd_hda_codec_free(codec);
920 #ifdef CONFIG_SND_HDA_POWER_SAVE
921 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
922 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
923 * the caller has to power down appropriatley after initialization
926 hda_keep_power_on(codec);
929 list_add_tail(&codec->list, &bus->codec_list);
930 bus->caddr_tbl[codec_addr] = codec;
932 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
934 if (codec->vendor_id == -1)
935 /* read again, hopefully the access method was corrected
936 * in the last read...
938 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
940 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
941 AC_PAR_SUBSYSTEM_ID);
942 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
945 setup_fg_nodes(codec);
946 if (!codec->afg && !codec->mfg) {
947 snd_printdd("hda_codec: no AFG or MFG node found\n");
952 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
954 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
957 err = read_pin_defaults(codec);
961 if (!codec->subsystem_id) {
962 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
963 codec->subsystem_id =
964 snd_hda_codec_read(codec, nid, 0,
965 AC_VERB_GET_SUBSYSTEM_ID, 0);
968 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
970 /* power-up all before initialization */
971 hda_set_power_state(codec,
972 codec->afg ? codec->afg : codec->mfg,
976 err = snd_hda_codec_configure(codec);
980 snd_hda_codec_proc_new(codec);
982 snd_hda_create_hwdep(codec);
984 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
985 codec->subsystem_id, codec->revision_id);
986 snd_component_add(codec->bus->card, component);
993 snd_hda_codec_free(codec);
996 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
998 int snd_hda_codec_configure(struct hda_codec *codec)
1002 codec->preset = find_codec_preset(codec);
1003 if (!codec->vendor_name || !codec->chip_name) {
1004 err = get_codec_name(codec);
1008 /* audio codec should override the mixer name */
1009 if (codec->afg || !*codec->bus->card->mixername)
1010 snprintf(codec->bus->card->mixername,
1011 sizeof(codec->bus->card->mixername),
1012 "%s %s", codec->vendor_name, codec->chip_name);
1014 if (is_generic_config(codec)) {
1015 err = snd_hda_parse_generic_codec(codec);
1018 if (codec->preset && codec->preset->patch) {
1019 err = codec->preset->patch(codec);
1023 /* call the default parser */
1024 err = snd_hda_parse_generic_codec(codec);
1026 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1029 if (!err && codec->patch_ops.unsol_event)
1030 err = init_unsol_queue(codec->bus);
1035 * snd_hda_codec_setup_stream - set up the codec for streaming
1036 * @codec: the CODEC to set up
1037 * @nid: the NID to set up
1038 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1039 * @channel_id: channel id to pass, zero based.
1040 * @format: stream format.
1042 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1044 int channel_id, int format)
1049 snd_printdd("hda_codec_setup_stream: "
1050 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1051 nid, stream_tag, channel_id, format);
1052 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1053 (stream_tag << 4) | channel_id);
1055 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1057 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1059 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1064 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1065 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1066 #if 0 /* keep the format */
1068 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1071 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
1074 * amp access functions
1077 /* FIXME: more better hash key? */
1078 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1079 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1080 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1081 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1082 #define INFO_AMP_CAPS (1<<0)
1083 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1085 /* initialize the hash table */
1086 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1087 unsigned int record_size)
1089 memset(cache, 0, sizeof(*cache));
1090 memset(cache->hash, 0xff, sizeof(cache->hash));
1091 snd_array_init(&cache->buf, record_size, 64);
1094 static void free_hda_cache(struct hda_cache_rec *cache)
1096 snd_array_free(&cache->buf);
1099 /* query the hash. allocate an entry if not found. */
1100 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1103 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1104 u16 cur = cache->hash[idx];
1105 struct hda_cache_head *info;
1107 while (cur != 0xffff) {
1108 info = snd_array_elem(&cache->buf, cur);
1109 if (info->key == key)
1114 /* add a new hash entry */
1115 info = snd_array_new(&cache->buf);
1118 cur = snd_array_index(&cache->buf, info);
1121 info->next = cache->hash[idx];
1122 cache->hash[idx] = cur;
1127 /* query and allocate an amp hash entry */
1128 static inline struct hda_amp_info *
1129 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1131 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1135 * query AMP capabilities for the given widget and direction
1137 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1139 struct hda_amp_info *info;
1141 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1144 if (!(info->head.val & INFO_AMP_CAPS)) {
1145 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1147 info->amp_caps = snd_hda_param_read(codec, nid,
1148 direction == HDA_OUTPUT ?
1149 AC_PAR_AMP_OUT_CAP :
1152 info->head.val |= INFO_AMP_CAPS;
1154 return info->amp_caps;
1156 EXPORT_SYMBOL_HDA(query_amp_caps);
1158 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1161 struct hda_amp_info *info;
1163 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1166 info->amp_caps = caps;
1167 info->head.val |= INFO_AMP_CAPS;
1170 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1173 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1174 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1176 struct hda_amp_info *info;
1178 info = get_alloc_amp_hash(codec, key);
1181 if (!info->head.val) {
1182 info->head.val |= INFO_AMP_CAPS;
1183 info->amp_caps = func(codec, nid);
1185 return info->amp_caps;
1188 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1190 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1193 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1195 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1198 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1201 * read the current volume to info
1202 * if the cache exists, read the cache value.
1204 static unsigned int get_vol_mute(struct hda_codec *codec,
1205 struct hda_amp_info *info, hda_nid_t nid,
1206 int ch, int direction, int index)
1210 if (info->head.val & INFO_AMP_VOL(ch))
1211 return info->vol[ch];
1213 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1214 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1216 val = snd_hda_codec_read(codec, nid, 0,
1217 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1218 info->vol[ch] = val & 0xff;
1219 info->head.val |= INFO_AMP_VOL(ch);
1220 return info->vol[ch];
1224 * write the current volume in info to the h/w and update the cache
1226 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1227 hda_nid_t nid, int ch, int direction, int index,
1232 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1233 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1234 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1236 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1237 info->vol[ch] = val;
1241 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1243 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1244 int direction, int index)
1246 struct hda_amp_info *info;
1247 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1250 return get_vol_mute(codec, info, nid, ch, direction, index);
1252 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1255 * update the AMP value, mask = bit mask to set, val = the value
1257 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1258 int direction, int idx, int mask, int val)
1260 struct hda_amp_info *info;
1262 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1266 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1267 if (info->vol[ch] == val)
1269 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1272 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1275 * update the AMP stereo with the same mask and value
1277 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1278 int direction, int idx, int mask, int val)
1281 for (ch = 0; ch < 2; ch++)
1282 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1286 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1288 #ifdef SND_HDA_NEEDS_RESUME
1289 /* resume the all amp commands from the cache */
1290 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1292 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1295 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1296 u32 key = buffer->head.key;
1298 unsigned int idx, dir, ch;
1302 idx = (key >> 16) & 0xff;
1303 dir = (key >> 24) & 0xff;
1304 for (ch = 0; ch < 2; ch++) {
1305 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1307 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1312 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1313 #endif /* SND_HDA_NEEDS_RESUME */
1316 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1317 struct snd_ctl_elem_info *uinfo)
1319 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1320 u16 nid = get_amp_nid(kcontrol);
1321 u8 chs = get_amp_channels(kcontrol);
1322 int dir = get_amp_direction(kcontrol);
1323 unsigned int ofs = get_amp_offset(kcontrol);
1326 caps = query_amp_caps(codec, nid, dir);
1328 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1330 printk(KERN_WARNING "hda_codec: "
1331 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1337 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1338 uinfo->count = chs == 3 ? 2 : 1;
1339 uinfo->value.integer.min = 0;
1340 uinfo->value.integer.max = caps;
1343 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1346 static inline unsigned int
1347 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1348 int ch, int dir, int idx, unsigned int ofs)
1351 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1352 val &= HDA_AMP_VOLMASK;
1361 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1362 int ch, int dir, int idx, unsigned int ofs,
1367 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1368 HDA_AMP_VOLMASK, val);
1371 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1372 struct snd_ctl_elem_value *ucontrol)
1374 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1375 hda_nid_t nid = get_amp_nid(kcontrol);
1376 int chs = get_amp_channels(kcontrol);
1377 int dir = get_amp_direction(kcontrol);
1378 int idx = get_amp_index(kcontrol);
1379 unsigned int ofs = get_amp_offset(kcontrol);
1380 long *valp = ucontrol->value.integer.value;
1383 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1385 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1388 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1390 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1391 struct snd_ctl_elem_value *ucontrol)
1393 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1394 hda_nid_t nid = get_amp_nid(kcontrol);
1395 int chs = get_amp_channels(kcontrol);
1396 int dir = get_amp_direction(kcontrol);
1397 int idx = get_amp_index(kcontrol);
1398 unsigned int ofs = get_amp_offset(kcontrol);
1399 long *valp = ucontrol->value.integer.value;
1402 snd_hda_power_up(codec);
1404 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1408 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1409 snd_hda_power_down(codec);
1412 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1414 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1415 unsigned int size, unsigned int __user *_tlv)
1417 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1418 hda_nid_t nid = get_amp_nid(kcontrol);
1419 int dir = get_amp_direction(kcontrol);
1420 unsigned int ofs = get_amp_offset(kcontrol);
1421 u32 caps, val1, val2;
1423 if (size < 4 * sizeof(unsigned int))
1425 caps = query_amp_caps(codec, nid, dir);
1426 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1427 val2 = (val2 + 1) * 25;
1428 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1430 val1 = ((int)val1) * ((int)val2);
1431 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1433 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1435 if (put_user(val1, _tlv + 2))
1437 if (put_user(val2, _tlv + 3))
1441 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1444 * set (static) TLV for virtual master volume; recalculated as max 0dB
1446 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1452 caps = query_amp_caps(codec, nid, dir);
1453 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1454 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1455 step = (step + 1) * 25;
1456 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1457 tlv[1] = 2 * sizeof(unsigned int);
1458 tlv[2] = -nums * step;
1461 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1463 /* find a mixer control element with the given name */
1464 static struct snd_kcontrol *
1465 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1466 const char *name, int idx)
1468 struct snd_ctl_elem_id id;
1469 memset(&id, 0, sizeof(id));
1470 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1472 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1474 strcpy(id.name, name);
1475 return snd_ctl_find_id(codec->bus->card, &id);
1478 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1481 return _snd_hda_find_mixer_ctl(codec, name, 0);
1483 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1485 /* Add a control element and assign to the codec */
1486 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1489 struct snd_kcontrol **knewp;
1491 err = snd_ctl_add(codec->bus->card, kctl);
1494 knewp = snd_array_new(&codec->mixers);
1500 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1502 /* Clear all controls assigned to the given codec */
1503 void snd_hda_ctls_clear(struct hda_codec *codec)
1506 struct snd_kcontrol **kctls = codec->mixers.list;
1507 for (i = 0; i < codec->mixers.used; i++)
1508 snd_ctl_remove(codec->bus->card, kctls[i]);
1509 snd_array_free(&codec->mixers);
1512 /* pseudo device locking
1513 * toggle card->shutdown to allow/disallow the device access (as a hack)
1515 static int hda_lock_devices(struct snd_card *card)
1517 spin_lock(&card->files_lock);
1518 if (card->shutdown) {
1519 spin_unlock(&card->files_lock);
1523 spin_unlock(&card->files_lock);
1527 static void hda_unlock_devices(struct snd_card *card)
1529 spin_lock(&card->files_lock);
1531 spin_unlock(&card->files_lock);
1534 int snd_hda_codec_reset(struct hda_codec *codec)
1536 struct snd_card *card = codec->bus->card;
1539 if (hda_lock_devices(card) < 0)
1541 /* check whether the codec isn't used by any mixer or PCM streams */
1542 if (!list_empty(&card->ctl_files)) {
1543 hda_unlock_devices(card);
1546 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1547 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1550 if (cpcm->pcm->streams[0].substream_opened ||
1551 cpcm->pcm->streams[1].substream_opened) {
1552 hda_unlock_devices(card);
1557 /* OK, let it free */
1559 #ifdef CONFIG_SND_HDA_POWER_SAVE
1560 cancel_delayed_work(&codec->power_work);
1561 flush_workqueue(codec->bus->workq);
1563 snd_hda_ctls_clear(codec);
1565 for (i = 0; i < codec->num_pcms; i++) {
1566 if (codec->pcm_info[i].pcm) {
1567 snd_device_free(card, codec->pcm_info[i].pcm);
1568 clear_bit(codec->pcm_info[i].device,
1569 codec->bus->pcm_dev_bits);
1572 if (codec->patch_ops.free)
1573 codec->patch_ops.free(codec);
1574 codec->proc_widget_hook = NULL;
1576 free_hda_cache(&codec->amp_cache);
1577 free_hda_cache(&codec->cmd_cache);
1578 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1579 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1580 /* free only driver_pins so that init_pins + user_pins are restored */
1581 snd_array_free(&codec->driver_pins);
1582 restore_pincfgs(codec);
1583 codec->num_pcms = 0;
1584 codec->pcm_info = NULL;
1585 codec->preset = NULL;
1586 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1587 codec->slave_dig_outs = NULL;
1588 codec->spdif_status_reset = 0;
1589 module_put(codec->owner);
1590 codec->owner = NULL;
1592 /* allow device access again */
1593 hda_unlock_devices(card);
1597 /* create a virtual master control and add slaves */
1598 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1599 unsigned int *tlv, const char **slaves)
1601 struct snd_kcontrol *kctl;
1605 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1608 snd_printdd("No slave found for %s\n", name);
1611 kctl = snd_ctl_make_virtual_master(name, tlv);
1614 err = snd_hda_ctl_add(codec, kctl);
1618 for (s = slaves; *s; s++) {
1619 struct snd_kcontrol *sctl;
1622 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1625 snd_printdd("Cannot find slave %s, "
1629 err = snd_ctl_add_slave(kctl, sctl);
1637 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1640 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1641 struct snd_ctl_elem_info *uinfo)
1643 int chs = get_amp_channels(kcontrol);
1645 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1646 uinfo->count = chs == 3 ? 2 : 1;
1647 uinfo->value.integer.min = 0;
1648 uinfo->value.integer.max = 1;
1651 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1653 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1654 struct snd_ctl_elem_value *ucontrol)
1656 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1657 hda_nid_t nid = get_amp_nid(kcontrol);
1658 int chs = get_amp_channels(kcontrol);
1659 int dir = get_amp_direction(kcontrol);
1660 int idx = get_amp_index(kcontrol);
1661 long *valp = ucontrol->value.integer.value;
1664 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1665 HDA_AMP_MUTE) ? 0 : 1;
1667 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1668 HDA_AMP_MUTE) ? 0 : 1;
1671 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1673 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1674 struct snd_ctl_elem_value *ucontrol)
1676 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1677 hda_nid_t nid = get_amp_nid(kcontrol);
1678 int chs = get_amp_channels(kcontrol);
1679 int dir = get_amp_direction(kcontrol);
1680 int idx = get_amp_index(kcontrol);
1681 long *valp = ucontrol->value.integer.value;
1684 snd_hda_power_up(codec);
1686 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1688 *valp ? 0 : HDA_AMP_MUTE);
1692 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1694 *valp ? 0 : HDA_AMP_MUTE);
1695 #ifdef CONFIG_SND_HDA_POWER_SAVE
1696 if (codec->patch_ops.check_power_status)
1697 codec->patch_ops.check_power_status(codec, nid);
1699 snd_hda_power_down(codec);
1702 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1705 * bound volume controls
1707 * bind multiple volumes (# indices, from 0)
1710 #define AMP_VAL_IDX_SHIFT 19
1711 #define AMP_VAL_IDX_MASK (0x0f<<19)
1713 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1714 struct snd_ctl_elem_value *ucontrol)
1716 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1720 mutex_lock(&codec->control_mutex);
1721 pval = kcontrol->private_value;
1722 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1723 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1724 kcontrol->private_value = pval;
1725 mutex_unlock(&codec->control_mutex);
1728 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1730 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1731 struct snd_ctl_elem_value *ucontrol)
1733 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1735 int i, indices, err = 0, change = 0;
1737 mutex_lock(&codec->control_mutex);
1738 pval = kcontrol->private_value;
1739 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1740 for (i = 0; i < indices; i++) {
1741 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1742 (i << AMP_VAL_IDX_SHIFT);
1743 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1748 kcontrol->private_value = pval;
1749 mutex_unlock(&codec->control_mutex);
1750 return err < 0 ? err : change;
1752 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1755 * generic bound volume/swtich controls
1757 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1758 struct snd_ctl_elem_info *uinfo)
1760 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1761 struct hda_bind_ctls *c;
1764 mutex_lock(&codec->control_mutex);
1765 c = (struct hda_bind_ctls *)kcontrol->private_value;
1766 kcontrol->private_value = *c->values;
1767 err = c->ops->info(kcontrol, uinfo);
1768 kcontrol->private_value = (long)c;
1769 mutex_unlock(&codec->control_mutex);
1772 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1774 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1775 struct snd_ctl_elem_value *ucontrol)
1777 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1778 struct hda_bind_ctls *c;
1781 mutex_lock(&codec->control_mutex);
1782 c = (struct hda_bind_ctls *)kcontrol->private_value;
1783 kcontrol->private_value = *c->values;
1784 err = c->ops->get(kcontrol, ucontrol);
1785 kcontrol->private_value = (long)c;
1786 mutex_unlock(&codec->control_mutex);
1789 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1791 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1792 struct snd_ctl_elem_value *ucontrol)
1794 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1795 struct hda_bind_ctls *c;
1796 unsigned long *vals;
1797 int err = 0, change = 0;
1799 mutex_lock(&codec->control_mutex);
1800 c = (struct hda_bind_ctls *)kcontrol->private_value;
1801 for (vals = c->values; *vals; vals++) {
1802 kcontrol->private_value = *vals;
1803 err = c->ops->put(kcontrol, ucontrol);
1808 kcontrol->private_value = (long)c;
1809 mutex_unlock(&codec->control_mutex);
1810 return err < 0 ? err : change;
1812 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1814 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1815 unsigned int size, unsigned int __user *tlv)
1817 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1818 struct hda_bind_ctls *c;
1821 mutex_lock(&codec->control_mutex);
1822 c = (struct hda_bind_ctls *)kcontrol->private_value;
1823 kcontrol->private_value = *c->values;
1824 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1825 kcontrol->private_value = (long)c;
1826 mutex_unlock(&codec->control_mutex);
1829 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1831 struct hda_ctl_ops snd_hda_bind_vol = {
1832 .info = snd_hda_mixer_amp_volume_info,
1833 .get = snd_hda_mixer_amp_volume_get,
1834 .put = snd_hda_mixer_amp_volume_put,
1835 .tlv = snd_hda_mixer_amp_tlv
1837 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1839 struct hda_ctl_ops snd_hda_bind_sw = {
1840 .info = snd_hda_mixer_amp_switch_info,
1841 .get = snd_hda_mixer_amp_switch_get,
1842 .put = snd_hda_mixer_amp_switch_put,
1843 .tlv = snd_hda_mixer_amp_tlv
1845 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1848 * SPDIF out controls
1851 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1852 struct snd_ctl_elem_info *uinfo)
1854 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1859 static int snd_hda_spdif_cmask_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_CON_EMPHASIS_5015 |
1865 IEC958_AES0_CON_NOT_COPYRIGHT;
1866 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1867 IEC958_AES1_CON_ORIGINAL;
1871 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1872 struct snd_ctl_elem_value *ucontrol)
1874 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1875 IEC958_AES0_NONAUDIO |
1876 IEC958_AES0_PRO_EMPHASIS_5015;
1880 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1881 struct snd_ctl_elem_value *ucontrol)
1883 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1885 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1886 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1887 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1888 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1893 /* convert from SPDIF status bits to HDA SPDIF bits
1894 * bit 0 (DigEn) is always set zero (to be filled later)
1896 static unsigned short convert_from_spdif_status(unsigned int sbits)
1898 unsigned short val = 0;
1900 if (sbits & IEC958_AES0_PROFESSIONAL)
1901 val |= AC_DIG1_PROFESSIONAL;
1902 if (sbits & IEC958_AES0_NONAUDIO)
1903 val |= AC_DIG1_NONAUDIO;
1904 if (sbits & IEC958_AES0_PROFESSIONAL) {
1905 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1906 IEC958_AES0_PRO_EMPHASIS_5015)
1907 val |= AC_DIG1_EMPHASIS;
1909 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1910 IEC958_AES0_CON_EMPHASIS_5015)
1911 val |= AC_DIG1_EMPHASIS;
1912 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1913 val |= AC_DIG1_COPYRIGHT;
1914 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1915 val |= AC_DIG1_LEVEL;
1916 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1921 /* convert to SPDIF status bits from HDA SPDIF bits
1923 static unsigned int convert_to_spdif_status(unsigned short val)
1925 unsigned int sbits = 0;
1927 if (val & AC_DIG1_NONAUDIO)
1928 sbits |= IEC958_AES0_NONAUDIO;
1929 if (val & AC_DIG1_PROFESSIONAL)
1930 sbits |= IEC958_AES0_PROFESSIONAL;
1931 if (sbits & IEC958_AES0_PROFESSIONAL) {
1932 if (sbits & AC_DIG1_EMPHASIS)
1933 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1935 if (val & AC_DIG1_EMPHASIS)
1936 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1937 if (!(val & AC_DIG1_COPYRIGHT))
1938 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1939 if (val & AC_DIG1_LEVEL)
1940 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1941 sbits |= val & (0x7f << 8);
1946 /* set digital convert verbs both for the given NID and its slaves */
1947 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1952 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1953 d = codec->slave_dig_outs;
1957 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1960 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1964 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1966 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1969 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1970 struct snd_ctl_elem_value *ucontrol)
1972 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1973 hda_nid_t nid = kcontrol->private_value;
1977 mutex_lock(&codec->spdif_mutex);
1978 codec->spdif_status = ucontrol->value.iec958.status[0] |
1979 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1980 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1981 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1982 val = convert_from_spdif_status(codec->spdif_status);
1983 val |= codec->spdif_ctls & 1;
1984 change = codec->spdif_ctls != val;
1985 codec->spdif_ctls = val;
1988 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1990 mutex_unlock(&codec->spdif_mutex);
1994 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1996 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1997 struct snd_ctl_elem_value *ucontrol)
1999 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2001 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
2005 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2006 struct snd_ctl_elem_value *ucontrol)
2008 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2009 hda_nid_t nid = kcontrol->private_value;
2013 mutex_lock(&codec->spdif_mutex);
2014 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2015 if (ucontrol->value.integer.value[0])
2016 val |= AC_DIG1_ENABLE;
2017 change = codec->spdif_ctls != val;
2019 codec->spdif_ctls = val;
2020 set_dig_out_convert(codec, nid, val & 0xff, -1);
2021 /* unmute amp switch (if any) */
2022 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2023 (val & AC_DIG1_ENABLE))
2024 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2027 mutex_unlock(&codec->spdif_mutex);
2031 static struct snd_kcontrol_new dig_mixes[] = {
2033 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2034 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2035 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2036 .info = snd_hda_spdif_mask_info,
2037 .get = snd_hda_spdif_cmask_get,
2040 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2041 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2042 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2043 .info = snd_hda_spdif_mask_info,
2044 .get = snd_hda_spdif_pmask_get,
2047 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2048 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2049 .info = snd_hda_spdif_mask_info,
2050 .get = snd_hda_spdif_default_get,
2051 .put = snd_hda_spdif_default_put,
2054 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2055 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2056 .info = snd_hda_spdif_out_switch_info,
2057 .get = snd_hda_spdif_out_switch_get,
2058 .put = snd_hda_spdif_out_switch_put,
2063 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2066 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2067 * @codec: the HDA codec
2068 * @nid: audio out widget NID
2070 * Creates controls related with the SPDIF output.
2071 * Called from each patch supporting the SPDIF out.
2073 * Returns 0 if successful, or a negative error code.
2075 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2078 struct snd_kcontrol *kctl;
2079 struct snd_kcontrol_new *dig_mix;
2082 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2083 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2087 if (idx >= SPDIF_MAX_IDX) {
2088 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2091 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2092 kctl = snd_ctl_new1(dig_mix, codec);
2095 kctl->id.index = idx;
2096 kctl->private_value = nid;
2097 err = snd_hda_ctl_add(codec, kctl);
2102 snd_hda_codec_read(codec, nid, 0,
2103 AC_VERB_GET_DIGI_CONVERT_1, 0);
2104 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2107 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2110 * SPDIF sharing with analog output
2112 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2113 struct snd_ctl_elem_value *ucontrol)
2115 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2116 ucontrol->value.integer.value[0] = mout->share_spdif;
2120 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2121 struct snd_ctl_elem_value *ucontrol)
2123 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2124 mout->share_spdif = !!ucontrol->value.integer.value[0];
2128 static struct snd_kcontrol_new spdif_share_sw = {
2129 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2130 .name = "IEC958 Default PCM Playback Switch",
2131 .info = snd_ctl_boolean_mono_info,
2132 .get = spdif_share_sw_get,
2133 .put = spdif_share_sw_put,
2136 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2137 struct hda_multi_out *mout)
2139 if (!mout->dig_out_nid)
2141 /* ATTENTION: here mout is passed as private_data, instead of codec */
2142 return snd_hda_ctl_add(codec,
2143 snd_ctl_new1(&spdif_share_sw, mout));
2145 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2151 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2153 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2154 struct snd_ctl_elem_value *ucontrol)
2156 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2158 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2162 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2163 struct snd_ctl_elem_value *ucontrol)
2165 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2166 hda_nid_t nid = kcontrol->private_value;
2167 unsigned int val = !!ucontrol->value.integer.value[0];
2170 mutex_lock(&codec->spdif_mutex);
2171 change = codec->spdif_in_enable != val;
2173 codec->spdif_in_enable = val;
2174 snd_hda_codec_write_cache(codec, nid, 0,
2175 AC_VERB_SET_DIGI_CONVERT_1, val);
2177 mutex_unlock(&codec->spdif_mutex);
2181 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2182 struct snd_ctl_elem_value *ucontrol)
2184 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2185 hda_nid_t nid = kcontrol->private_value;
2189 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2190 sbits = convert_to_spdif_status(val);
2191 ucontrol->value.iec958.status[0] = sbits;
2192 ucontrol->value.iec958.status[1] = sbits >> 8;
2193 ucontrol->value.iec958.status[2] = sbits >> 16;
2194 ucontrol->value.iec958.status[3] = sbits >> 24;
2198 static struct snd_kcontrol_new dig_in_ctls[] = {
2200 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2201 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2202 .info = snd_hda_spdif_in_switch_info,
2203 .get = snd_hda_spdif_in_switch_get,
2204 .put = snd_hda_spdif_in_switch_put,
2207 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2208 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2209 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2210 .info = snd_hda_spdif_mask_info,
2211 .get = snd_hda_spdif_in_status_get,
2217 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2218 * @codec: the HDA codec
2219 * @nid: audio in widget NID
2221 * Creates controls related with the SPDIF input.
2222 * Called from each patch supporting the SPDIF in.
2224 * Returns 0 if successful, or a negative error code.
2226 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2229 struct snd_kcontrol *kctl;
2230 struct snd_kcontrol_new *dig_mix;
2233 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2234 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2238 if (idx >= SPDIF_MAX_IDX) {
2239 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2242 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2243 kctl = snd_ctl_new1(dig_mix, codec);
2246 kctl->private_value = nid;
2247 err = snd_hda_ctl_add(codec, kctl);
2251 codec->spdif_in_enable =
2252 snd_hda_codec_read(codec, nid, 0,
2253 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2257 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2259 #ifdef SND_HDA_NEEDS_RESUME
2264 /* build a 32bit cache key with the widget id and the command parameter */
2265 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2266 #define get_cmd_cache_nid(key) ((key) & 0xff)
2267 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2270 * snd_hda_codec_write_cache - send a single command with caching
2271 * @codec: the HDA codec
2272 * @nid: NID to send the command
2273 * @direct: direct flag
2274 * @verb: the verb to send
2275 * @parm: the parameter for the verb
2277 * Send a single command without waiting for response.
2279 * Returns 0 if successful, or a negative error code.
2281 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2282 int direct, unsigned int verb, unsigned int parm)
2284 struct hda_bus *bus = codec->bus;
2288 res = make_codec_cmd(codec, nid, direct, verb, parm);
2289 snd_hda_power_up(codec);
2290 mutex_lock(&bus->cmd_mutex);
2291 err = bus->ops.command(bus, res);
2293 struct hda_cache_head *c;
2295 /* parm may contain the verb stuff for get/set amp */
2296 verb = verb | (parm >> 8);
2298 key = build_cmd_cache_key(nid, verb);
2299 c = get_alloc_hash(&codec->cmd_cache, key);
2303 mutex_unlock(&bus->cmd_mutex);
2304 snd_hda_power_down(codec);
2307 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2309 /* resume the all commands from the cache */
2310 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2312 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2315 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2316 u32 key = buffer->key;
2319 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2320 get_cmd_cache_cmd(key), buffer->val);
2323 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2326 * snd_hda_sequence_write_cache - sequence writes with caching
2327 * @codec: the HDA codec
2328 * @seq: VERB array to send
2330 * Send the commands sequentially from the given array.
2331 * Thte commands are recorded on cache for power-save and resume.
2332 * The array must be terminated with NID=0.
2334 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2335 const struct hda_verb *seq)
2337 for (; seq->nid; seq++)
2338 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2341 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2342 #endif /* SND_HDA_NEEDS_RESUME */
2345 * set power state of the codec
2347 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2348 unsigned int power_state)
2353 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2355 msleep(10); /* partial workaround for "azx_get_response timeout" */
2357 nid = codec->start_nid;
2358 for (i = 0; i < codec->num_nodes; i++, nid++) {
2359 unsigned int wcaps = get_wcaps(codec, nid);
2360 if (wcaps & AC_WCAP_POWER) {
2361 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2363 if (power_state == AC_PWRST_D3 &&
2364 wid_type == AC_WID_PIN) {
2365 unsigned int pincap;
2367 * don't power down the widget if it controls
2368 * eapd and EAPD_BTLENABLE is set.
2370 pincap = snd_hda_query_pin_caps(codec, nid);
2371 if (pincap & AC_PINCAP_EAPD) {
2372 int eapd = snd_hda_codec_read(codec,
2374 AC_VERB_GET_EAPD_BTLENABLE, 0);
2380 snd_hda_codec_write(codec, nid, 0,
2381 AC_VERB_SET_POWER_STATE,
2386 if (power_state == AC_PWRST_D0) {
2387 unsigned long end_time;
2390 /* wait until the codec reachs to D0 */
2391 end_time = jiffies + msecs_to_jiffies(500);
2393 state = snd_hda_codec_read(codec, fg, 0,
2394 AC_VERB_GET_POWER_STATE, 0);
2395 if (state == power_state)
2398 } while (time_after_eq(end_time, jiffies));
2402 #ifdef CONFIG_SND_HDA_HWDEP
2403 /* execute additional init verbs */
2404 static void hda_exec_init_verbs(struct hda_codec *codec)
2406 if (codec->init_verbs.list)
2407 snd_hda_sequence_write(codec, codec->init_verbs.list);
2410 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2413 #ifdef SND_HDA_NEEDS_RESUME
2415 * call suspend and power-down; used both from PM and power-save
2417 static void hda_call_codec_suspend(struct hda_codec *codec)
2419 if (codec->patch_ops.suspend)
2420 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2421 hda_set_power_state(codec,
2422 codec->afg ? codec->afg : codec->mfg,
2424 #ifdef CONFIG_SND_HDA_POWER_SAVE
2425 cancel_delayed_work(&codec->power_work);
2426 codec->power_on = 0;
2427 codec->power_transition = 0;
2432 * kick up codec; used both from PM and power-save
2434 static void hda_call_codec_resume(struct hda_codec *codec)
2436 hda_set_power_state(codec,
2437 codec->afg ? codec->afg : codec->mfg,
2439 restore_pincfgs(codec); /* restore all current pin configs */
2440 hda_exec_init_verbs(codec);
2441 if (codec->patch_ops.resume)
2442 codec->patch_ops.resume(codec);
2444 if (codec->patch_ops.init)
2445 codec->patch_ops.init(codec);
2446 snd_hda_codec_resume_amp(codec);
2447 snd_hda_codec_resume_cache(codec);
2450 #endif /* SND_HDA_NEEDS_RESUME */
2454 * snd_hda_build_controls - build mixer controls
2457 * Creates mixer controls for each codec included in the bus.
2459 * Returns 0 if successful, otherwise a negative error code.
2461 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2463 struct hda_codec *codec;
2465 list_for_each_entry(codec, &bus->codec_list, list) {
2466 int err = snd_hda_codec_build_controls(codec);
2468 printk(KERN_ERR "hda_codec: cannot build controls"
2469 "for #%d (error %d)\n", codec->addr, err);
2470 err = snd_hda_codec_reset(codec);
2473 "hda_codec: cannot revert codec\n");
2480 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2482 int snd_hda_codec_build_controls(struct hda_codec *codec)
2485 hda_exec_init_verbs(codec);
2486 /* continue to initialize... */
2487 if (codec->patch_ops.init)
2488 err = codec->patch_ops.init(codec);
2489 if (!err && codec->patch_ops.build_controls)
2490 err = codec->patch_ops.build_controls(codec);
2499 struct hda_rate_tbl {
2501 unsigned int alsa_bits;
2502 unsigned int hda_fmt;
2505 static struct hda_rate_tbl rate_bits[] = {
2506 /* rate in Hz, ALSA rate bitmask, HDA format value */
2508 /* autodetected value used in snd_hda_query_supported_pcm */
2509 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2510 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2511 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2512 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2513 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2514 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2515 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2516 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2517 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2518 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2519 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2520 #define AC_PAR_PCM_RATE_BITS 11
2521 /* up to bits 10, 384kHZ isn't supported properly */
2523 /* not autodetected value */
2524 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2526 { 0 } /* terminator */
2530 * snd_hda_calc_stream_format - calculate format bitset
2531 * @rate: the sample rate
2532 * @channels: the number of channels
2533 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2534 * @maxbps: the max. bps
2536 * Calculate the format bitset from the given rate, channels and th PCM format.
2538 * Return zero if invalid.
2540 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2541 unsigned int channels,
2542 unsigned int format,
2543 unsigned int maxbps)
2546 unsigned int val = 0;
2548 for (i = 0; rate_bits[i].hz; i++)
2549 if (rate_bits[i].hz == rate) {
2550 val = rate_bits[i].hda_fmt;
2553 if (!rate_bits[i].hz) {
2554 snd_printdd("invalid rate %d\n", rate);
2558 if (channels == 0 || channels > 8) {
2559 snd_printdd("invalid channels %d\n", channels);
2562 val |= channels - 1;
2564 switch (snd_pcm_format_width(format)) {
2565 case 8: val |= 0x00; break;
2566 case 16: val |= 0x10; break;
2572 else if (maxbps >= 24)
2578 snd_printdd("invalid format width %d\n",
2579 snd_pcm_format_width(format));
2585 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2587 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2589 unsigned int val = 0;
2590 if (nid != codec->afg &&
2591 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2592 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2593 if (!val || val == -1)
2594 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2595 if (!val || val == -1)
2600 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2602 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2606 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2608 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2609 if (!streams || streams == -1)
2610 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2611 if (!streams || streams == -1)
2616 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2618 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2623 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2624 * @codec: the HDA codec
2625 * @nid: NID to query
2626 * @ratesp: the pointer to store the detected rate bitflags
2627 * @formatsp: the pointer to store the detected formats
2628 * @bpsp: the pointer to store the detected format widths
2630 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2631 * or @bsps argument is ignored.
2633 * Returns 0 if successful, otherwise a negative error code.
2635 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2636 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2638 unsigned int i, val, wcaps;
2640 wcaps = get_wcaps(codec, nid);
2641 val = query_pcm_param(codec, nid);
2645 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2647 rates |= rate_bits[i].alsa_bits;
2650 snd_printk(KERN_ERR "hda_codec: rates == 0 "
2651 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2653 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2659 if (formatsp || bpsp) {
2661 unsigned int streams, bps;
2663 streams = query_stream_param(codec, nid);
2668 if (streams & AC_SUPFMT_PCM) {
2669 if (val & AC_SUPPCM_BITS_8) {
2670 formats |= SNDRV_PCM_FMTBIT_U8;
2673 if (val & AC_SUPPCM_BITS_16) {
2674 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2677 if (wcaps & AC_WCAP_DIGITAL) {
2678 if (val & AC_SUPPCM_BITS_32)
2679 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2680 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2681 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2682 if (val & AC_SUPPCM_BITS_24)
2684 else if (val & AC_SUPPCM_BITS_20)
2686 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2687 AC_SUPPCM_BITS_32)) {
2688 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2689 if (val & AC_SUPPCM_BITS_32)
2691 else if (val & AC_SUPPCM_BITS_24)
2693 else if (val & AC_SUPPCM_BITS_20)
2697 else if (streams == AC_SUPFMT_FLOAT32) {
2698 /* should be exclusive */
2699 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2701 } else if (streams == AC_SUPFMT_AC3) {
2702 /* should be exclusive */
2703 /* temporary hack: we have still no proper support
2704 * for the direct AC3 stream...
2706 formats |= SNDRV_PCM_FMTBIT_U8;
2710 snd_printk(KERN_ERR "hda_codec: formats == 0 "
2711 "(nid=0x%x, val=0x%x, ovrd=%i, "
2714 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2719 *formatsp = formats;
2728 * snd_hda_is_supported_format - check whether the given node supports
2731 * Returns 1 if supported, 0 if not.
2733 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2734 unsigned int format)
2737 unsigned int val = 0, rate, stream;
2739 val = query_pcm_param(codec, nid);
2743 rate = format & 0xff00;
2744 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2745 if (rate_bits[i].hda_fmt == rate) {
2750 if (i >= AC_PAR_PCM_RATE_BITS)
2753 stream = query_stream_param(codec, nid);
2757 if (stream & AC_SUPFMT_PCM) {
2758 switch (format & 0xf0) {
2760 if (!(val & AC_SUPPCM_BITS_8))
2764 if (!(val & AC_SUPPCM_BITS_16))
2768 if (!(val & AC_SUPPCM_BITS_20))
2772 if (!(val & AC_SUPPCM_BITS_24))
2776 if (!(val & AC_SUPPCM_BITS_32))
2783 /* FIXME: check for float32 and AC3? */
2788 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2793 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2794 struct hda_codec *codec,
2795 struct snd_pcm_substream *substream)
2800 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2801 struct hda_codec *codec,
2802 unsigned int stream_tag,
2803 unsigned int format,
2804 struct snd_pcm_substream *substream)
2806 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2810 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2811 struct hda_codec *codec,
2812 struct snd_pcm_substream *substream)
2814 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2818 static int set_pcm_default_values(struct hda_codec *codec,
2819 struct hda_pcm_stream *info)
2823 /* query support PCM information from the given NID */
2824 if (info->nid && (!info->rates || !info->formats)) {
2825 err = snd_hda_query_supported_pcm(codec, info->nid,
2826 info->rates ? NULL : &info->rates,
2827 info->formats ? NULL : &info->formats,
2828 info->maxbps ? NULL : &info->maxbps);
2832 if (info->ops.open == NULL)
2833 info->ops.open = hda_pcm_default_open_close;
2834 if (info->ops.close == NULL)
2835 info->ops.close = hda_pcm_default_open_close;
2836 if (info->ops.prepare == NULL) {
2837 if (snd_BUG_ON(!info->nid))
2839 info->ops.prepare = hda_pcm_default_prepare;
2841 if (info->ops.cleanup == NULL) {
2842 if (snd_BUG_ON(!info->nid))
2844 info->ops.cleanup = hda_pcm_default_cleanup;
2850 * get the empty PCM device number to assign
2852 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2854 static const char *dev_name[HDA_PCM_NTYPES] = {
2855 "Audio", "SPDIF", "HDMI", "Modem"
2857 /* starting device index for each PCM type */
2858 static int dev_idx[HDA_PCM_NTYPES] = {
2859 [HDA_PCM_TYPE_AUDIO] = 0,
2860 [HDA_PCM_TYPE_SPDIF] = 1,
2861 [HDA_PCM_TYPE_HDMI] = 3,
2862 [HDA_PCM_TYPE_MODEM] = 6
2864 /* normal audio device indices; not linear to keep compatibility */
2865 static int audio_idx[4] = { 0, 2, 4, 5 };
2869 case HDA_PCM_TYPE_AUDIO:
2870 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2872 if (!test_bit(dev, bus->pcm_dev_bits))
2875 snd_printk(KERN_WARNING "Too many audio devices\n");
2877 case HDA_PCM_TYPE_SPDIF:
2878 case HDA_PCM_TYPE_HDMI:
2879 case HDA_PCM_TYPE_MODEM:
2880 dev = dev_idx[type];
2881 if (test_bit(dev, bus->pcm_dev_bits)) {
2882 snd_printk(KERN_WARNING "%s already defined\n",
2888 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2892 set_bit(dev, bus->pcm_dev_bits);
2897 * attach a new PCM stream
2899 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2901 struct hda_bus *bus = codec->bus;
2902 struct hda_pcm_stream *info;
2905 if (snd_BUG_ON(!pcm->name))
2907 for (stream = 0; stream < 2; stream++) {
2908 info = &pcm->stream[stream];
2909 if (info->substreams) {
2910 err = set_pcm_default_values(codec, info);
2915 return bus->ops.attach_pcm(bus, codec, pcm);
2918 /* assign all PCMs of the given codec */
2919 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2924 if (!codec->num_pcms) {
2925 if (!codec->patch_ops.build_pcms)
2927 err = codec->patch_ops.build_pcms(codec);
2929 printk(KERN_ERR "hda_codec: cannot build PCMs"
2930 "for #%d (error %d)\n", codec->addr, err);
2931 err = snd_hda_codec_reset(codec);
2934 "hda_codec: cannot revert codec\n");
2939 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2940 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2943 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2944 continue; /* no substreams assigned */
2947 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2949 continue; /* no fatal error */
2951 err = snd_hda_attach_pcm(codec, cpcm);
2953 printk(KERN_ERR "hda_codec: cannot attach "
2954 "PCM stream %d for codec #%d\n",
2956 continue; /* no fatal error */
2964 * snd_hda_build_pcms - build PCM information
2967 * Create PCM information for each codec included in the bus.
2969 * The build_pcms codec patch is requested to set up codec->num_pcms and
2970 * codec->pcm_info properly. The array is referred by the top-level driver
2971 * to create its PCM instances.
2972 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2975 * At least, substreams, channels_min and channels_max must be filled for
2976 * each stream. substreams = 0 indicates that the stream doesn't exist.
2977 * When rates and/or formats are zero, the supported values are queried
2978 * from the given nid. The nid is used also by the default ops.prepare
2979 * and ops.cleanup callbacks.
2981 * The driver needs to call ops.open in its open callback. Similarly,
2982 * ops.close is supposed to be called in the close callback.
2983 * ops.prepare should be called in the prepare or hw_params callback
2984 * with the proper parameters for set up.
2985 * ops.cleanup should be called in hw_free for clean up of streams.
2987 * This function returns 0 if successfull, or a negative error code.
2989 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2991 struct hda_codec *codec;
2993 list_for_each_entry(codec, &bus->codec_list, list) {
2994 int err = snd_hda_codec_build_pcms(codec);
3000 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
3003 * snd_hda_check_board_config - compare the current codec with the config table
3004 * @codec: the HDA codec
3005 * @num_configs: number of config enums
3006 * @models: array of model name strings
3007 * @tbl: configuration table, terminated by null entries
3009 * Compares the modelname or PCI subsystem id of the current codec with the
3010 * given configuration table. If a matching entry is found, returns its
3011 * config value (supposed to be 0 or positive).
3013 * If no entries are matching, the function returns a negative value.
3015 int snd_hda_check_board_config(struct hda_codec *codec,
3016 int num_configs, const char **models,
3017 const struct snd_pci_quirk *tbl)
3019 if (codec->modelname && models) {
3021 for (i = 0; i < num_configs; i++) {
3023 !strcmp(codec->modelname, models[i])) {
3024 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3025 "selected\n", models[i]);
3031 if (!codec->bus->pci || !tbl)
3034 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3037 if (tbl->value >= 0 && tbl->value < num_configs) {
3038 #ifdef CONFIG_SND_DEBUG_VERBOSE
3040 const char *model = NULL;
3042 model = models[tbl->value];
3044 sprintf(tmp, "#%d", tbl->value);
3047 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3048 "for config %x:%x (%s)\n",
3049 model, tbl->subvendor, tbl->subdevice,
3050 (tbl->name ? tbl->name : "Unknown device"));
3056 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3059 * snd_hda_check_board_codec_sid_config - compare the current codec
3060 subsystem ID with the
3063 This is important for Gateway notebooks with SB450 HDA Audio
3064 where the vendor ID of the PCI device is:
3065 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3066 and the vendor/subvendor are found only at the codec.
3068 * @codec: the HDA codec
3069 * @num_configs: number of config enums
3070 * @models: array of model name strings
3071 * @tbl: configuration table, terminated by null entries
3073 * Compares the modelname or PCI subsystem id of the current codec with the
3074 * given configuration table. If a matching entry is found, returns its
3075 * config value (supposed to be 0 or positive).
3077 * If no entries are matching, the function returns a negative value.
3079 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3080 int num_configs, const char **models,
3081 const struct snd_pci_quirk *tbl)
3083 const struct snd_pci_quirk *q;
3085 /* Search for codec ID */
3086 for (q = tbl; q->subvendor; q++) {
3087 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3089 if (vendorid == codec->subsystem_id)
3098 if (tbl->value >= 0 && tbl->value < num_configs) {
3099 #ifdef CONFIG_SND_DEBUG_DETECT
3101 const char *model = NULL;
3103 model = models[tbl->value];
3105 sprintf(tmp, "#%d", tbl->value);
3108 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3109 "for config %x:%x (%s)\n",
3110 model, tbl->subvendor, tbl->subdevice,
3111 (tbl->name ? tbl->name : "Unknown device"));
3117 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3120 * snd_hda_add_new_ctls - create controls from the array
3121 * @codec: the HDA codec
3122 * @knew: the array of struct snd_kcontrol_new
3124 * This helper function creates and add new controls in the given array.
3125 * The array must be terminated with an empty entry as terminator.
3127 * Returns 0 if successful, or a negative error code.
3129 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3133 for (; knew->name; knew++) {
3134 struct snd_kcontrol *kctl;
3135 kctl = snd_ctl_new1(knew, codec);
3138 err = snd_hda_ctl_add(codec, kctl);
3142 kctl = snd_ctl_new1(knew, codec);
3145 kctl->id.device = codec->addr;
3146 err = snd_hda_ctl_add(codec, kctl);
3153 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3155 #ifdef CONFIG_SND_HDA_POWER_SAVE
3156 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3157 unsigned int power_state);
3159 static void hda_power_work(struct work_struct *work)
3161 struct hda_codec *codec =
3162 container_of(work, struct hda_codec, power_work.work);
3163 struct hda_bus *bus = codec->bus;
3165 if (!codec->power_on || codec->power_count) {
3166 codec->power_transition = 0;
3170 hda_call_codec_suspend(codec);
3171 if (bus->ops.pm_notify)
3172 bus->ops.pm_notify(bus);
3175 static void hda_keep_power_on(struct hda_codec *codec)
3177 codec->power_count++;
3178 codec->power_on = 1;
3181 void snd_hda_power_up(struct hda_codec *codec)
3183 struct hda_bus *bus = codec->bus;
3185 codec->power_count++;
3186 if (codec->power_on || codec->power_transition)
3189 codec->power_on = 1;
3190 if (bus->ops.pm_notify)
3191 bus->ops.pm_notify(bus);
3192 hda_call_codec_resume(codec);
3193 cancel_delayed_work(&codec->power_work);
3194 codec->power_transition = 0;
3196 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3198 #define power_save(codec) \
3199 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3201 #define power_save(codec) \
3202 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3204 void snd_hda_power_down(struct hda_codec *codec)
3206 --codec->power_count;
3207 if (!codec->power_on || codec->power_count || codec->power_transition)
3209 if (power_save(codec)) {
3210 codec->power_transition = 1; /* avoid reentrance */
3211 queue_delayed_work(codec->bus->workq, &codec->power_work,
3212 msecs_to_jiffies(power_save(codec) * 1000));
3215 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3217 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3218 struct hda_loopback_check *check,
3221 struct hda_amp_list *p;
3224 if (!check->amplist)
3226 for (p = check->amplist; p->nid; p++) {
3231 return 0; /* nothing changed */
3233 for (p = check->amplist; p->nid; p++) {
3234 for (ch = 0; ch < 2; ch++) {
3235 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3237 if (!(v & HDA_AMP_MUTE) && v > 0) {
3238 if (!check->power_on) {
3239 check->power_on = 1;
3240 snd_hda_power_up(codec);
3246 if (check->power_on) {
3247 check->power_on = 0;
3248 snd_hda_power_down(codec);
3252 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3256 * Channel mode helper
3258 int snd_hda_ch_mode_info(struct hda_codec *codec,
3259 struct snd_ctl_elem_info *uinfo,
3260 const struct hda_channel_mode *chmode,
3263 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3265 uinfo->value.enumerated.items = num_chmodes;
3266 if (uinfo->value.enumerated.item >= num_chmodes)
3267 uinfo->value.enumerated.item = num_chmodes - 1;
3268 sprintf(uinfo->value.enumerated.name, "%dch",
3269 chmode[uinfo->value.enumerated.item].channels);
3272 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3274 int snd_hda_ch_mode_get(struct hda_codec *codec,
3275 struct snd_ctl_elem_value *ucontrol,
3276 const struct hda_channel_mode *chmode,
3282 for (i = 0; i < num_chmodes; i++) {
3283 if (max_channels == chmode[i].channels) {
3284 ucontrol->value.enumerated.item[0] = i;
3290 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3292 int snd_hda_ch_mode_put(struct hda_codec *codec,
3293 struct snd_ctl_elem_value *ucontrol,
3294 const struct hda_channel_mode *chmode,
3300 mode = ucontrol->value.enumerated.item[0];
3301 if (mode >= num_chmodes)
3303 if (*max_channelsp == chmode[mode].channels)
3305 /* change the current channel setting */
3306 *max_channelsp = chmode[mode].channels;
3307 if (chmode[mode].sequence)
3308 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3311 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3316 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3317 struct snd_ctl_elem_info *uinfo)
3321 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3323 uinfo->value.enumerated.items = imux->num_items;
3324 if (!imux->num_items)
3326 index = uinfo->value.enumerated.item;
3327 if (index >= imux->num_items)
3328 index = imux->num_items - 1;
3329 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3332 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3334 int snd_hda_input_mux_put(struct hda_codec *codec,
3335 const struct hda_input_mux *imux,
3336 struct snd_ctl_elem_value *ucontrol,
3338 unsigned int *cur_val)
3342 if (!imux->num_items)
3344 idx = ucontrol->value.enumerated.item[0];
3345 if (idx >= imux->num_items)
3346 idx = imux->num_items - 1;
3347 if (*cur_val == idx)
3349 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3350 imux->items[idx].index);
3354 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3358 * Multi-channel / digital-out PCM helper functions
3361 /* setup SPDIF output stream */
3362 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3363 unsigned int stream_tag, unsigned int format)
3365 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3366 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3367 set_dig_out_convert(codec, nid,
3368 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3370 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3371 if (codec->slave_dig_outs) {
3373 for (d = codec->slave_dig_outs; *d; d++)
3374 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3377 /* turn on again (if needed) */
3378 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3379 set_dig_out_convert(codec, nid,
3380 codec->spdif_ctls & 0xff, -1);
3383 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3385 snd_hda_codec_cleanup_stream(codec, nid);
3386 if (codec->slave_dig_outs) {
3388 for (d = codec->slave_dig_outs; *d; d++)
3389 snd_hda_codec_cleanup_stream(codec, *d);
3394 * open the digital out in the exclusive mode
3396 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3397 struct hda_multi_out *mout)
3399 mutex_lock(&codec->spdif_mutex);
3400 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3401 /* already opened as analog dup; reset it once */
3402 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3403 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3404 mutex_unlock(&codec->spdif_mutex);
3407 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3409 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3410 struct hda_multi_out *mout,
3411 unsigned int stream_tag,
3412 unsigned int format,
3413 struct snd_pcm_substream *substream)
3415 mutex_lock(&codec->spdif_mutex);
3416 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3417 mutex_unlock(&codec->spdif_mutex);
3420 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3422 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3423 struct hda_multi_out *mout)
3425 mutex_lock(&codec->spdif_mutex);
3426 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3427 mutex_unlock(&codec->spdif_mutex);
3430 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3433 * release the digital out
3435 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3436 struct hda_multi_out *mout)
3438 mutex_lock(&codec->spdif_mutex);
3439 mout->dig_out_used = 0;
3440 mutex_unlock(&codec->spdif_mutex);
3443 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3446 * set up more restrictions for analog out
3448 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3449 struct hda_multi_out *mout,
3450 struct snd_pcm_substream *substream,
3451 struct hda_pcm_stream *hinfo)
3453 struct snd_pcm_runtime *runtime = substream->runtime;
3454 runtime->hw.channels_max = mout->max_channels;
3455 if (mout->dig_out_nid) {
3456 if (!mout->analog_rates) {
3457 mout->analog_rates = hinfo->rates;
3458 mout->analog_formats = hinfo->formats;
3459 mout->analog_maxbps = hinfo->maxbps;
3461 runtime->hw.rates = mout->analog_rates;
3462 runtime->hw.formats = mout->analog_formats;
3463 hinfo->maxbps = mout->analog_maxbps;
3465 if (!mout->spdif_rates) {
3466 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3468 &mout->spdif_formats,
3469 &mout->spdif_maxbps);
3471 mutex_lock(&codec->spdif_mutex);
3472 if (mout->share_spdif) {
3473 runtime->hw.rates &= mout->spdif_rates;
3474 runtime->hw.formats &= mout->spdif_formats;
3475 if (mout->spdif_maxbps < hinfo->maxbps)
3476 hinfo->maxbps = mout->spdif_maxbps;
3478 mutex_unlock(&codec->spdif_mutex);
3480 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3481 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3483 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3486 * set up the i/o for analog out
3487 * when the digital out is available, copy the front out to digital out, too.
3489 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3490 struct hda_multi_out *mout,
3491 unsigned int stream_tag,
3492 unsigned int format,
3493 struct snd_pcm_substream *substream)
3495 hda_nid_t *nids = mout->dac_nids;
3496 int chs = substream->runtime->channels;
3499 mutex_lock(&codec->spdif_mutex);
3500 if (mout->dig_out_nid && mout->share_spdif &&
3501 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3503 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3505 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3506 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3507 setup_dig_out_stream(codec, mout->dig_out_nid,
3508 stream_tag, format);
3510 mout->dig_out_used = 0;
3511 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3514 mutex_unlock(&codec->spdif_mutex);
3517 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3519 if (!mout->no_share_stream &&
3520 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3521 /* headphone out will just decode front left/right (stereo) */
3522 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3524 /* extra outputs copied from front */
3525 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3526 if (!mout->no_share_stream && mout->extra_out_nid[i])
3527 snd_hda_codec_setup_stream(codec,
3528 mout->extra_out_nid[i],
3529 stream_tag, 0, format);
3532 for (i = 1; i < mout->num_dacs; i++) {
3533 if (chs >= (i + 1) * 2) /* independent out */
3534 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3536 else if (!mout->no_share_stream) /* copy front */
3537 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3542 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3545 * clean up the setting for analog out
3547 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3548 struct hda_multi_out *mout)
3550 hda_nid_t *nids = mout->dac_nids;
3553 for (i = 0; i < mout->num_dacs; i++)
3554 snd_hda_codec_cleanup_stream(codec, nids[i]);
3556 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3557 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3558 if (mout->extra_out_nid[i])
3559 snd_hda_codec_cleanup_stream(codec,
3560 mout->extra_out_nid[i]);
3561 mutex_lock(&codec->spdif_mutex);
3562 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3563 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3564 mout->dig_out_used = 0;
3566 mutex_unlock(&codec->spdif_mutex);
3569 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3572 * Helper for automatic pin configuration
3575 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3577 for (; *list; list++)
3585 * Sort an associated group of pins according to their sequence numbers.
3587 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3594 for (i = 0; i < num_pins; i++) {
3595 for (j = i + 1; j < num_pins; j++) {
3596 if (sequences[i] > sequences[j]) {
3598 sequences[i] = sequences[j];
3610 * Parse all pin widgets and store the useful pin nids to cfg
3612 * The number of line-outs or any primary output is stored in line_outs,
3613 * and the corresponding output pins are assigned to line_out_pins[],
3614 * in the order of front, rear, CLFE, side, ...
3616 * If more extra outputs (speaker and headphone) are found, the pins are
3617 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3618 * is detected, one of speaker of HP pins is assigned as the primary
3619 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3620 * if any analog output exists.
3622 * The analog input pins are assigned to input_pins array.
3623 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3626 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3627 struct auto_pin_cfg *cfg,
3628 hda_nid_t *ignore_nids)
3630 hda_nid_t nid, end_nid;
3631 short seq, assoc_line_out, assoc_speaker;
3632 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3633 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3634 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3636 memset(cfg, 0, sizeof(*cfg));
3638 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3639 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3640 memset(sequences_hp, 0, sizeof(sequences_hp));
3641 assoc_line_out = assoc_speaker = 0;
3643 end_nid = codec->start_nid + codec->num_nodes;
3644 for (nid = codec->start_nid; nid < end_nid; nid++) {
3645 unsigned int wid_caps = get_wcaps(codec, nid);
3646 unsigned int wid_type =
3647 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3648 unsigned int def_conf;
3651 /* read all default configuration for pin complex */
3652 if (wid_type != AC_WID_PIN)
3654 /* ignore the given nids (e.g. pc-beep returns error) */
3655 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3658 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3659 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3661 loc = get_defcfg_location(def_conf);
3662 switch (get_defcfg_device(def_conf)) {
3663 case AC_JACK_LINE_OUT:
3664 seq = get_defcfg_sequence(def_conf);
3665 assoc = get_defcfg_association(def_conf);
3667 if (!(wid_caps & AC_WCAP_STEREO))
3668 if (!cfg->mono_out_pin)
3669 cfg->mono_out_pin = nid;
3672 if (!assoc_line_out)
3673 assoc_line_out = assoc;
3674 else if (assoc_line_out != assoc)
3676 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3678 cfg->line_out_pins[cfg->line_outs] = nid;
3679 sequences_line_out[cfg->line_outs] = seq;
3682 case AC_JACK_SPEAKER:
3683 seq = get_defcfg_sequence(def_conf);
3684 assoc = get_defcfg_association(def_conf);
3687 if (! assoc_speaker)
3688 assoc_speaker = assoc;
3689 else if (assoc_speaker != assoc)
3691 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3693 cfg->speaker_pins[cfg->speaker_outs] = nid;
3694 sequences_speaker[cfg->speaker_outs] = seq;
3695 cfg->speaker_outs++;
3697 case AC_JACK_HP_OUT:
3698 seq = get_defcfg_sequence(def_conf);
3699 assoc = get_defcfg_association(def_conf);
3700 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3702 cfg->hp_pins[cfg->hp_outs] = nid;
3703 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3706 case AC_JACK_MIC_IN: {
3708 if (loc == AC_JACK_LOC_FRONT) {
3709 preferred = AUTO_PIN_FRONT_MIC;
3712 preferred = AUTO_PIN_MIC;
3713 alt = AUTO_PIN_FRONT_MIC;
3715 if (!cfg->input_pins[preferred])
3716 cfg->input_pins[preferred] = nid;
3717 else if (!cfg->input_pins[alt])
3718 cfg->input_pins[alt] = nid;
3721 case AC_JACK_LINE_IN:
3722 if (loc == AC_JACK_LOC_FRONT)
3723 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3725 cfg->input_pins[AUTO_PIN_LINE] = nid;
3728 cfg->input_pins[AUTO_PIN_CD] = nid;
3731 cfg->input_pins[AUTO_PIN_AUX] = nid;
3733 case AC_JACK_SPDIF_OUT:
3734 case AC_JACK_DIG_OTHER_OUT:
3735 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3737 cfg->dig_out_pins[cfg->dig_outs] = nid;
3738 cfg->dig_out_type[cfg->dig_outs] =
3739 (loc == AC_JACK_LOC_HDMI) ?
3740 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3743 case AC_JACK_SPDIF_IN:
3744 case AC_JACK_DIG_OTHER_IN:
3745 cfg->dig_in_pin = nid;
3746 if (loc == AC_JACK_LOC_HDMI)
3747 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3749 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
3755 * If no line-out is defined but multiple HPs are found,
3756 * some of them might be the real line-outs.
3758 if (!cfg->line_outs && cfg->hp_outs > 1) {
3760 while (i < cfg->hp_outs) {
3761 /* The real HPs should have the sequence 0x0f */
3762 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3766 /* Move it to the line-out table */
3767 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3768 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3771 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3772 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3773 memmove(sequences_hp + i - 1, sequences_hp + i,
3774 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3778 /* sort by sequence */
3779 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3781 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3783 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3786 /* if we have only one mic, make it AUTO_PIN_MIC */
3787 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3788 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3789 cfg->input_pins[AUTO_PIN_MIC] =
3790 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3791 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3793 /* ditto for line-in */
3794 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3795 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3796 cfg->input_pins[AUTO_PIN_LINE] =
3797 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3798 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3802 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3803 * as a primary output
3805 if (!cfg->line_outs) {
3806 if (cfg->speaker_outs) {
3807 cfg->line_outs = cfg->speaker_outs;
3808 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3809 sizeof(cfg->speaker_pins));
3810 cfg->speaker_outs = 0;
3811 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3812 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3813 } else if (cfg->hp_outs) {
3814 cfg->line_outs = cfg->hp_outs;
3815 memcpy(cfg->line_out_pins, cfg->hp_pins,
3816 sizeof(cfg->hp_pins));
3818 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3819 cfg->line_out_type = AUTO_PIN_HP_OUT;
3823 /* Reorder the surround channels
3824 * ALSA sequence is front/surr/clfe/side
3826 * 4-ch: front/surr => OK as it is
3827 * 6-ch: front/clfe/surr
3828 * 8-ch: front/clfe/rear/side|fc
3830 switch (cfg->line_outs) {
3833 nid = cfg->line_out_pins[1];
3834 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3835 cfg->line_out_pins[2] = nid;
3840 * debug prints of the parsed results
3842 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3843 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3844 cfg->line_out_pins[2], cfg->line_out_pins[3],
3845 cfg->line_out_pins[4]);
3846 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3847 cfg->speaker_outs, cfg->speaker_pins[0],
3848 cfg->speaker_pins[1], cfg->speaker_pins[2],
3849 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3850 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3851 cfg->hp_outs, cfg->hp_pins[0],
3852 cfg->hp_pins[1], cfg->hp_pins[2],
3853 cfg->hp_pins[3], cfg->hp_pins[4]);
3854 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3856 snd_printd(" dig-out=0x%x/0x%x\n",
3857 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
3858 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3859 " cd=0x%x, aux=0x%x\n",
3860 cfg->input_pins[AUTO_PIN_MIC],
3861 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3862 cfg->input_pins[AUTO_PIN_LINE],
3863 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3864 cfg->input_pins[AUTO_PIN_CD],
3865 cfg->input_pins[AUTO_PIN_AUX]);
3866 if (cfg->dig_in_pin)
3867 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
3871 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3873 /* labels for input pins */
3874 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3875 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3877 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3886 * snd_hda_suspend - suspend the codecs
3888 * @state: suspsend state
3890 * Returns 0 if successful.
3892 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3894 struct hda_codec *codec;
3896 list_for_each_entry(codec, &bus->codec_list, list) {
3897 #ifdef CONFIG_SND_HDA_POWER_SAVE
3898 if (!codec->power_on)
3901 hda_call_codec_suspend(codec);
3905 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3908 * snd_hda_resume - resume the codecs
3911 * Returns 0 if successful.
3913 * This fucntion is defined only when POWER_SAVE isn't set.
3914 * In the power-save mode, the codec is resumed dynamically.
3916 int snd_hda_resume(struct hda_bus *bus)
3918 struct hda_codec *codec;
3920 list_for_each_entry(codec, &bus->codec_list, list) {
3921 if (snd_hda_codec_needs_resume(codec))
3922 hda_call_codec_resume(codec);
3926 EXPORT_SYMBOL_HDA(snd_hda_resume);
3927 #endif /* CONFIG_PM */
3933 /* get a new element from the given array
3934 * if it exceeds the pre-allocated array size, re-allocate the array
3936 void *snd_array_new(struct snd_array *array)
3938 if (array->used >= array->alloced) {
3939 int num = array->alloced + array->alloc_align;
3941 if (snd_BUG_ON(num >= 4096))
3943 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3947 memcpy(nlist, array->list,
3948 array->elem_size * array->alloced);
3951 array->list = nlist;
3952 array->alloced = num;
3954 return snd_array_elem(array, array->used++);
3956 EXPORT_SYMBOL_HDA(snd_array_new);
3958 /* free the given array elements */
3959 void snd_array_free(struct snd_array *array)
3966 EXPORT_SYMBOL_HDA(snd_array_free);
3969 * used by hda_proc.c and hda_eld.c
3971 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3973 static unsigned int rates[] = {
3974 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3975 96000, 176400, 192000, 384000
3979 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3981 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3983 buf[j] = '\0'; /* necessary when j == 0 */
3985 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3987 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3989 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3992 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3993 if (pcm & (AC_SUPPCM_BITS_8 << i))
3994 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3996 buf[j] = '\0'; /* necessary when j == 0 */
3998 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
4000 MODULE_DESCRIPTION("HDA codec core");
4001 MODULE_LICENSE("GPL");