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 * Send and receive a verb
164 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
167 struct hda_bus *bus = codec->bus;
173 snd_hda_power_up(codec);
174 mutex_lock(&bus->cmd_mutex);
175 err = bus->ops.command(bus, cmd);
177 *res = bus->ops.get_response(bus);
178 mutex_unlock(&bus->cmd_mutex);
179 snd_hda_power_down(codec);
180 if (res && *res == -1 && bus->rirb_error) {
181 if (bus->response_reset) {
182 snd_printd("hda_codec: resetting BUS due to "
183 "fatal communication error\n");
184 bus->ops.bus_reset(bus);
188 /* clear reset-flag when the communication gets recovered */
190 bus->response_reset = 0;
195 * snd_hda_codec_read - send a command and get the response
196 * @codec: the HDA codec
197 * @nid: NID to send the command
198 * @direct: direct flag
199 * @verb: the verb to send
200 * @parm: the parameter for the verb
202 * Send a single command and read the corresponding response.
204 * Returns the obtained response value, or -1 for an error.
206 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
208 unsigned int verb, unsigned int parm)
210 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
212 codec_exec_verb(codec, cmd, &res);
215 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
218 * snd_hda_codec_write - send a single command without waiting for response
219 * @codec: the HDA codec
220 * @nid: NID to send the command
221 * @direct: direct flag
222 * @verb: the verb to send
223 * @parm: the parameter for the verb
225 * Send a single command without waiting for response.
227 * Returns 0 if successful, or a negative error code.
229 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
230 unsigned int verb, unsigned int parm)
232 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
234 return codec_exec_verb(codec, cmd,
235 codec->bus->sync_write ? &res : NULL);
237 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
240 * snd_hda_sequence_write - sequence writes
241 * @codec: the HDA codec
242 * @seq: VERB array to send
244 * Send the commands sequentially from the given array.
245 * The array must be terminated with NID=0.
247 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
249 for (; seq->nid; seq++)
250 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
252 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
255 * snd_hda_get_sub_nodes - get the range of sub nodes
256 * @codec: the HDA codec
258 * @start_id: the pointer to store the start NID
260 * Parse the NID and store the start NID of its sub-nodes.
261 * Returns the number of sub-nodes.
263 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
268 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
271 *start_id = (parm >> 16) & 0x7fff;
272 return (int)(parm & 0x7fff);
274 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
277 * snd_hda_get_connections - get connection list
278 * @codec: the HDA codec
280 * @conn_list: connection list array
281 * @max_conns: max. number of connections to store
283 * Parses the connection list of the given widget and stores the list
286 * Returns the number of connections, or a negative error code.
288 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
289 hda_nid_t *conn_list, int max_conns)
292 int i, conn_len, conns;
293 unsigned int shift, num_elems, mask;
296 if (snd_BUG_ON(!conn_list || max_conns <= 0))
299 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
300 if (parm & AC_CLIST_LONG) {
309 conn_len = parm & AC_CLIST_LENGTH;
310 mask = (1 << (shift-1)) - 1;
313 return 0; /* no connection */
316 /* single connection */
317 parm = snd_hda_codec_read(codec, nid, 0,
318 AC_VERB_GET_CONNECT_LIST, 0);
319 conn_list[0] = parm & mask;
323 /* multi connection */
326 for (i = 0; i < conn_len; i++) {
330 if (i % num_elems == 0)
331 parm = snd_hda_codec_read(codec, nid, 0,
332 AC_VERB_GET_CONNECT_LIST, i);
333 range_val = !!(parm & (1 << (shift-1))); /* ranges */
337 /* ranges between the previous and this one */
338 if (!prev_nid || prev_nid >= val) {
339 snd_printk(KERN_WARNING "hda_codec: "
340 "invalid dep_range_val %x:%x\n",
344 for (n = prev_nid + 1; n <= val; n++) {
345 if (conns >= max_conns) {
347 "Too many connections\n");
350 conn_list[conns++] = n;
353 if (conns >= max_conns) {
354 snd_printk(KERN_ERR "Too many connections\n");
357 conn_list[conns++] = val;
363 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
367 * snd_hda_queue_unsol_event - add an unsolicited event to queue
369 * @res: unsolicited event (lower 32bit of RIRB entry)
370 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
372 * Adds the given event to the queue. The events are processed in
373 * the workqueue asynchronously. Call this function in the interrupt
374 * hanlder when RIRB receives an unsolicited event.
376 * Returns 0 if successful, or a negative error code.
378 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
380 struct hda_bus_unsolicited *unsol;
387 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
391 unsol->queue[wp] = res;
392 unsol->queue[wp + 1] = res_ex;
394 queue_work(bus->workq, &unsol->work);
398 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
401 * process queued unsolicited events
403 static void process_unsol_events(struct work_struct *work)
405 struct hda_bus_unsolicited *unsol =
406 container_of(work, struct hda_bus_unsolicited, work);
407 struct hda_bus *bus = unsol->bus;
408 struct hda_codec *codec;
409 unsigned int rp, caddr, res;
411 while (unsol->rp != unsol->wp) {
412 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
415 res = unsol->queue[rp];
416 caddr = unsol->queue[rp + 1];
417 if (!(caddr & (1 << 4))) /* no unsolicited event? */
419 codec = bus->caddr_tbl[caddr & 0x0f];
420 if (codec && codec->patch_ops.unsol_event)
421 codec->patch_ops.unsol_event(codec, res);
426 * initialize unsolicited queue
428 static int init_unsol_queue(struct hda_bus *bus)
430 struct hda_bus_unsolicited *unsol;
432 if (bus->unsol) /* already initialized */
435 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
437 snd_printk(KERN_ERR "hda_codec: "
438 "can't allocate unsolicited queue\n");
441 INIT_WORK(&unsol->work, process_unsol_events);
450 static void snd_hda_codec_free(struct hda_codec *codec);
452 static int snd_hda_bus_free(struct hda_bus *bus)
454 struct hda_codec *codec, *n;
459 flush_workqueue(bus->workq);
462 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
463 snd_hda_codec_free(codec);
465 if (bus->ops.private_free)
466 bus->ops.private_free(bus);
468 destroy_workqueue(bus->workq);
473 static int snd_hda_bus_dev_free(struct snd_device *device)
475 struct hda_bus *bus = device->device_data;
477 return snd_hda_bus_free(bus);
480 #ifdef CONFIG_SND_HDA_HWDEP
481 static int snd_hda_bus_dev_register(struct snd_device *device)
483 struct hda_bus *bus = device->device_data;
484 struct hda_codec *codec;
485 list_for_each_entry(codec, &bus->codec_list, list) {
486 snd_hda_hwdep_add_sysfs(codec);
491 #define snd_hda_bus_dev_register NULL
495 * snd_hda_bus_new - create a HDA bus
496 * @card: the card entry
497 * @temp: the template for hda_bus information
498 * @busp: the pointer to store the created bus instance
500 * Returns 0 if successful, or a negative error code.
502 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
503 const struct hda_bus_template *temp,
504 struct hda_bus **busp)
508 static struct snd_device_ops dev_ops = {
509 .dev_register = snd_hda_bus_dev_register,
510 .dev_free = snd_hda_bus_dev_free,
513 if (snd_BUG_ON(!temp))
515 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
521 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
523 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
528 bus->private_data = temp->private_data;
529 bus->pci = temp->pci;
530 bus->modelname = temp->modelname;
531 bus->power_save = temp->power_save;
532 bus->ops = temp->ops;
534 mutex_init(&bus->cmd_mutex);
535 INIT_LIST_HEAD(&bus->codec_list);
537 snprintf(bus->workq_name, sizeof(bus->workq_name),
538 "hd-audio%d", card->number);
539 bus->workq = create_singlethread_workqueue(bus->workq_name);
541 snd_printk(KERN_ERR "cannot create workqueue %s\n",
547 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
549 snd_hda_bus_free(bus);
556 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
558 #ifdef CONFIG_SND_HDA_GENERIC
559 #define is_generic_config(codec) \
560 (codec->modelname && !strcmp(codec->modelname, "generic"))
562 #define is_generic_config(codec) 0
566 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
568 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
572 * find a matching codec preset
574 static const struct hda_codec_preset *
575 find_codec_preset(struct hda_codec *codec)
577 struct hda_codec_preset_list *tbl;
578 const struct hda_codec_preset *preset;
579 int mod_requested = 0;
581 if (is_generic_config(codec))
582 return NULL; /* use the generic parser */
585 mutex_lock(&preset_mutex);
586 list_for_each_entry(tbl, &hda_preset_tables, list) {
587 if (!try_module_get(tbl->owner)) {
588 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
591 for (preset = tbl->preset; preset->id; preset++) {
592 u32 mask = preset->mask;
593 if (preset->afg && preset->afg != codec->afg)
595 if (preset->mfg && preset->mfg != codec->mfg)
599 if (preset->id == (codec->vendor_id & mask) &&
601 preset->rev == codec->revision_id)) {
602 mutex_unlock(&preset_mutex);
603 codec->owner = tbl->owner;
607 module_put(tbl->owner);
609 mutex_unlock(&preset_mutex);
611 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
614 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
617 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
618 (codec->vendor_id >> 16) & 0xffff);
619 request_module(name);
627 * get_codec_name - store the codec name
629 static int get_codec_name(struct hda_codec *codec)
631 const struct hda_vendor_id *c;
632 const char *vendor = NULL;
633 u16 vendor_id = codec->vendor_id >> 16;
636 if (codec->vendor_name)
639 for (c = hda_vendor_ids; c->id; c++) {
640 if (c->id == vendor_id) {
646 sprintf(tmp, "Generic %04x", vendor_id);
649 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
650 if (!codec->vendor_name)
654 if (codec->chip_name)
657 if (codec->preset && codec->preset->name)
658 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
660 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
661 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
663 if (!codec->chip_name)
669 * look for an AFG and MFG nodes
671 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
673 int i, total_nodes, function_id;
676 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
677 for (i = 0; i < total_nodes; i++, nid++) {
678 function_id = snd_hda_param_read(codec, nid,
679 AC_PAR_FUNCTION_TYPE) & 0xff;
680 switch (function_id) {
681 case AC_GRP_AUDIO_FUNCTION:
683 codec->function_id = function_id;
685 case AC_GRP_MODEM_FUNCTION:
687 codec->function_id = function_id;
696 * read widget caps for each widget and store in cache
698 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
703 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
705 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
708 nid = codec->start_nid;
709 for (i = 0; i < codec->num_nodes; i++, nid++)
710 codec->wcaps[i] = snd_hda_param_read(codec, nid,
711 AC_PAR_AUDIO_WIDGET_CAP);
715 /* read all pin default configurations and save codec->init_pins */
716 static int read_pin_defaults(struct hda_codec *codec)
719 hda_nid_t nid = codec->start_nid;
721 for (i = 0; i < codec->num_nodes; i++, nid++) {
722 struct hda_pincfg *pin;
723 unsigned int wcaps = get_wcaps(codec, nid);
724 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
726 if (wid_type != AC_WID_PIN)
728 pin = snd_array_new(&codec->init_pins);
732 pin->cfg = snd_hda_codec_read(codec, nid, 0,
733 AC_VERB_GET_CONFIG_DEFAULT, 0);
738 /* look up the given pin config list and return the item matching with NID */
739 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
740 struct snd_array *array,
744 for (i = 0; i < array->used; i++) {
745 struct hda_pincfg *pin = snd_array_elem(array, i);
752 /* write a config value for the given NID */
753 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
757 for (i = 0; i < 4; i++) {
758 snd_hda_codec_write(codec, nid, 0,
759 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
765 /* set the current pin config value for the given NID.
766 * the value is cached, and read via snd_hda_codec_get_pincfg()
768 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
769 hda_nid_t nid, unsigned int cfg)
771 struct hda_pincfg *pin;
774 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
775 pin = look_up_pincfg(codec, list, nid);
777 pin = snd_array_new(list);
784 /* change only when needed; e.g. if the pincfg is already present
785 * in user_pins[], don't write it
787 cfg = snd_hda_codec_get_pincfg(codec, nid);
789 set_pincfg(codec, nid, cfg);
793 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
794 hda_nid_t nid, unsigned int cfg)
796 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
798 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
800 /* get the current pin config value of the given pin NID */
801 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
803 struct hda_pincfg *pin;
805 #ifdef CONFIG_SND_HDA_HWDEP
806 pin = look_up_pincfg(codec, &codec->user_pins, nid);
810 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
813 pin = look_up_pincfg(codec, &codec->init_pins, nid);
818 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
820 /* restore all current pin configs */
821 static void restore_pincfgs(struct hda_codec *codec)
824 for (i = 0; i < codec->init_pins.used; i++) {
825 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
826 set_pincfg(codec, pin->nid,
827 snd_hda_codec_get_pincfg(codec, pin->nid));
831 static void init_hda_cache(struct hda_cache_rec *cache,
832 unsigned int record_size);
833 static void free_hda_cache(struct hda_cache_rec *cache);
835 /* restore the initial pin cfgs and release all pincfg lists */
836 static void restore_init_pincfgs(struct hda_codec *codec)
838 /* first free driver_pins and user_pins, then call restore_pincfg
839 * so that only the values in init_pins are restored
841 snd_array_free(&codec->driver_pins);
842 #ifdef CONFIG_SND_HDA_HWDEP
843 snd_array_free(&codec->user_pins);
845 restore_pincfgs(codec);
846 snd_array_free(&codec->init_pins);
852 static void snd_hda_codec_free(struct hda_codec *codec)
856 restore_init_pincfgs(codec);
857 #ifdef CONFIG_SND_HDA_POWER_SAVE
858 cancel_delayed_work(&codec->power_work);
859 flush_workqueue(codec->bus->workq);
861 list_del(&codec->list);
862 snd_array_free(&codec->mixers);
863 codec->bus->caddr_tbl[codec->addr] = NULL;
864 if (codec->patch_ops.free)
865 codec->patch_ops.free(codec);
866 module_put(codec->owner);
867 free_hda_cache(&codec->amp_cache);
868 free_hda_cache(&codec->cmd_cache);
869 kfree(codec->vendor_name);
870 kfree(codec->chip_name);
871 kfree(codec->modelname);
876 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
877 unsigned int power_state);
880 * snd_hda_codec_new - create a HDA codec
881 * @bus: the bus to assign
882 * @codec_addr: the codec address
883 * @codecp: the pointer to store the generated codec
885 * Returns 0 if successful, or a negative error code.
887 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
888 int do_init, struct hda_codec **codecp)
890 struct hda_codec *codec;
894 if (snd_BUG_ON(!bus))
896 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
899 if (bus->caddr_tbl[codec_addr]) {
900 snd_printk(KERN_ERR "hda_codec: "
901 "address 0x%x is already occupied\n", codec_addr);
905 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
907 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
912 codec->addr = codec_addr;
913 mutex_init(&codec->spdif_mutex);
914 mutex_init(&codec->control_mutex);
915 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
916 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
917 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
918 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
919 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
920 if (codec->bus->modelname) {
921 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
922 if (!codec->modelname) {
923 snd_hda_codec_free(codec);
928 #ifdef CONFIG_SND_HDA_POWER_SAVE
929 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
930 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
931 * the caller has to power down appropriatley after initialization
934 hda_keep_power_on(codec);
937 list_add_tail(&codec->list, &bus->codec_list);
938 bus->caddr_tbl[codec_addr] = codec;
940 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
942 if (codec->vendor_id == -1)
943 /* read again, hopefully the access method was corrected
944 * in the last read...
946 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
948 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
949 AC_PAR_SUBSYSTEM_ID);
950 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
953 setup_fg_nodes(codec);
954 if (!codec->afg && !codec->mfg) {
955 snd_printdd("hda_codec: no AFG or MFG node found\n");
960 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
962 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
965 err = read_pin_defaults(codec);
969 if (!codec->subsystem_id) {
970 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
971 codec->subsystem_id =
972 snd_hda_codec_read(codec, nid, 0,
973 AC_VERB_GET_SUBSYSTEM_ID, 0);
976 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
978 /* power-up all before initialization */
979 hda_set_power_state(codec,
980 codec->afg ? codec->afg : codec->mfg,
984 err = snd_hda_codec_configure(codec);
988 snd_hda_codec_proc_new(codec);
990 snd_hda_create_hwdep(codec);
992 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
993 codec->subsystem_id, codec->revision_id);
994 snd_component_add(codec->bus->card, component);
1001 snd_hda_codec_free(codec);
1004 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1006 int snd_hda_codec_configure(struct hda_codec *codec)
1010 codec->preset = find_codec_preset(codec);
1011 if (!codec->vendor_name || !codec->chip_name) {
1012 err = get_codec_name(codec);
1016 /* audio codec should override the mixer name */
1017 if (codec->afg || !*codec->bus->card->mixername)
1018 snprintf(codec->bus->card->mixername,
1019 sizeof(codec->bus->card->mixername),
1020 "%s %s", codec->vendor_name, codec->chip_name);
1022 if (is_generic_config(codec)) {
1023 err = snd_hda_parse_generic_codec(codec);
1026 if (codec->preset && codec->preset->patch) {
1027 err = codec->preset->patch(codec);
1031 /* call the default parser */
1032 err = snd_hda_parse_generic_codec(codec);
1034 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1037 if (!err && codec->patch_ops.unsol_event)
1038 err = init_unsol_queue(codec->bus);
1043 * snd_hda_codec_setup_stream - set up the codec for streaming
1044 * @codec: the CODEC to set up
1045 * @nid: the NID to set up
1046 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1047 * @channel_id: channel id to pass, zero based.
1048 * @format: stream format.
1050 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1052 int channel_id, int format)
1057 snd_printdd("hda_codec_setup_stream: "
1058 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1059 nid, stream_tag, channel_id, format);
1060 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1061 (stream_tag << 4) | channel_id);
1063 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1065 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1067 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1072 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1073 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1074 #if 0 /* keep the format */
1076 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1079 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
1082 * amp access functions
1085 /* FIXME: more better hash key? */
1086 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1087 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1088 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1089 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1090 #define INFO_AMP_CAPS (1<<0)
1091 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1093 /* initialize the hash table */
1094 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1095 unsigned int record_size)
1097 memset(cache, 0, sizeof(*cache));
1098 memset(cache->hash, 0xff, sizeof(cache->hash));
1099 snd_array_init(&cache->buf, record_size, 64);
1102 static void free_hda_cache(struct hda_cache_rec *cache)
1104 snd_array_free(&cache->buf);
1107 /* query the hash. allocate an entry if not found. */
1108 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1111 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1112 u16 cur = cache->hash[idx];
1113 struct hda_cache_head *info;
1115 while (cur != 0xffff) {
1116 info = snd_array_elem(&cache->buf, cur);
1117 if (info->key == key)
1122 /* add a new hash entry */
1123 info = snd_array_new(&cache->buf);
1126 cur = snd_array_index(&cache->buf, info);
1129 info->next = cache->hash[idx];
1130 cache->hash[idx] = cur;
1135 /* query and allocate an amp hash entry */
1136 static inline struct hda_amp_info *
1137 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1139 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1143 * query AMP capabilities for the given widget and direction
1145 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1147 struct hda_amp_info *info;
1149 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1152 if (!(info->head.val & INFO_AMP_CAPS)) {
1153 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1155 info->amp_caps = snd_hda_param_read(codec, nid,
1156 direction == HDA_OUTPUT ?
1157 AC_PAR_AMP_OUT_CAP :
1160 info->head.val |= INFO_AMP_CAPS;
1162 return info->amp_caps;
1164 EXPORT_SYMBOL_HDA(query_amp_caps);
1166 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1169 struct hda_amp_info *info;
1171 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1174 info->amp_caps = caps;
1175 info->head.val |= INFO_AMP_CAPS;
1178 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1181 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1182 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1184 struct hda_amp_info *info;
1186 info = get_alloc_amp_hash(codec, key);
1189 if (!info->head.val) {
1190 info->head.val |= INFO_AMP_CAPS;
1191 info->amp_caps = func(codec, nid);
1193 return info->amp_caps;
1196 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1198 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1201 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1203 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1206 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1209 * read the current volume to info
1210 * if the cache exists, read the cache value.
1212 static unsigned int get_vol_mute(struct hda_codec *codec,
1213 struct hda_amp_info *info, hda_nid_t nid,
1214 int ch, int direction, int index)
1218 if (info->head.val & INFO_AMP_VOL(ch))
1219 return info->vol[ch];
1221 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1222 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1224 val = snd_hda_codec_read(codec, nid, 0,
1225 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1226 info->vol[ch] = val & 0xff;
1227 info->head.val |= INFO_AMP_VOL(ch);
1228 return info->vol[ch];
1232 * write the current volume in info to the h/w and update the cache
1234 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1235 hda_nid_t nid, int ch, int direction, int index,
1240 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1241 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1242 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1244 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1245 info->vol[ch] = val;
1249 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1251 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1252 int direction, int index)
1254 struct hda_amp_info *info;
1255 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1258 return get_vol_mute(codec, info, nid, ch, direction, index);
1260 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1263 * update the AMP value, mask = bit mask to set, val = the value
1265 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1266 int direction, int idx, int mask, int val)
1268 struct hda_amp_info *info;
1270 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1274 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1275 if (info->vol[ch] == val)
1277 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1280 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1283 * update the AMP stereo with the same mask and value
1285 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1286 int direction, int idx, int mask, int val)
1289 for (ch = 0; ch < 2; ch++)
1290 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1294 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1296 #ifdef SND_HDA_NEEDS_RESUME
1297 /* resume the all amp commands from the cache */
1298 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1300 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1303 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1304 u32 key = buffer->head.key;
1306 unsigned int idx, dir, ch;
1310 idx = (key >> 16) & 0xff;
1311 dir = (key >> 24) & 0xff;
1312 for (ch = 0; ch < 2; ch++) {
1313 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1315 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1320 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1321 #endif /* SND_HDA_NEEDS_RESUME */
1324 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1325 struct snd_ctl_elem_info *uinfo)
1327 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1328 u16 nid = get_amp_nid(kcontrol);
1329 u8 chs = get_amp_channels(kcontrol);
1330 int dir = get_amp_direction(kcontrol);
1331 unsigned int ofs = get_amp_offset(kcontrol);
1334 caps = query_amp_caps(codec, nid, dir);
1336 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1338 printk(KERN_WARNING "hda_codec: "
1339 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1345 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1346 uinfo->count = chs == 3 ? 2 : 1;
1347 uinfo->value.integer.min = 0;
1348 uinfo->value.integer.max = caps;
1351 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1354 static inline unsigned int
1355 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1356 int ch, int dir, int idx, unsigned int ofs)
1359 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1360 val &= HDA_AMP_VOLMASK;
1369 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1370 int ch, int dir, int idx, unsigned int ofs,
1375 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1376 HDA_AMP_VOLMASK, val);
1379 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1380 struct snd_ctl_elem_value *ucontrol)
1382 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1383 hda_nid_t nid = get_amp_nid(kcontrol);
1384 int chs = get_amp_channels(kcontrol);
1385 int dir = get_amp_direction(kcontrol);
1386 int idx = get_amp_index(kcontrol);
1387 unsigned int ofs = get_amp_offset(kcontrol);
1388 long *valp = ucontrol->value.integer.value;
1391 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1393 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1396 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1398 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1399 struct snd_ctl_elem_value *ucontrol)
1401 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1402 hda_nid_t nid = get_amp_nid(kcontrol);
1403 int chs = get_amp_channels(kcontrol);
1404 int dir = get_amp_direction(kcontrol);
1405 int idx = get_amp_index(kcontrol);
1406 unsigned int ofs = get_amp_offset(kcontrol);
1407 long *valp = ucontrol->value.integer.value;
1410 snd_hda_power_up(codec);
1412 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1416 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1417 snd_hda_power_down(codec);
1420 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1422 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1423 unsigned int size, unsigned int __user *_tlv)
1425 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1426 hda_nid_t nid = get_amp_nid(kcontrol);
1427 int dir = get_amp_direction(kcontrol);
1428 unsigned int ofs = get_amp_offset(kcontrol);
1429 u32 caps, val1, val2;
1431 if (size < 4 * sizeof(unsigned int))
1433 caps = query_amp_caps(codec, nid, dir);
1434 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1435 val2 = (val2 + 1) * 25;
1436 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1438 val1 = ((int)val1) * ((int)val2);
1439 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1441 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1443 if (put_user(val1, _tlv + 2))
1445 if (put_user(val2, _tlv + 3))
1449 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1452 * set (static) TLV for virtual master volume; recalculated as max 0dB
1454 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1460 caps = query_amp_caps(codec, nid, dir);
1461 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1462 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1463 step = (step + 1) * 25;
1464 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1465 tlv[1] = 2 * sizeof(unsigned int);
1466 tlv[2] = -nums * step;
1469 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1471 /* find a mixer control element with the given name */
1472 static struct snd_kcontrol *
1473 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1474 const char *name, int idx)
1476 struct snd_ctl_elem_id id;
1477 memset(&id, 0, sizeof(id));
1478 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1480 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1482 strcpy(id.name, name);
1483 return snd_ctl_find_id(codec->bus->card, &id);
1486 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1489 return _snd_hda_find_mixer_ctl(codec, name, 0);
1491 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1493 /* Add a control element and assign to the codec */
1494 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1497 struct snd_kcontrol **knewp;
1499 err = snd_ctl_add(codec->bus->card, kctl);
1502 knewp = snd_array_new(&codec->mixers);
1508 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1510 /* Clear all controls assigned to the given codec */
1511 void snd_hda_ctls_clear(struct hda_codec *codec)
1514 struct snd_kcontrol **kctls = codec->mixers.list;
1515 for (i = 0; i < codec->mixers.used; i++)
1516 snd_ctl_remove(codec->bus->card, kctls[i]);
1517 snd_array_free(&codec->mixers);
1520 /* pseudo device locking
1521 * toggle card->shutdown to allow/disallow the device access (as a hack)
1523 static int hda_lock_devices(struct snd_card *card)
1525 spin_lock(&card->files_lock);
1526 if (card->shutdown) {
1527 spin_unlock(&card->files_lock);
1531 spin_unlock(&card->files_lock);
1535 static void hda_unlock_devices(struct snd_card *card)
1537 spin_lock(&card->files_lock);
1539 spin_unlock(&card->files_lock);
1542 int snd_hda_codec_reset(struct hda_codec *codec)
1544 struct snd_card *card = codec->bus->card;
1547 if (hda_lock_devices(card) < 0)
1549 /* check whether the codec isn't used by any mixer or PCM streams */
1550 if (!list_empty(&card->ctl_files)) {
1551 hda_unlock_devices(card);
1554 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1555 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1558 if (cpcm->pcm->streams[0].substream_opened ||
1559 cpcm->pcm->streams[1].substream_opened) {
1560 hda_unlock_devices(card);
1565 /* OK, let it free */
1567 #ifdef CONFIG_SND_HDA_POWER_SAVE
1568 cancel_delayed_work(&codec->power_work);
1569 flush_workqueue(codec->bus->workq);
1571 snd_hda_ctls_clear(codec);
1573 for (i = 0; i < codec->num_pcms; i++) {
1574 if (codec->pcm_info[i].pcm) {
1575 snd_device_free(card, codec->pcm_info[i].pcm);
1576 clear_bit(codec->pcm_info[i].device,
1577 codec->bus->pcm_dev_bits);
1580 if (codec->patch_ops.free)
1581 codec->patch_ops.free(codec);
1582 codec->proc_widget_hook = NULL;
1584 free_hda_cache(&codec->amp_cache);
1585 free_hda_cache(&codec->cmd_cache);
1586 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1587 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1588 /* free only driver_pins so that init_pins + user_pins are restored */
1589 snd_array_free(&codec->driver_pins);
1590 restore_pincfgs(codec);
1591 codec->num_pcms = 0;
1592 codec->pcm_info = NULL;
1593 codec->preset = NULL;
1594 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1595 codec->slave_dig_outs = NULL;
1596 codec->spdif_status_reset = 0;
1597 module_put(codec->owner);
1598 codec->owner = NULL;
1600 /* allow device access again */
1601 hda_unlock_devices(card);
1605 /* create a virtual master control and add slaves */
1606 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1607 unsigned int *tlv, const char **slaves)
1609 struct snd_kcontrol *kctl;
1613 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1616 snd_printdd("No slave found for %s\n", name);
1619 kctl = snd_ctl_make_virtual_master(name, tlv);
1622 err = snd_hda_ctl_add(codec, kctl);
1626 for (s = slaves; *s; s++) {
1627 struct snd_kcontrol *sctl;
1630 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1633 snd_printdd("Cannot find slave %s, "
1637 err = snd_ctl_add_slave(kctl, sctl);
1645 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1648 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1649 struct snd_ctl_elem_info *uinfo)
1651 int chs = get_amp_channels(kcontrol);
1653 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1654 uinfo->count = chs == 3 ? 2 : 1;
1655 uinfo->value.integer.min = 0;
1656 uinfo->value.integer.max = 1;
1659 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1661 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1662 struct snd_ctl_elem_value *ucontrol)
1664 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1665 hda_nid_t nid = get_amp_nid(kcontrol);
1666 int chs = get_amp_channels(kcontrol);
1667 int dir = get_amp_direction(kcontrol);
1668 int idx = get_amp_index(kcontrol);
1669 long *valp = ucontrol->value.integer.value;
1672 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1673 HDA_AMP_MUTE) ? 0 : 1;
1675 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1676 HDA_AMP_MUTE) ? 0 : 1;
1679 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1681 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1682 struct snd_ctl_elem_value *ucontrol)
1684 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1685 hda_nid_t nid = get_amp_nid(kcontrol);
1686 int chs = get_amp_channels(kcontrol);
1687 int dir = get_amp_direction(kcontrol);
1688 int idx = get_amp_index(kcontrol);
1689 long *valp = ucontrol->value.integer.value;
1692 snd_hda_power_up(codec);
1694 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1696 *valp ? 0 : HDA_AMP_MUTE);
1700 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1702 *valp ? 0 : HDA_AMP_MUTE);
1703 #ifdef CONFIG_SND_HDA_POWER_SAVE
1704 if (codec->patch_ops.check_power_status)
1705 codec->patch_ops.check_power_status(codec, nid);
1707 snd_hda_power_down(codec);
1710 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1713 * bound volume controls
1715 * bind multiple volumes (# indices, from 0)
1718 #define AMP_VAL_IDX_SHIFT 19
1719 #define AMP_VAL_IDX_MASK (0x0f<<19)
1721 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1722 struct snd_ctl_elem_value *ucontrol)
1724 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1728 mutex_lock(&codec->control_mutex);
1729 pval = kcontrol->private_value;
1730 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1731 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1732 kcontrol->private_value = pval;
1733 mutex_unlock(&codec->control_mutex);
1736 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1738 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1739 struct snd_ctl_elem_value *ucontrol)
1741 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1743 int i, indices, err = 0, change = 0;
1745 mutex_lock(&codec->control_mutex);
1746 pval = kcontrol->private_value;
1747 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1748 for (i = 0; i < indices; i++) {
1749 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1750 (i << AMP_VAL_IDX_SHIFT);
1751 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1756 kcontrol->private_value = pval;
1757 mutex_unlock(&codec->control_mutex);
1758 return err < 0 ? err : change;
1760 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1763 * generic bound volume/swtich controls
1765 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1766 struct snd_ctl_elem_info *uinfo)
1768 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1769 struct hda_bind_ctls *c;
1772 mutex_lock(&codec->control_mutex);
1773 c = (struct hda_bind_ctls *)kcontrol->private_value;
1774 kcontrol->private_value = *c->values;
1775 err = c->ops->info(kcontrol, uinfo);
1776 kcontrol->private_value = (long)c;
1777 mutex_unlock(&codec->control_mutex);
1780 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1782 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1783 struct snd_ctl_elem_value *ucontrol)
1785 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1786 struct hda_bind_ctls *c;
1789 mutex_lock(&codec->control_mutex);
1790 c = (struct hda_bind_ctls *)kcontrol->private_value;
1791 kcontrol->private_value = *c->values;
1792 err = c->ops->get(kcontrol, ucontrol);
1793 kcontrol->private_value = (long)c;
1794 mutex_unlock(&codec->control_mutex);
1797 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1799 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1800 struct snd_ctl_elem_value *ucontrol)
1802 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1803 struct hda_bind_ctls *c;
1804 unsigned long *vals;
1805 int err = 0, change = 0;
1807 mutex_lock(&codec->control_mutex);
1808 c = (struct hda_bind_ctls *)kcontrol->private_value;
1809 for (vals = c->values; *vals; vals++) {
1810 kcontrol->private_value = *vals;
1811 err = c->ops->put(kcontrol, ucontrol);
1816 kcontrol->private_value = (long)c;
1817 mutex_unlock(&codec->control_mutex);
1818 return err < 0 ? err : change;
1820 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1822 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1823 unsigned int size, unsigned int __user *tlv)
1825 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1826 struct hda_bind_ctls *c;
1829 mutex_lock(&codec->control_mutex);
1830 c = (struct hda_bind_ctls *)kcontrol->private_value;
1831 kcontrol->private_value = *c->values;
1832 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1833 kcontrol->private_value = (long)c;
1834 mutex_unlock(&codec->control_mutex);
1837 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1839 struct hda_ctl_ops snd_hda_bind_vol = {
1840 .info = snd_hda_mixer_amp_volume_info,
1841 .get = snd_hda_mixer_amp_volume_get,
1842 .put = snd_hda_mixer_amp_volume_put,
1843 .tlv = snd_hda_mixer_amp_tlv
1845 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1847 struct hda_ctl_ops snd_hda_bind_sw = {
1848 .info = snd_hda_mixer_amp_switch_info,
1849 .get = snd_hda_mixer_amp_switch_get,
1850 .put = snd_hda_mixer_amp_switch_put,
1851 .tlv = snd_hda_mixer_amp_tlv
1853 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1856 * SPDIF out controls
1859 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1860 struct snd_ctl_elem_info *uinfo)
1862 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1867 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1868 struct snd_ctl_elem_value *ucontrol)
1870 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1871 IEC958_AES0_NONAUDIO |
1872 IEC958_AES0_CON_EMPHASIS_5015 |
1873 IEC958_AES0_CON_NOT_COPYRIGHT;
1874 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1875 IEC958_AES1_CON_ORIGINAL;
1879 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1880 struct snd_ctl_elem_value *ucontrol)
1882 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1883 IEC958_AES0_NONAUDIO |
1884 IEC958_AES0_PRO_EMPHASIS_5015;
1888 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1889 struct snd_ctl_elem_value *ucontrol)
1891 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1893 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1894 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1895 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1896 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1901 /* convert from SPDIF status bits to HDA SPDIF bits
1902 * bit 0 (DigEn) is always set zero (to be filled later)
1904 static unsigned short convert_from_spdif_status(unsigned int sbits)
1906 unsigned short val = 0;
1908 if (sbits & IEC958_AES0_PROFESSIONAL)
1909 val |= AC_DIG1_PROFESSIONAL;
1910 if (sbits & IEC958_AES0_NONAUDIO)
1911 val |= AC_DIG1_NONAUDIO;
1912 if (sbits & IEC958_AES0_PROFESSIONAL) {
1913 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1914 IEC958_AES0_PRO_EMPHASIS_5015)
1915 val |= AC_DIG1_EMPHASIS;
1917 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1918 IEC958_AES0_CON_EMPHASIS_5015)
1919 val |= AC_DIG1_EMPHASIS;
1920 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1921 val |= AC_DIG1_COPYRIGHT;
1922 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1923 val |= AC_DIG1_LEVEL;
1924 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1929 /* convert to SPDIF status bits from HDA SPDIF bits
1931 static unsigned int convert_to_spdif_status(unsigned short val)
1933 unsigned int sbits = 0;
1935 if (val & AC_DIG1_NONAUDIO)
1936 sbits |= IEC958_AES0_NONAUDIO;
1937 if (val & AC_DIG1_PROFESSIONAL)
1938 sbits |= IEC958_AES0_PROFESSIONAL;
1939 if (sbits & IEC958_AES0_PROFESSIONAL) {
1940 if (sbits & AC_DIG1_EMPHASIS)
1941 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1943 if (val & AC_DIG1_EMPHASIS)
1944 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1945 if (!(val & AC_DIG1_COPYRIGHT))
1946 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1947 if (val & AC_DIG1_LEVEL)
1948 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1949 sbits |= val & (0x7f << 8);
1954 /* set digital convert verbs both for the given NID and its slaves */
1955 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1960 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1961 d = codec->slave_dig_outs;
1965 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1968 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1972 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1974 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1977 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1978 struct snd_ctl_elem_value *ucontrol)
1980 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1981 hda_nid_t nid = kcontrol->private_value;
1985 mutex_lock(&codec->spdif_mutex);
1986 codec->spdif_status = ucontrol->value.iec958.status[0] |
1987 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1988 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1989 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1990 val = convert_from_spdif_status(codec->spdif_status);
1991 val |= codec->spdif_ctls & 1;
1992 change = codec->spdif_ctls != val;
1993 codec->spdif_ctls = val;
1996 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1998 mutex_unlock(&codec->spdif_mutex);
2002 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2004 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2005 struct snd_ctl_elem_value *ucontrol)
2007 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2009 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
2013 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2014 struct snd_ctl_elem_value *ucontrol)
2016 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2017 hda_nid_t nid = kcontrol->private_value;
2021 mutex_lock(&codec->spdif_mutex);
2022 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2023 if (ucontrol->value.integer.value[0])
2024 val |= AC_DIG1_ENABLE;
2025 change = codec->spdif_ctls != val;
2027 codec->spdif_ctls = val;
2028 set_dig_out_convert(codec, nid, val & 0xff, -1);
2029 /* unmute amp switch (if any) */
2030 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2031 (val & AC_DIG1_ENABLE))
2032 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2035 mutex_unlock(&codec->spdif_mutex);
2039 static struct snd_kcontrol_new dig_mixes[] = {
2041 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2042 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2043 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2044 .info = snd_hda_spdif_mask_info,
2045 .get = snd_hda_spdif_cmask_get,
2048 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2049 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2050 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2051 .info = snd_hda_spdif_mask_info,
2052 .get = snd_hda_spdif_pmask_get,
2055 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2056 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2057 .info = snd_hda_spdif_mask_info,
2058 .get = snd_hda_spdif_default_get,
2059 .put = snd_hda_spdif_default_put,
2062 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2063 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2064 .info = snd_hda_spdif_out_switch_info,
2065 .get = snd_hda_spdif_out_switch_get,
2066 .put = snd_hda_spdif_out_switch_put,
2071 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2074 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2075 * @codec: the HDA codec
2076 * @nid: audio out widget NID
2078 * Creates controls related with the SPDIF output.
2079 * Called from each patch supporting the SPDIF out.
2081 * Returns 0 if successful, or a negative error code.
2083 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2086 struct snd_kcontrol *kctl;
2087 struct snd_kcontrol_new *dig_mix;
2090 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2091 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2095 if (idx >= SPDIF_MAX_IDX) {
2096 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2099 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2100 kctl = snd_ctl_new1(dig_mix, codec);
2103 kctl->id.index = idx;
2104 kctl->private_value = nid;
2105 err = snd_hda_ctl_add(codec, kctl);
2110 snd_hda_codec_read(codec, nid, 0,
2111 AC_VERB_GET_DIGI_CONVERT_1, 0);
2112 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2115 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2118 * SPDIF sharing with analog output
2120 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2121 struct snd_ctl_elem_value *ucontrol)
2123 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2124 ucontrol->value.integer.value[0] = mout->share_spdif;
2128 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2129 struct snd_ctl_elem_value *ucontrol)
2131 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2132 mout->share_spdif = !!ucontrol->value.integer.value[0];
2136 static struct snd_kcontrol_new spdif_share_sw = {
2137 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2138 .name = "IEC958 Default PCM Playback Switch",
2139 .info = snd_ctl_boolean_mono_info,
2140 .get = spdif_share_sw_get,
2141 .put = spdif_share_sw_put,
2144 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2145 struct hda_multi_out *mout)
2147 if (!mout->dig_out_nid)
2149 /* ATTENTION: here mout is passed as private_data, instead of codec */
2150 return snd_hda_ctl_add(codec,
2151 snd_ctl_new1(&spdif_share_sw, mout));
2153 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2159 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2161 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2162 struct snd_ctl_elem_value *ucontrol)
2164 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2166 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2170 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2171 struct snd_ctl_elem_value *ucontrol)
2173 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2174 hda_nid_t nid = kcontrol->private_value;
2175 unsigned int val = !!ucontrol->value.integer.value[0];
2178 mutex_lock(&codec->spdif_mutex);
2179 change = codec->spdif_in_enable != val;
2181 codec->spdif_in_enable = val;
2182 snd_hda_codec_write_cache(codec, nid, 0,
2183 AC_VERB_SET_DIGI_CONVERT_1, val);
2185 mutex_unlock(&codec->spdif_mutex);
2189 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2190 struct snd_ctl_elem_value *ucontrol)
2192 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2193 hda_nid_t nid = kcontrol->private_value;
2197 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2198 sbits = convert_to_spdif_status(val);
2199 ucontrol->value.iec958.status[0] = sbits;
2200 ucontrol->value.iec958.status[1] = sbits >> 8;
2201 ucontrol->value.iec958.status[2] = sbits >> 16;
2202 ucontrol->value.iec958.status[3] = sbits >> 24;
2206 static struct snd_kcontrol_new dig_in_ctls[] = {
2208 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2209 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2210 .info = snd_hda_spdif_in_switch_info,
2211 .get = snd_hda_spdif_in_switch_get,
2212 .put = snd_hda_spdif_in_switch_put,
2215 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2216 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2217 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2218 .info = snd_hda_spdif_mask_info,
2219 .get = snd_hda_spdif_in_status_get,
2225 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2226 * @codec: the HDA codec
2227 * @nid: audio in widget NID
2229 * Creates controls related with the SPDIF input.
2230 * Called from each patch supporting the SPDIF in.
2232 * Returns 0 if successful, or a negative error code.
2234 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2237 struct snd_kcontrol *kctl;
2238 struct snd_kcontrol_new *dig_mix;
2241 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2242 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2246 if (idx >= SPDIF_MAX_IDX) {
2247 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2250 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2251 kctl = snd_ctl_new1(dig_mix, codec);
2254 kctl->private_value = nid;
2255 err = snd_hda_ctl_add(codec, kctl);
2259 codec->spdif_in_enable =
2260 snd_hda_codec_read(codec, nid, 0,
2261 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2265 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2267 #ifdef SND_HDA_NEEDS_RESUME
2272 /* build a 32bit cache key with the widget id and the command parameter */
2273 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2274 #define get_cmd_cache_nid(key) ((key) & 0xff)
2275 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2278 * snd_hda_codec_write_cache - send a single command with caching
2279 * @codec: the HDA codec
2280 * @nid: NID to send the command
2281 * @direct: direct flag
2282 * @verb: the verb to send
2283 * @parm: the parameter for the verb
2285 * Send a single command without waiting for response.
2287 * Returns 0 if successful, or a negative error code.
2289 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2290 int direct, unsigned int verb, unsigned int parm)
2292 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2293 struct hda_cache_head *c;
2298 /* parm may contain the verb stuff for get/set amp */
2299 verb = verb | (parm >> 8);
2301 key = build_cmd_cache_key(nid, verb);
2302 mutex_lock(&codec->bus->cmd_mutex);
2303 c = get_alloc_hash(&codec->cmd_cache, key);
2306 mutex_unlock(&codec->bus->cmd_mutex);
2309 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2311 /* resume the all commands from the cache */
2312 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2314 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2317 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2318 u32 key = buffer->key;
2321 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2322 get_cmd_cache_cmd(key), buffer->val);
2325 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2328 * snd_hda_sequence_write_cache - sequence writes with caching
2329 * @codec: the HDA codec
2330 * @seq: VERB array to send
2332 * Send the commands sequentially from the given array.
2333 * Thte commands are recorded on cache for power-save and resume.
2334 * The array must be terminated with NID=0.
2336 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2337 const struct hda_verb *seq)
2339 for (; seq->nid; seq++)
2340 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2343 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2344 #endif /* SND_HDA_NEEDS_RESUME */
2347 * set power state of the codec
2349 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2350 unsigned int power_state)
2355 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2357 msleep(10); /* partial workaround for "azx_get_response timeout" */
2359 nid = codec->start_nid;
2360 for (i = 0; i < codec->num_nodes; i++, nid++) {
2361 unsigned int wcaps = get_wcaps(codec, nid);
2362 if (wcaps & AC_WCAP_POWER) {
2363 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2365 if (power_state == AC_PWRST_D3 &&
2366 wid_type == AC_WID_PIN) {
2367 unsigned int pincap;
2369 * don't power down the widget if it controls
2370 * eapd and EAPD_BTLENABLE is set.
2372 pincap = snd_hda_query_pin_caps(codec, nid);
2373 if (pincap & AC_PINCAP_EAPD) {
2374 int eapd = snd_hda_codec_read(codec,
2376 AC_VERB_GET_EAPD_BTLENABLE, 0);
2382 snd_hda_codec_write(codec, nid, 0,
2383 AC_VERB_SET_POWER_STATE,
2388 if (power_state == AC_PWRST_D0) {
2389 unsigned long end_time;
2392 /* wait until the codec reachs to D0 */
2393 end_time = jiffies + msecs_to_jiffies(500);
2395 state = snd_hda_codec_read(codec, fg, 0,
2396 AC_VERB_GET_POWER_STATE, 0);
2397 if (state == power_state)
2400 } while (time_after_eq(end_time, jiffies));
2404 #ifdef CONFIG_SND_HDA_HWDEP
2405 /* execute additional init verbs */
2406 static void hda_exec_init_verbs(struct hda_codec *codec)
2408 if (codec->init_verbs.list)
2409 snd_hda_sequence_write(codec, codec->init_verbs.list);
2412 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2415 #ifdef SND_HDA_NEEDS_RESUME
2417 * call suspend and power-down; used both from PM and power-save
2419 static void hda_call_codec_suspend(struct hda_codec *codec)
2421 if (codec->patch_ops.suspend)
2422 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2423 hda_set_power_state(codec,
2424 codec->afg ? codec->afg : codec->mfg,
2426 #ifdef CONFIG_SND_HDA_POWER_SAVE
2427 cancel_delayed_work(&codec->power_work);
2428 codec->power_on = 0;
2429 codec->power_transition = 0;
2434 * kick up codec; used both from PM and power-save
2436 static void hda_call_codec_resume(struct hda_codec *codec)
2438 hda_set_power_state(codec,
2439 codec->afg ? codec->afg : codec->mfg,
2441 restore_pincfgs(codec); /* restore all current pin configs */
2442 hda_exec_init_verbs(codec);
2443 if (codec->patch_ops.resume)
2444 codec->patch_ops.resume(codec);
2446 if (codec->patch_ops.init)
2447 codec->patch_ops.init(codec);
2448 snd_hda_codec_resume_amp(codec);
2449 snd_hda_codec_resume_cache(codec);
2452 #endif /* SND_HDA_NEEDS_RESUME */
2456 * snd_hda_build_controls - build mixer controls
2459 * Creates mixer controls for each codec included in the bus.
2461 * Returns 0 if successful, otherwise a negative error code.
2463 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2465 struct hda_codec *codec;
2467 list_for_each_entry(codec, &bus->codec_list, list) {
2468 int err = snd_hda_codec_build_controls(codec);
2470 printk(KERN_ERR "hda_codec: cannot build controls"
2471 "for #%d (error %d)\n", codec->addr, err);
2472 err = snd_hda_codec_reset(codec);
2475 "hda_codec: cannot revert codec\n");
2482 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2484 int snd_hda_codec_build_controls(struct hda_codec *codec)
2487 hda_exec_init_verbs(codec);
2488 /* continue to initialize... */
2489 if (codec->patch_ops.init)
2490 err = codec->patch_ops.init(codec);
2491 if (!err && codec->patch_ops.build_controls)
2492 err = codec->patch_ops.build_controls(codec);
2501 struct hda_rate_tbl {
2503 unsigned int alsa_bits;
2504 unsigned int hda_fmt;
2507 static struct hda_rate_tbl rate_bits[] = {
2508 /* rate in Hz, ALSA rate bitmask, HDA format value */
2510 /* autodetected value used in snd_hda_query_supported_pcm */
2511 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2512 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2513 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2514 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2515 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2516 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2517 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2518 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2519 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2520 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2521 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2522 #define AC_PAR_PCM_RATE_BITS 11
2523 /* up to bits 10, 384kHZ isn't supported properly */
2525 /* not autodetected value */
2526 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2528 { 0 } /* terminator */
2532 * snd_hda_calc_stream_format - calculate format bitset
2533 * @rate: the sample rate
2534 * @channels: the number of channels
2535 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2536 * @maxbps: the max. bps
2538 * Calculate the format bitset from the given rate, channels and th PCM format.
2540 * Return zero if invalid.
2542 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2543 unsigned int channels,
2544 unsigned int format,
2545 unsigned int maxbps)
2548 unsigned int val = 0;
2550 for (i = 0; rate_bits[i].hz; i++)
2551 if (rate_bits[i].hz == rate) {
2552 val = rate_bits[i].hda_fmt;
2555 if (!rate_bits[i].hz) {
2556 snd_printdd("invalid rate %d\n", rate);
2560 if (channels == 0 || channels > 8) {
2561 snd_printdd("invalid channels %d\n", channels);
2564 val |= channels - 1;
2566 switch (snd_pcm_format_width(format)) {
2567 case 8: val |= 0x00; break;
2568 case 16: val |= 0x10; break;
2574 else if (maxbps >= 24)
2580 snd_printdd("invalid format width %d\n",
2581 snd_pcm_format_width(format));
2587 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2589 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2591 unsigned int val = 0;
2592 if (nid != codec->afg &&
2593 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2594 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2595 if (!val || val == -1)
2596 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2597 if (!val || val == -1)
2602 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2604 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2608 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2610 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2611 if (!streams || streams == -1)
2612 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2613 if (!streams || streams == -1)
2618 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2620 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2625 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2626 * @codec: the HDA codec
2627 * @nid: NID to query
2628 * @ratesp: the pointer to store the detected rate bitflags
2629 * @formatsp: the pointer to store the detected formats
2630 * @bpsp: the pointer to store the detected format widths
2632 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2633 * or @bsps argument is ignored.
2635 * Returns 0 if successful, otherwise a negative error code.
2637 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2638 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2640 unsigned int i, val, wcaps;
2642 wcaps = get_wcaps(codec, nid);
2643 val = query_pcm_param(codec, nid);
2647 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2649 rates |= rate_bits[i].alsa_bits;
2652 snd_printk(KERN_ERR "hda_codec: rates == 0 "
2653 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2655 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2661 if (formatsp || bpsp) {
2663 unsigned int streams, bps;
2665 streams = query_stream_param(codec, nid);
2670 if (streams & AC_SUPFMT_PCM) {
2671 if (val & AC_SUPPCM_BITS_8) {
2672 formats |= SNDRV_PCM_FMTBIT_U8;
2675 if (val & AC_SUPPCM_BITS_16) {
2676 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2679 if (wcaps & AC_WCAP_DIGITAL) {
2680 if (val & AC_SUPPCM_BITS_32)
2681 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2682 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2683 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2684 if (val & AC_SUPPCM_BITS_24)
2686 else if (val & AC_SUPPCM_BITS_20)
2688 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2689 AC_SUPPCM_BITS_32)) {
2690 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2691 if (val & AC_SUPPCM_BITS_32)
2693 else if (val & AC_SUPPCM_BITS_24)
2695 else if (val & AC_SUPPCM_BITS_20)
2699 else if (streams == AC_SUPFMT_FLOAT32) {
2700 /* should be exclusive */
2701 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2703 } else if (streams == AC_SUPFMT_AC3) {
2704 /* should be exclusive */
2705 /* temporary hack: we have still no proper support
2706 * for the direct AC3 stream...
2708 formats |= SNDRV_PCM_FMTBIT_U8;
2712 snd_printk(KERN_ERR "hda_codec: formats == 0 "
2713 "(nid=0x%x, val=0x%x, ovrd=%i, "
2716 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2721 *formatsp = formats;
2730 * snd_hda_is_supported_format - check whether the given node supports
2733 * Returns 1 if supported, 0 if not.
2735 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2736 unsigned int format)
2739 unsigned int val = 0, rate, stream;
2741 val = query_pcm_param(codec, nid);
2745 rate = format & 0xff00;
2746 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2747 if (rate_bits[i].hda_fmt == rate) {
2752 if (i >= AC_PAR_PCM_RATE_BITS)
2755 stream = query_stream_param(codec, nid);
2759 if (stream & AC_SUPFMT_PCM) {
2760 switch (format & 0xf0) {
2762 if (!(val & AC_SUPPCM_BITS_8))
2766 if (!(val & AC_SUPPCM_BITS_16))
2770 if (!(val & AC_SUPPCM_BITS_20))
2774 if (!(val & AC_SUPPCM_BITS_24))
2778 if (!(val & AC_SUPPCM_BITS_32))
2785 /* FIXME: check for float32 and AC3? */
2790 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2795 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2796 struct hda_codec *codec,
2797 struct snd_pcm_substream *substream)
2802 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2803 struct hda_codec *codec,
2804 unsigned int stream_tag,
2805 unsigned int format,
2806 struct snd_pcm_substream *substream)
2808 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2812 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2813 struct hda_codec *codec,
2814 struct snd_pcm_substream *substream)
2816 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2820 static int set_pcm_default_values(struct hda_codec *codec,
2821 struct hda_pcm_stream *info)
2825 /* query support PCM information from the given NID */
2826 if (info->nid && (!info->rates || !info->formats)) {
2827 err = snd_hda_query_supported_pcm(codec, info->nid,
2828 info->rates ? NULL : &info->rates,
2829 info->formats ? NULL : &info->formats,
2830 info->maxbps ? NULL : &info->maxbps);
2834 if (info->ops.open == NULL)
2835 info->ops.open = hda_pcm_default_open_close;
2836 if (info->ops.close == NULL)
2837 info->ops.close = hda_pcm_default_open_close;
2838 if (info->ops.prepare == NULL) {
2839 if (snd_BUG_ON(!info->nid))
2841 info->ops.prepare = hda_pcm_default_prepare;
2843 if (info->ops.cleanup == NULL) {
2844 if (snd_BUG_ON(!info->nid))
2846 info->ops.cleanup = hda_pcm_default_cleanup;
2852 * get the empty PCM device number to assign
2854 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2856 static const char *dev_name[HDA_PCM_NTYPES] = {
2857 "Audio", "SPDIF", "HDMI", "Modem"
2859 /* starting device index for each PCM type */
2860 static int dev_idx[HDA_PCM_NTYPES] = {
2861 [HDA_PCM_TYPE_AUDIO] = 0,
2862 [HDA_PCM_TYPE_SPDIF] = 1,
2863 [HDA_PCM_TYPE_HDMI] = 3,
2864 [HDA_PCM_TYPE_MODEM] = 6
2866 /* normal audio device indices; not linear to keep compatibility */
2867 static int audio_idx[4] = { 0, 2, 4, 5 };
2871 case HDA_PCM_TYPE_AUDIO:
2872 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2874 if (!test_bit(dev, bus->pcm_dev_bits))
2877 snd_printk(KERN_WARNING "Too many audio devices\n");
2879 case HDA_PCM_TYPE_SPDIF:
2880 case HDA_PCM_TYPE_HDMI:
2881 case HDA_PCM_TYPE_MODEM:
2882 dev = dev_idx[type];
2883 if (test_bit(dev, bus->pcm_dev_bits)) {
2884 snd_printk(KERN_WARNING "%s already defined\n",
2890 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2894 set_bit(dev, bus->pcm_dev_bits);
2899 * attach a new PCM stream
2901 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2903 struct hda_bus *bus = codec->bus;
2904 struct hda_pcm_stream *info;
2907 if (snd_BUG_ON(!pcm->name))
2909 for (stream = 0; stream < 2; stream++) {
2910 info = &pcm->stream[stream];
2911 if (info->substreams) {
2912 err = set_pcm_default_values(codec, info);
2917 return bus->ops.attach_pcm(bus, codec, pcm);
2920 /* assign all PCMs of the given codec */
2921 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2926 if (!codec->num_pcms) {
2927 if (!codec->patch_ops.build_pcms)
2929 err = codec->patch_ops.build_pcms(codec);
2931 printk(KERN_ERR "hda_codec: cannot build PCMs"
2932 "for #%d (error %d)\n", codec->addr, err);
2933 err = snd_hda_codec_reset(codec);
2936 "hda_codec: cannot revert codec\n");
2941 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2942 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2945 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2946 continue; /* no substreams assigned */
2949 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2951 continue; /* no fatal error */
2953 err = snd_hda_attach_pcm(codec, cpcm);
2955 printk(KERN_ERR "hda_codec: cannot attach "
2956 "PCM stream %d for codec #%d\n",
2958 continue; /* no fatal error */
2966 * snd_hda_build_pcms - build PCM information
2969 * Create PCM information for each codec included in the bus.
2971 * The build_pcms codec patch is requested to set up codec->num_pcms and
2972 * codec->pcm_info properly. The array is referred by the top-level driver
2973 * to create its PCM instances.
2974 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2977 * At least, substreams, channels_min and channels_max must be filled for
2978 * each stream. substreams = 0 indicates that the stream doesn't exist.
2979 * When rates and/or formats are zero, the supported values are queried
2980 * from the given nid. The nid is used also by the default ops.prepare
2981 * and ops.cleanup callbacks.
2983 * The driver needs to call ops.open in its open callback. Similarly,
2984 * ops.close is supposed to be called in the close callback.
2985 * ops.prepare should be called in the prepare or hw_params callback
2986 * with the proper parameters for set up.
2987 * ops.cleanup should be called in hw_free for clean up of streams.
2989 * This function returns 0 if successfull, or a negative error code.
2991 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2993 struct hda_codec *codec;
2995 list_for_each_entry(codec, &bus->codec_list, list) {
2996 int err = snd_hda_codec_build_pcms(codec);
3002 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
3005 * snd_hda_check_board_config - compare the current codec with the config table
3006 * @codec: the HDA codec
3007 * @num_configs: number of config enums
3008 * @models: array of model name strings
3009 * @tbl: configuration table, terminated by null entries
3011 * Compares the modelname or PCI subsystem id of the current codec with the
3012 * given configuration table. If a matching entry is found, returns its
3013 * config value (supposed to be 0 or positive).
3015 * If no entries are matching, the function returns a negative value.
3017 int snd_hda_check_board_config(struct hda_codec *codec,
3018 int num_configs, const char **models,
3019 const struct snd_pci_quirk *tbl)
3021 if (codec->modelname && models) {
3023 for (i = 0; i < num_configs; i++) {
3025 !strcmp(codec->modelname, models[i])) {
3026 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3027 "selected\n", models[i]);
3033 if (!codec->bus->pci || !tbl)
3036 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3039 if (tbl->value >= 0 && tbl->value < num_configs) {
3040 #ifdef CONFIG_SND_DEBUG_VERBOSE
3042 const char *model = NULL;
3044 model = models[tbl->value];
3046 sprintf(tmp, "#%d", tbl->value);
3049 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3050 "for config %x:%x (%s)\n",
3051 model, tbl->subvendor, tbl->subdevice,
3052 (tbl->name ? tbl->name : "Unknown device"));
3058 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3061 * snd_hda_check_board_codec_sid_config - compare the current codec
3062 subsystem ID with the
3065 This is important for Gateway notebooks with SB450 HDA Audio
3066 where the vendor ID of the PCI device is:
3067 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3068 and the vendor/subvendor are found only at the codec.
3070 * @codec: the HDA codec
3071 * @num_configs: number of config enums
3072 * @models: array of model name strings
3073 * @tbl: configuration table, terminated by null entries
3075 * Compares the modelname or PCI subsystem id of the current codec with the
3076 * given configuration table. If a matching entry is found, returns its
3077 * config value (supposed to be 0 or positive).
3079 * If no entries are matching, the function returns a negative value.
3081 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3082 int num_configs, const char **models,
3083 const struct snd_pci_quirk *tbl)
3085 const struct snd_pci_quirk *q;
3087 /* Search for codec ID */
3088 for (q = tbl; q->subvendor; q++) {
3089 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3091 if (vendorid == codec->subsystem_id)
3100 if (tbl->value >= 0 && tbl->value < num_configs) {
3101 #ifdef CONFIG_SND_DEBUG_DETECT
3103 const char *model = NULL;
3105 model = models[tbl->value];
3107 sprintf(tmp, "#%d", tbl->value);
3110 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3111 "for config %x:%x (%s)\n",
3112 model, tbl->subvendor, tbl->subdevice,
3113 (tbl->name ? tbl->name : "Unknown device"));
3119 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3122 * snd_hda_add_new_ctls - create controls from the array
3123 * @codec: the HDA codec
3124 * @knew: the array of struct snd_kcontrol_new
3126 * This helper function creates and add new controls in the given array.
3127 * The array must be terminated with an empty entry as terminator.
3129 * Returns 0 if successful, or a negative error code.
3131 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3135 for (; knew->name; knew++) {
3136 struct snd_kcontrol *kctl;
3137 kctl = snd_ctl_new1(knew, codec);
3140 err = snd_hda_ctl_add(codec, kctl);
3144 kctl = snd_ctl_new1(knew, codec);
3147 kctl->id.device = codec->addr;
3148 err = snd_hda_ctl_add(codec, kctl);
3155 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3157 #ifdef CONFIG_SND_HDA_POWER_SAVE
3158 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3159 unsigned int power_state);
3161 static void hda_power_work(struct work_struct *work)
3163 struct hda_codec *codec =
3164 container_of(work, struct hda_codec, power_work.work);
3165 struct hda_bus *bus = codec->bus;
3167 if (!codec->power_on || codec->power_count) {
3168 codec->power_transition = 0;
3172 hda_call_codec_suspend(codec);
3173 if (bus->ops.pm_notify)
3174 bus->ops.pm_notify(bus);
3177 static void hda_keep_power_on(struct hda_codec *codec)
3179 codec->power_count++;
3180 codec->power_on = 1;
3183 void snd_hda_power_up(struct hda_codec *codec)
3185 struct hda_bus *bus = codec->bus;
3187 codec->power_count++;
3188 if (codec->power_on || codec->power_transition)
3191 codec->power_on = 1;
3192 if (bus->ops.pm_notify)
3193 bus->ops.pm_notify(bus);
3194 hda_call_codec_resume(codec);
3195 cancel_delayed_work(&codec->power_work);
3196 codec->power_transition = 0;
3198 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3200 #define power_save(codec) \
3201 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3203 #define power_save(codec) \
3204 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3206 void snd_hda_power_down(struct hda_codec *codec)
3208 --codec->power_count;
3209 if (!codec->power_on || codec->power_count || codec->power_transition)
3211 if (power_save(codec)) {
3212 codec->power_transition = 1; /* avoid reentrance */
3213 queue_delayed_work(codec->bus->workq, &codec->power_work,
3214 msecs_to_jiffies(power_save(codec) * 1000));
3217 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3219 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3220 struct hda_loopback_check *check,
3223 struct hda_amp_list *p;
3226 if (!check->amplist)
3228 for (p = check->amplist; p->nid; p++) {
3233 return 0; /* nothing changed */
3235 for (p = check->amplist; p->nid; p++) {
3236 for (ch = 0; ch < 2; ch++) {
3237 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3239 if (!(v & HDA_AMP_MUTE) && v > 0) {
3240 if (!check->power_on) {
3241 check->power_on = 1;
3242 snd_hda_power_up(codec);
3248 if (check->power_on) {
3249 check->power_on = 0;
3250 snd_hda_power_down(codec);
3254 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3258 * Channel mode helper
3260 int snd_hda_ch_mode_info(struct hda_codec *codec,
3261 struct snd_ctl_elem_info *uinfo,
3262 const struct hda_channel_mode *chmode,
3265 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3267 uinfo->value.enumerated.items = num_chmodes;
3268 if (uinfo->value.enumerated.item >= num_chmodes)
3269 uinfo->value.enumerated.item = num_chmodes - 1;
3270 sprintf(uinfo->value.enumerated.name, "%dch",
3271 chmode[uinfo->value.enumerated.item].channels);
3274 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3276 int snd_hda_ch_mode_get(struct hda_codec *codec,
3277 struct snd_ctl_elem_value *ucontrol,
3278 const struct hda_channel_mode *chmode,
3284 for (i = 0; i < num_chmodes; i++) {
3285 if (max_channels == chmode[i].channels) {
3286 ucontrol->value.enumerated.item[0] = i;
3292 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3294 int snd_hda_ch_mode_put(struct hda_codec *codec,
3295 struct snd_ctl_elem_value *ucontrol,
3296 const struct hda_channel_mode *chmode,
3302 mode = ucontrol->value.enumerated.item[0];
3303 if (mode >= num_chmodes)
3305 if (*max_channelsp == chmode[mode].channels)
3307 /* change the current channel setting */
3308 *max_channelsp = chmode[mode].channels;
3309 if (chmode[mode].sequence)
3310 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3313 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3318 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3319 struct snd_ctl_elem_info *uinfo)
3323 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3325 uinfo->value.enumerated.items = imux->num_items;
3326 if (!imux->num_items)
3328 index = uinfo->value.enumerated.item;
3329 if (index >= imux->num_items)
3330 index = imux->num_items - 1;
3331 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3334 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3336 int snd_hda_input_mux_put(struct hda_codec *codec,
3337 const struct hda_input_mux *imux,
3338 struct snd_ctl_elem_value *ucontrol,
3340 unsigned int *cur_val)
3344 if (!imux->num_items)
3346 idx = ucontrol->value.enumerated.item[0];
3347 if (idx >= imux->num_items)
3348 idx = imux->num_items - 1;
3349 if (*cur_val == idx)
3351 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3352 imux->items[idx].index);
3356 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3360 * Multi-channel / digital-out PCM helper functions
3363 /* setup SPDIF output stream */
3364 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3365 unsigned int stream_tag, unsigned int format)
3367 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3368 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3369 set_dig_out_convert(codec, nid,
3370 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3372 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3373 if (codec->slave_dig_outs) {
3375 for (d = codec->slave_dig_outs; *d; d++)
3376 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3379 /* turn on again (if needed) */
3380 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3381 set_dig_out_convert(codec, nid,
3382 codec->spdif_ctls & 0xff, -1);
3385 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3387 snd_hda_codec_cleanup_stream(codec, nid);
3388 if (codec->slave_dig_outs) {
3390 for (d = codec->slave_dig_outs; *d; d++)
3391 snd_hda_codec_cleanup_stream(codec, *d);
3396 * open the digital out in the exclusive mode
3398 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3399 struct hda_multi_out *mout)
3401 mutex_lock(&codec->spdif_mutex);
3402 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3403 /* already opened as analog dup; reset it once */
3404 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3405 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3406 mutex_unlock(&codec->spdif_mutex);
3409 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3411 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3412 struct hda_multi_out *mout,
3413 unsigned int stream_tag,
3414 unsigned int format,
3415 struct snd_pcm_substream *substream)
3417 mutex_lock(&codec->spdif_mutex);
3418 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3419 mutex_unlock(&codec->spdif_mutex);
3422 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3424 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3425 struct hda_multi_out *mout)
3427 mutex_lock(&codec->spdif_mutex);
3428 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3429 mutex_unlock(&codec->spdif_mutex);
3432 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3435 * release the digital out
3437 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3438 struct hda_multi_out *mout)
3440 mutex_lock(&codec->spdif_mutex);
3441 mout->dig_out_used = 0;
3442 mutex_unlock(&codec->spdif_mutex);
3445 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3448 * set up more restrictions for analog out
3450 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3451 struct hda_multi_out *mout,
3452 struct snd_pcm_substream *substream,
3453 struct hda_pcm_stream *hinfo)
3455 struct snd_pcm_runtime *runtime = substream->runtime;
3456 runtime->hw.channels_max = mout->max_channels;
3457 if (mout->dig_out_nid) {
3458 if (!mout->analog_rates) {
3459 mout->analog_rates = hinfo->rates;
3460 mout->analog_formats = hinfo->formats;
3461 mout->analog_maxbps = hinfo->maxbps;
3463 runtime->hw.rates = mout->analog_rates;
3464 runtime->hw.formats = mout->analog_formats;
3465 hinfo->maxbps = mout->analog_maxbps;
3467 if (!mout->spdif_rates) {
3468 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3470 &mout->spdif_formats,
3471 &mout->spdif_maxbps);
3473 mutex_lock(&codec->spdif_mutex);
3474 if (mout->share_spdif) {
3475 runtime->hw.rates &= mout->spdif_rates;
3476 runtime->hw.formats &= mout->spdif_formats;
3477 if (mout->spdif_maxbps < hinfo->maxbps)
3478 hinfo->maxbps = mout->spdif_maxbps;
3480 mutex_unlock(&codec->spdif_mutex);
3482 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3483 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3485 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3488 * set up the i/o for analog out
3489 * when the digital out is available, copy the front out to digital out, too.
3491 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3492 struct hda_multi_out *mout,
3493 unsigned int stream_tag,
3494 unsigned int format,
3495 struct snd_pcm_substream *substream)
3497 hda_nid_t *nids = mout->dac_nids;
3498 int chs = substream->runtime->channels;
3501 mutex_lock(&codec->spdif_mutex);
3502 if (mout->dig_out_nid && mout->share_spdif &&
3503 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3505 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3507 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3508 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3509 setup_dig_out_stream(codec, mout->dig_out_nid,
3510 stream_tag, format);
3512 mout->dig_out_used = 0;
3513 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3516 mutex_unlock(&codec->spdif_mutex);
3519 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3521 if (!mout->no_share_stream &&
3522 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3523 /* headphone out will just decode front left/right (stereo) */
3524 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3526 /* extra outputs copied from front */
3527 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3528 if (!mout->no_share_stream && mout->extra_out_nid[i])
3529 snd_hda_codec_setup_stream(codec,
3530 mout->extra_out_nid[i],
3531 stream_tag, 0, format);
3534 for (i = 1; i < mout->num_dacs; i++) {
3535 if (chs >= (i + 1) * 2) /* independent out */
3536 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3538 else if (!mout->no_share_stream) /* copy front */
3539 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3544 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3547 * clean up the setting for analog out
3549 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3550 struct hda_multi_out *mout)
3552 hda_nid_t *nids = mout->dac_nids;
3555 for (i = 0; i < mout->num_dacs; i++)
3556 snd_hda_codec_cleanup_stream(codec, nids[i]);
3558 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3559 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3560 if (mout->extra_out_nid[i])
3561 snd_hda_codec_cleanup_stream(codec,
3562 mout->extra_out_nid[i]);
3563 mutex_lock(&codec->spdif_mutex);
3564 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3565 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3566 mout->dig_out_used = 0;
3568 mutex_unlock(&codec->spdif_mutex);
3571 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3574 * Helper for automatic pin configuration
3577 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3579 for (; *list; list++)
3587 * Sort an associated group of pins according to their sequence numbers.
3589 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3596 for (i = 0; i < num_pins; i++) {
3597 for (j = i + 1; j < num_pins; j++) {
3598 if (sequences[i] > sequences[j]) {
3600 sequences[i] = sequences[j];
3612 * Parse all pin widgets and store the useful pin nids to cfg
3614 * The number of line-outs or any primary output is stored in line_outs,
3615 * and the corresponding output pins are assigned to line_out_pins[],
3616 * in the order of front, rear, CLFE, side, ...
3618 * If more extra outputs (speaker and headphone) are found, the pins are
3619 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3620 * is detected, one of speaker of HP pins is assigned as the primary
3621 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3622 * if any analog output exists.
3624 * The analog input pins are assigned to input_pins array.
3625 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3628 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3629 struct auto_pin_cfg *cfg,
3630 hda_nid_t *ignore_nids)
3632 hda_nid_t nid, end_nid;
3633 short seq, assoc_line_out, assoc_speaker;
3634 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3635 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3636 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3638 memset(cfg, 0, sizeof(*cfg));
3640 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3641 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3642 memset(sequences_hp, 0, sizeof(sequences_hp));
3643 assoc_line_out = assoc_speaker = 0;
3645 end_nid = codec->start_nid + codec->num_nodes;
3646 for (nid = codec->start_nid; nid < end_nid; nid++) {
3647 unsigned int wid_caps = get_wcaps(codec, nid);
3648 unsigned int wid_type =
3649 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3650 unsigned int def_conf;
3653 /* read all default configuration for pin complex */
3654 if (wid_type != AC_WID_PIN)
3656 /* ignore the given nids (e.g. pc-beep returns error) */
3657 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3660 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3661 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3663 loc = get_defcfg_location(def_conf);
3664 switch (get_defcfg_device(def_conf)) {
3665 case AC_JACK_LINE_OUT:
3666 seq = get_defcfg_sequence(def_conf);
3667 assoc = get_defcfg_association(def_conf);
3669 if (!(wid_caps & AC_WCAP_STEREO))
3670 if (!cfg->mono_out_pin)
3671 cfg->mono_out_pin = nid;
3674 if (!assoc_line_out)
3675 assoc_line_out = assoc;
3676 else if (assoc_line_out != assoc)
3678 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3680 cfg->line_out_pins[cfg->line_outs] = nid;
3681 sequences_line_out[cfg->line_outs] = seq;
3684 case AC_JACK_SPEAKER:
3685 seq = get_defcfg_sequence(def_conf);
3686 assoc = get_defcfg_association(def_conf);
3689 if (! assoc_speaker)
3690 assoc_speaker = assoc;
3691 else if (assoc_speaker != assoc)
3693 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3695 cfg->speaker_pins[cfg->speaker_outs] = nid;
3696 sequences_speaker[cfg->speaker_outs] = seq;
3697 cfg->speaker_outs++;
3699 case AC_JACK_HP_OUT:
3700 seq = get_defcfg_sequence(def_conf);
3701 assoc = get_defcfg_association(def_conf);
3702 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3704 cfg->hp_pins[cfg->hp_outs] = nid;
3705 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3708 case AC_JACK_MIC_IN: {
3710 if (loc == AC_JACK_LOC_FRONT) {
3711 preferred = AUTO_PIN_FRONT_MIC;
3714 preferred = AUTO_PIN_MIC;
3715 alt = AUTO_PIN_FRONT_MIC;
3717 if (!cfg->input_pins[preferred])
3718 cfg->input_pins[preferred] = nid;
3719 else if (!cfg->input_pins[alt])
3720 cfg->input_pins[alt] = nid;
3723 case AC_JACK_LINE_IN:
3724 if (loc == AC_JACK_LOC_FRONT)
3725 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3727 cfg->input_pins[AUTO_PIN_LINE] = nid;
3730 cfg->input_pins[AUTO_PIN_CD] = nid;
3733 cfg->input_pins[AUTO_PIN_AUX] = nid;
3735 case AC_JACK_SPDIF_OUT:
3736 case AC_JACK_DIG_OTHER_OUT:
3737 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3739 cfg->dig_out_pins[cfg->dig_outs] = nid;
3740 cfg->dig_out_type[cfg->dig_outs] =
3741 (loc == AC_JACK_LOC_HDMI) ?
3742 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3745 case AC_JACK_SPDIF_IN:
3746 case AC_JACK_DIG_OTHER_IN:
3747 cfg->dig_in_pin = nid;
3748 if (loc == AC_JACK_LOC_HDMI)
3749 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3751 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
3757 * If no line-out is defined but multiple HPs are found,
3758 * some of them might be the real line-outs.
3760 if (!cfg->line_outs && cfg->hp_outs > 1) {
3762 while (i < cfg->hp_outs) {
3763 /* The real HPs should have the sequence 0x0f */
3764 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3768 /* Move it to the line-out table */
3769 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3770 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3773 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3774 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3775 memmove(sequences_hp + i - 1, sequences_hp + i,
3776 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3780 /* sort by sequence */
3781 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3783 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3785 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3788 /* if we have only one mic, make it AUTO_PIN_MIC */
3789 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3790 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3791 cfg->input_pins[AUTO_PIN_MIC] =
3792 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3793 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3795 /* ditto for line-in */
3796 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3797 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3798 cfg->input_pins[AUTO_PIN_LINE] =
3799 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3800 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3804 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3805 * as a primary output
3807 if (!cfg->line_outs) {
3808 if (cfg->speaker_outs) {
3809 cfg->line_outs = cfg->speaker_outs;
3810 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3811 sizeof(cfg->speaker_pins));
3812 cfg->speaker_outs = 0;
3813 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3814 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3815 } else if (cfg->hp_outs) {
3816 cfg->line_outs = cfg->hp_outs;
3817 memcpy(cfg->line_out_pins, cfg->hp_pins,
3818 sizeof(cfg->hp_pins));
3820 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3821 cfg->line_out_type = AUTO_PIN_HP_OUT;
3825 /* Reorder the surround channels
3826 * ALSA sequence is front/surr/clfe/side
3828 * 4-ch: front/surr => OK as it is
3829 * 6-ch: front/clfe/surr
3830 * 8-ch: front/clfe/rear/side|fc
3832 switch (cfg->line_outs) {
3835 nid = cfg->line_out_pins[1];
3836 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3837 cfg->line_out_pins[2] = nid;
3842 * debug prints of the parsed results
3844 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3845 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3846 cfg->line_out_pins[2], cfg->line_out_pins[3],
3847 cfg->line_out_pins[4]);
3848 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3849 cfg->speaker_outs, cfg->speaker_pins[0],
3850 cfg->speaker_pins[1], cfg->speaker_pins[2],
3851 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3852 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3853 cfg->hp_outs, cfg->hp_pins[0],
3854 cfg->hp_pins[1], cfg->hp_pins[2],
3855 cfg->hp_pins[3], cfg->hp_pins[4]);
3856 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3858 snd_printd(" dig-out=0x%x/0x%x\n",
3859 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
3860 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3861 " cd=0x%x, aux=0x%x\n",
3862 cfg->input_pins[AUTO_PIN_MIC],
3863 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3864 cfg->input_pins[AUTO_PIN_LINE],
3865 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3866 cfg->input_pins[AUTO_PIN_CD],
3867 cfg->input_pins[AUTO_PIN_AUX]);
3868 if (cfg->dig_in_pin)
3869 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
3873 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3875 /* labels for input pins */
3876 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3877 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3879 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3888 * snd_hda_suspend - suspend the codecs
3891 * Returns 0 if successful.
3893 int snd_hda_suspend(struct hda_bus *bus)
3895 struct hda_codec *codec;
3897 list_for_each_entry(codec, &bus->codec_list, list) {
3898 #ifdef CONFIG_SND_HDA_POWER_SAVE
3899 if (!codec->power_on)
3902 hda_call_codec_suspend(codec);
3906 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3909 * snd_hda_resume - resume the codecs
3912 * Returns 0 if successful.
3914 * This fucntion is defined only when POWER_SAVE isn't set.
3915 * In the power-save mode, the codec is resumed dynamically.
3917 int snd_hda_resume(struct hda_bus *bus)
3919 struct hda_codec *codec;
3921 list_for_each_entry(codec, &bus->codec_list, list) {
3922 if (snd_hda_codec_needs_resume(codec))
3923 hda_call_codec_resume(codec);
3927 EXPORT_SYMBOL_HDA(snd_hda_resume);
3928 #endif /* CONFIG_PM */
3934 /* get a new element from the given array
3935 * if it exceeds the pre-allocated array size, re-allocate the array
3937 void *snd_array_new(struct snd_array *array)
3939 if (array->used >= array->alloced) {
3940 int num = array->alloced + array->alloc_align;
3942 if (snd_BUG_ON(num >= 4096))
3944 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3948 memcpy(nlist, array->list,
3949 array->elem_size * array->alloced);
3952 array->list = nlist;
3953 array->alloced = num;
3955 return snd_array_elem(array, array->used++);
3957 EXPORT_SYMBOL_HDA(snd_array_new);
3959 /* free the given array elements */
3960 void snd_array_free(struct snd_array *array)
3967 EXPORT_SYMBOL_HDA(snd_array_free);
3970 * used by hda_proc.c and hda_eld.c
3972 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3974 static unsigned int rates[] = {
3975 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3976 96000, 176400, 192000, 384000
3980 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3982 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3984 buf[j] = '\0'; /* necessary when j == 0 */
3986 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3988 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3990 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3993 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3994 if (pcm & (AC_SUPPCM_BITS_8 << i))
3995 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3997 buf[j] = '\0'; /* necessary when j == 0 */
3999 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
4001 MODULE_DESCRIPTION("HDA codec core");
4002 MODULE_LICENSE("GPL");