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;
168 int err, repeated = 0;
172 snd_hda_power_up(codec);
173 mutex_lock(&bus->cmd_mutex);
175 err = bus->ops.command(bus, cmd);
178 *res = bus->ops.get_response(bus);
179 if (*res == -1 && bus->rirb_error) {
180 if (repeated++ < 1) {
181 snd_printd(KERN_WARNING "hda_codec: "
182 "Trying verb 0x%08x again\n", cmd);
188 mutex_unlock(&bus->cmd_mutex);
189 snd_hda_power_down(codec);
194 * snd_hda_codec_read - send a command and get the response
195 * @codec: the HDA codec
196 * @nid: NID to send the command
197 * @direct: direct flag
198 * @verb: the verb to send
199 * @parm: the parameter for the verb
201 * Send a single command and read the corresponding response.
203 * Returns the obtained response value, or -1 for an error.
205 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
207 unsigned int verb, unsigned int parm)
209 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
211 codec_exec_verb(codec, cmd, &res);
214 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
216 /* Define the below to send and receive verbs synchronously.
217 * If you often get any codec communication errors, this is worth to try.
219 /* #define SND_HDA_SUPPORT_SYNC_WRITE */
222 * snd_hda_codec_write - send a single command without waiting for response
223 * @codec: the HDA codec
224 * @nid: NID to send the command
225 * @direct: direct flag
226 * @verb: the verb to send
227 * @parm: the parameter for the verb
229 * Send a single command without waiting for response.
231 * Returns 0 if successful, or a negative error code.
233 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
234 unsigned int verb, unsigned int parm)
236 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
237 #ifdef SND_HDA_SUPPORT_SYNC_WRITE
239 return codec_exec_verb(codec, cmd, &res);
241 return codec_exec_verb(codec, cmd, NULL);
244 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
247 * snd_hda_sequence_write - sequence writes
248 * @codec: the HDA codec
249 * @seq: VERB array to send
251 * Send the commands sequentially from the given array.
252 * The array must be terminated with NID=0.
254 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
256 for (; seq->nid; seq++)
257 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
259 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
262 * snd_hda_get_sub_nodes - get the range of sub nodes
263 * @codec: the HDA codec
265 * @start_id: the pointer to store the start NID
267 * Parse the NID and store the start NID of its sub-nodes.
268 * Returns the number of sub-nodes.
270 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
275 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
278 *start_id = (parm >> 16) & 0x7fff;
279 return (int)(parm & 0x7fff);
281 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
284 * snd_hda_get_connections - get connection list
285 * @codec: the HDA codec
287 * @conn_list: connection list array
288 * @max_conns: max. number of connections to store
290 * Parses the connection list of the given widget and stores the list
293 * Returns the number of connections, or a negative error code.
295 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
296 hda_nid_t *conn_list, int max_conns)
299 int i, conn_len, conns;
300 unsigned int shift, num_elems, mask;
303 if (snd_BUG_ON(!conn_list || max_conns <= 0))
306 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
307 if (parm & AC_CLIST_LONG) {
316 conn_len = parm & AC_CLIST_LENGTH;
317 mask = (1 << (shift-1)) - 1;
320 return 0; /* no connection */
323 /* single connection */
324 parm = snd_hda_codec_read(codec, nid, 0,
325 AC_VERB_GET_CONNECT_LIST, 0);
326 conn_list[0] = parm & mask;
330 /* multi connection */
333 for (i = 0; i < conn_len; i++) {
337 if (i % num_elems == 0)
338 parm = snd_hda_codec_read(codec, nid, 0,
339 AC_VERB_GET_CONNECT_LIST, i);
340 range_val = !!(parm & (1 << (shift-1))); /* ranges */
344 /* ranges between the previous and this one */
345 if (!prev_nid || prev_nid >= val) {
346 snd_printk(KERN_WARNING "hda_codec: "
347 "invalid dep_range_val %x:%x\n",
351 for (n = prev_nid + 1; n <= val; n++) {
352 if (conns >= max_conns) {
354 "Too many connections\n");
357 conn_list[conns++] = n;
360 if (conns >= max_conns) {
361 snd_printk(KERN_ERR "Too many connections\n");
364 conn_list[conns++] = val;
370 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
374 * snd_hda_queue_unsol_event - add an unsolicited event to queue
376 * @res: unsolicited event (lower 32bit of RIRB entry)
377 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
379 * Adds the given event to the queue. The events are processed in
380 * the workqueue asynchronously. Call this function in the interrupt
381 * hanlder when RIRB receives an unsolicited event.
383 * Returns 0 if successful, or a negative error code.
385 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
387 struct hda_bus_unsolicited *unsol;
394 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
398 unsol->queue[wp] = res;
399 unsol->queue[wp + 1] = res_ex;
401 queue_work(bus->workq, &unsol->work);
405 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
408 * process queued unsolicited events
410 static void process_unsol_events(struct work_struct *work)
412 struct hda_bus_unsolicited *unsol =
413 container_of(work, struct hda_bus_unsolicited, work);
414 struct hda_bus *bus = unsol->bus;
415 struct hda_codec *codec;
416 unsigned int rp, caddr, res;
418 while (unsol->rp != unsol->wp) {
419 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
422 res = unsol->queue[rp];
423 caddr = unsol->queue[rp + 1];
424 if (!(caddr & (1 << 4))) /* no unsolicited event? */
426 codec = bus->caddr_tbl[caddr & 0x0f];
427 if (codec && codec->patch_ops.unsol_event)
428 codec->patch_ops.unsol_event(codec, res);
433 * initialize unsolicited queue
435 static int init_unsol_queue(struct hda_bus *bus)
437 struct hda_bus_unsolicited *unsol;
439 if (bus->unsol) /* already initialized */
442 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
444 snd_printk(KERN_ERR "hda_codec: "
445 "can't allocate unsolicited queue\n");
448 INIT_WORK(&unsol->work, process_unsol_events);
457 static void snd_hda_codec_free(struct hda_codec *codec);
459 static int snd_hda_bus_free(struct hda_bus *bus)
461 struct hda_codec *codec, *n;
466 flush_workqueue(bus->workq);
469 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
470 snd_hda_codec_free(codec);
472 if (bus->ops.private_free)
473 bus->ops.private_free(bus);
475 destroy_workqueue(bus->workq);
480 static int snd_hda_bus_dev_free(struct snd_device *device)
482 struct hda_bus *bus = device->device_data;
484 return snd_hda_bus_free(bus);
487 #ifdef CONFIG_SND_HDA_HWDEP
488 static int snd_hda_bus_dev_register(struct snd_device *device)
490 struct hda_bus *bus = device->device_data;
491 struct hda_codec *codec;
492 list_for_each_entry(codec, &bus->codec_list, list) {
493 snd_hda_hwdep_add_sysfs(codec);
498 #define snd_hda_bus_dev_register NULL
502 * snd_hda_bus_new - create a HDA bus
503 * @card: the card entry
504 * @temp: the template for hda_bus information
505 * @busp: the pointer to store the created bus instance
507 * Returns 0 if successful, or a negative error code.
509 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
510 const struct hda_bus_template *temp,
511 struct hda_bus **busp)
515 static struct snd_device_ops dev_ops = {
516 .dev_register = snd_hda_bus_dev_register,
517 .dev_free = snd_hda_bus_dev_free,
520 if (snd_BUG_ON(!temp))
522 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
528 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
530 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
535 bus->private_data = temp->private_data;
536 bus->pci = temp->pci;
537 bus->modelname = temp->modelname;
538 bus->power_save = temp->power_save;
539 bus->ops = temp->ops;
541 mutex_init(&bus->cmd_mutex);
542 INIT_LIST_HEAD(&bus->codec_list);
544 snprintf(bus->workq_name, sizeof(bus->workq_name),
545 "hd-audio%d", card->number);
546 bus->workq = create_singlethread_workqueue(bus->workq_name);
548 snd_printk(KERN_ERR "cannot create workqueue %s\n",
554 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
556 snd_hda_bus_free(bus);
563 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
565 #ifdef CONFIG_SND_HDA_GENERIC
566 #define is_generic_config(codec) \
567 (codec->modelname && !strcmp(codec->modelname, "generic"))
569 #define is_generic_config(codec) 0
573 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
575 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
579 * find a matching codec preset
581 static const struct hda_codec_preset *
582 find_codec_preset(struct hda_codec *codec)
584 struct hda_codec_preset_list *tbl;
585 const struct hda_codec_preset *preset;
586 int mod_requested = 0;
588 if (is_generic_config(codec))
589 return NULL; /* use the generic parser */
592 mutex_lock(&preset_mutex);
593 list_for_each_entry(tbl, &hda_preset_tables, list) {
594 if (!try_module_get(tbl->owner)) {
595 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
598 for (preset = tbl->preset; preset->id; preset++) {
599 u32 mask = preset->mask;
600 if (preset->afg && preset->afg != codec->afg)
602 if (preset->mfg && preset->mfg != codec->mfg)
606 if (preset->id == (codec->vendor_id & mask) &&
608 preset->rev == codec->revision_id)) {
609 mutex_unlock(&preset_mutex);
610 codec->owner = tbl->owner;
614 module_put(tbl->owner);
616 mutex_unlock(&preset_mutex);
618 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
621 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
624 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
625 (codec->vendor_id >> 16) & 0xffff);
626 request_module(name);
634 * get_codec_name - store the codec name
636 static int get_codec_name(struct hda_codec *codec)
638 const struct hda_vendor_id *c;
639 const char *vendor = NULL;
640 u16 vendor_id = codec->vendor_id >> 16;
643 if (codec->vendor_name)
646 for (c = hda_vendor_ids; c->id; c++) {
647 if (c->id == vendor_id) {
653 sprintf(tmp, "Generic %04x", vendor_id);
656 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
657 if (!codec->vendor_name)
661 if (codec->chip_name)
664 if (codec->preset && codec->preset->name)
665 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
667 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
668 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
670 if (!codec->chip_name)
676 * look for an AFG and MFG nodes
678 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
680 int i, total_nodes, function_id;
683 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
684 for (i = 0; i < total_nodes; i++, nid++) {
685 function_id = snd_hda_param_read(codec, nid,
686 AC_PAR_FUNCTION_TYPE) & 0xff;
687 switch (function_id) {
688 case AC_GRP_AUDIO_FUNCTION:
690 codec->function_id = function_id;
692 case AC_GRP_MODEM_FUNCTION:
694 codec->function_id = function_id;
703 * read widget caps for each widget and store in cache
705 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
710 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
712 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
715 nid = codec->start_nid;
716 for (i = 0; i < codec->num_nodes; i++, nid++)
717 codec->wcaps[i] = snd_hda_param_read(codec, nid,
718 AC_PAR_AUDIO_WIDGET_CAP);
722 /* read all pin default configurations and save codec->init_pins */
723 static int read_pin_defaults(struct hda_codec *codec)
726 hda_nid_t nid = codec->start_nid;
728 for (i = 0; i < codec->num_nodes; i++, nid++) {
729 struct hda_pincfg *pin;
730 unsigned int wcaps = get_wcaps(codec, nid);
731 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
733 if (wid_type != AC_WID_PIN)
735 pin = snd_array_new(&codec->init_pins);
739 pin->cfg = snd_hda_codec_read(codec, nid, 0,
740 AC_VERB_GET_CONFIG_DEFAULT, 0);
745 /* look up the given pin config list and return the item matching with NID */
746 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
747 struct snd_array *array,
751 for (i = 0; i < array->used; i++) {
752 struct hda_pincfg *pin = snd_array_elem(array, i);
759 /* write a config value for the given NID */
760 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
764 for (i = 0; i < 4; i++) {
765 snd_hda_codec_write(codec, nid, 0,
766 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
772 /* set the current pin config value for the given NID.
773 * the value is cached, and read via snd_hda_codec_get_pincfg()
775 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
776 hda_nid_t nid, unsigned int cfg)
778 struct hda_pincfg *pin;
781 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
782 pin = look_up_pincfg(codec, list, nid);
784 pin = snd_array_new(list);
791 /* change only when needed; e.g. if the pincfg is already present
792 * in user_pins[], don't write it
794 cfg = snd_hda_codec_get_pincfg(codec, nid);
796 set_pincfg(codec, nid, cfg);
800 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
801 hda_nid_t nid, unsigned int cfg)
803 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
805 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
807 /* get the current pin config value of the given pin NID */
808 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
810 struct hda_pincfg *pin;
812 #ifdef CONFIG_SND_HDA_HWDEP
813 pin = look_up_pincfg(codec, &codec->user_pins, nid);
817 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
820 pin = look_up_pincfg(codec, &codec->init_pins, nid);
825 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
827 /* restore all current pin configs */
828 static void restore_pincfgs(struct hda_codec *codec)
831 for (i = 0; i < codec->init_pins.used; i++) {
832 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
833 set_pincfg(codec, pin->nid,
834 snd_hda_codec_get_pincfg(codec, pin->nid));
838 static void init_hda_cache(struct hda_cache_rec *cache,
839 unsigned int record_size);
840 static void free_hda_cache(struct hda_cache_rec *cache);
842 /* restore the initial pin cfgs and release all pincfg lists */
843 static void restore_init_pincfgs(struct hda_codec *codec)
845 /* first free driver_pins and user_pins, then call restore_pincfg
846 * so that only the values in init_pins are restored
848 snd_array_free(&codec->driver_pins);
849 #ifdef CONFIG_SND_HDA_HWDEP
850 snd_array_free(&codec->user_pins);
852 restore_pincfgs(codec);
853 snd_array_free(&codec->init_pins);
859 static void snd_hda_codec_free(struct hda_codec *codec)
863 restore_init_pincfgs(codec);
864 #ifdef CONFIG_SND_HDA_POWER_SAVE
865 cancel_delayed_work(&codec->power_work);
866 flush_workqueue(codec->bus->workq);
868 list_del(&codec->list);
869 snd_array_free(&codec->mixers);
870 codec->bus->caddr_tbl[codec->addr] = NULL;
871 if (codec->patch_ops.free)
872 codec->patch_ops.free(codec);
873 module_put(codec->owner);
874 free_hda_cache(&codec->amp_cache);
875 free_hda_cache(&codec->cmd_cache);
876 kfree(codec->vendor_name);
877 kfree(codec->chip_name);
878 kfree(codec->modelname);
883 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
884 unsigned int power_state);
887 * snd_hda_codec_new - create a HDA codec
888 * @bus: the bus to assign
889 * @codec_addr: the codec address
890 * @codecp: the pointer to store the generated codec
892 * Returns 0 if successful, or a negative error code.
894 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
895 int do_init, struct hda_codec **codecp)
897 struct hda_codec *codec;
901 if (snd_BUG_ON(!bus))
903 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
906 if (bus->caddr_tbl[codec_addr]) {
907 snd_printk(KERN_ERR "hda_codec: "
908 "address 0x%x is already occupied\n", codec_addr);
912 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
914 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
919 codec->addr = codec_addr;
920 mutex_init(&codec->spdif_mutex);
921 mutex_init(&codec->control_mutex);
922 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
923 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
924 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
925 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
926 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
927 if (codec->bus->modelname) {
928 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
929 if (!codec->modelname) {
930 snd_hda_codec_free(codec);
935 #ifdef CONFIG_SND_HDA_POWER_SAVE
936 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
937 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
938 * the caller has to power down appropriatley after initialization
941 hda_keep_power_on(codec);
944 list_add_tail(&codec->list, &bus->codec_list);
945 bus->caddr_tbl[codec_addr] = codec;
947 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
949 if (codec->vendor_id == -1)
950 /* read again, hopefully the access method was corrected
951 * in the last read...
953 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
955 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
956 AC_PAR_SUBSYSTEM_ID);
957 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
960 setup_fg_nodes(codec);
961 if (!codec->afg && !codec->mfg) {
962 snd_printdd("hda_codec: no AFG or MFG node found\n");
967 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
969 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
972 err = read_pin_defaults(codec);
976 if (!codec->subsystem_id) {
977 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
978 codec->subsystem_id =
979 snd_hda_codec_read(codec, nid, 0,
980 AC_VERB_GET_SUBSYSTEM_ID, 0);
983 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
985 /* power-up all before initialization */
986 hda_set_power_state(codec,
987 codec->afg ? codec->afg : codec->mfg,
991 err = snd_hda_codec_configure(codec);
995 snd_hda_codec_proc_new(codec);
997 snd_hda_create_hwdep(codec);
999 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1000 codec->subsystem_id, codec->revision_id);
1001 snd_component_add(codec->bus->card, component);
1008 snd_hda_codec_free(codec);
1011 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1013 int snd_hda_codec_configure(struct hda_codec *codec)
1017 codec->preset = find_codec_preset(codec);
1018 if (!codec->vendor_name || !codec->chip_name) {
1019 err = get_codec_name(codec);
1023 /* audio codec should override the mixer name */
1024 if (codec->afg || !*codec->bus->card->mixername)
1025 snprintf(codec->bus->card->mixername,
1026 sizeof(codec->bus->card->mixername),
1027 "%s %s", codec->vendor_name, codec->chip_name);
1029 if (is_generic_config(codec)) {
1030 err = snd_hda_parse_generic_codec(codec);
1033 if (codec->preset && codec->preset->patch) {
1034 err = codec->preset->patch(codec);
1038 /* call the default parser */
1039 err = snd_hda_parse_generic_codec(codec);
1041 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1044 if (!err && codec->patch_ops.unsol_event)
1045 err = init_unsol_queue(codec->bus);
1050 * snd_hda_codec_setup_stream - set up the codec for streaming
1051 * @codec: the CODEC to set up
1052 * @nid: the NID to set up
1053 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1054 * @channel_id: channel id to pass, zero based.
1055 * @format: stream format.
1057 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1059 int channel_id, int format)
1064 snd_printdd("hda_codec_setup_stream: "
1065 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1066 nid, stream_tag, channel_id, format);
1067 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1068 (stream_tag << 4) | channel_id);
1070 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1072 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1074 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1079 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1080 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1081 #if 0 /* keep the format */
1083 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1086 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
1089 * amp access functions
1092 /* FIXME: more better hash key? */
1093 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1094 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1095 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1096 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1097 #define INFO_AMP_CAPS (1<<0)
1098 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1100 /* initialize the hash table */
1101 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1102 unsigned int record_size)
1104 memset(cache, 0, sizeof(*cache));
1105 memset(cache->hash, 0xff, sizeof(cache->hash));
1106 snd_array_init(&cache->buf, record_size, 64);
1109 static void free_hda_cache(struct hda_cache_rec *cache)
1111 snd_array_free(&cache->buf);
1114 /* query the hash. allocate an entry if not found. */
1115 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1118 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1119 u16 cur = cache->hash[idx];
1120 struct hda_cache_head *info;
1122 while (cur != 0xffff) {
1123 info = snd_array_elem(&cache->buf, cur);
1124 if (info->key == key)
1129 /* add a new hash entry */
1130 info = snd_array_new(&cache->buf);
1133 cur = snd_array_index(&cache->buf, info);
1136 info->next = cache->hash[idx];
1137 cache->hash[idx] = cur;
1142 /* query and allocate an amp hash entry */
1143 static inline struct hda_amp_info *
1144 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1146 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1150 * query AMP capabilities for the given widget and direction
1152 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1154 struct hda_amp_info *info;
1156 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1159 if (!(info->head.val & INFO_AMP_CAPS)) {
1160 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1162 info->amp_caps = snd_hda_param_read(codec, nid,
1163 direction == HDA_OUTPUT ?
1164 AC_PAR_AMP_OUT_CAP :
1167 info->head.val |= INFO_AMP_CAPS;
1169 return info->amp_caps;
1171 EXPORT_SYMBOL_HDA(query_amp_caps);
1173 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1176 struct hda_amp_info *info;
1178 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1181 info->amp_caps = caps;
1182 info->head.val |= INFO_AMP_CAPS;
1185 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1188 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1189 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1191 struct hda_amp_info *info;
1193 info = get_alloc_amp_hash(codec, key);
1196 if (!info->head.val) {
1197 info->head.val |= INFO_AMP_CAPS;
1198 info->amp_caps = func(codec, nid);
1200 return info->amp_caps;
1203 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1205 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1208 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1210 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1213 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1216 * read the current volume to info
1217 * if the cache exists, read the cache value.
1219 static unsigned int get_vol_mute(struct hda_codec *codec,
1220 struct hda_amp_info *info, hda_nid_t nid,
1221 int ch, int direction, int index)
1225 if (info->head.val & INFO_AMP_VOL(ch))
1226 return info->vol[ch];
1228 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1229 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1231 val = snd_hda_codec_read(codec, nid, 0,
1232 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1233 info->vol[ch] = val & 0xff;
1234 info->head.val |= INFO_AMP_VOL(ch);
1235 return info->vol[ch];
1239 * write the current volume in info to the h/w and update the cache
1241 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1242 hda_nid_t nid, int ch, int direction, int index,
1247 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1248 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1249 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1251 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1252 info->vol[ch] = val;
1256 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1258 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1259 int direction, int index)
1261 struct hda_amp_info *info;
1262 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1265 return get_vol_mute(codec, info, nid, ch, direction, index);
1267 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1270 * update the AMP value, mask = bit mask to set, val = the value
1272 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1273 int direction, int idx, int mask, int val)
1275 struct hda_amp_info *info;
1277 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1281 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1282 if (info->vol[ch] == val)
1284 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1287 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1290 * update the AMP stereo with the same mask and value
1292 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1293 int direction, int idx, int mask, int val)
1296 for (ch = 0; ch < 2; ch++)
1297 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1301 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1303 #ifdef SND_HDA_NEEDS_RESUME
1304 /* resume the all amp commands from the cache */
1305 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1307 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1310 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1311 u32 key = buffer->head.key;
1313 unsigned int idx, dir, ch;
1317 idx = (key >> 16) & 0xff;
1318 dir = (key >> 24) & 0xff;
1319 for (ch = 0; ch < 2; ch++) {
1320 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1322 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1327 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1328 #endif /* SND_HDA_NEEDS_RESUME */
1331 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1332 struct snd_ctl_elem_info *uinfo)
1334 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1335 u16 nid = get_amp_nid(kcontrol);
1336 u8 chs = get_amp_channels(kcontrol);
1337 int dir = get_amp_direction(kcontrol);
1338 unsigned int ofs = get_amp_offset(kcontrol);
1341 caps = query_amp_caps(codec, nid, dir);
1343 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1345 printk(KERN_WARNING "hda_codec: "
1346 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1352 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1353 uinfo->count = chs == 3 ? 2 : 1;
1354 uinfo->value.integer.min = 0;
1355 uinfo->value.integer.max = caps;
1358 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1361 static inline unsigned int
1362 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1363 int ch, int dir, int idx, unsigned int ofs)
1366 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1367 val &= HDA_AMP_VOLMASK;
1376 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1377 int ch, int dir, int idx, unsigned int ofs,
1382 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1383 HDA_AMP_VOLMASK, val);
1386 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1387 struct snd_ctl_elem_value *ucontrol)
1389 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1390 hda_nid_t nid = get_amp_nid(kcontrol);
1391 int chs = get_amp_channels(kcontrol);
1392 int dir = get_amp_direction(kcontrol);
1393 int idx = get_amp_index(kcontrol);
1394 unsigned int ofs = get_amp_offset(kcontrol);
1395 long *valp = ucontrol->value.integer.value;
1398 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1400 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1403 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1405 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1406 struct snd_ctl_elem_value *ucontrol)
1408 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1409 hda_nid_t nid = get_amp_nid(kcontrol);
1410 int chs = get_amp_channels(kcontrol);
1411 int dir = get_amp_direction(kcontrol);
1412 int idx = get_amp_index(kcontrol);
1413 unsigned int ofs = get_amp_offset(kcontrol);
1414 long *valp = ucontrol->value.integer.value;
1417 snd_hda_power_up(codec);
1419 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1423 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1424 snd_hda_power_down(codec);
1427 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1429 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1430 unsigned int size, unsigned int __user *_tlv)
1432 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1433 hda_nid_t nid = get_amp_nid(kcontrol);
1434 int dir = get_amp_direction(kcontrol);
1435 unsigned int ofs = get_amp_offset(kcontrol);
1436 u32 caps, val1, val2;
1438 if (size < 4 * sizeof(unsigned int))
1440 caps = query_amp_caps(codec, nid, dir);
1441 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1442 val2 = (val2 + 1) * 25;
1443 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1445 val1 = ((int)val1) * ((int)val2);
1446 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1448 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1450 if (put_user(val1, _tlv + 2))
1452 if (put_user(val2, _tlv + 3))
1456 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1459 * set (static) TLV for virtual master volume; recalculated as max 0dB
1461 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1467 caps = query_amp_caps(codec, nid, dir);
1468 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1469 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1470 step = (step + 1) * 25;
1471 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1472 tlv[1] = 2 * sizeof(unsigned int);
1473 tlv[2] = -nums * step;
1476 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1478 /* find a mixer control element with the given name */
1479 static struct snd_kcontrol *
1480 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1481 const char *name, int idx)
1483 struct snd_ctl_elem_id id;
1484 memset(&id, 0, sizeof(id));
1485 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1487 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1489 strcpy(id.name, name);
1490 return snd_ctl_find_id(codec->bus->card, &id);
1493 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1496 return _snd_hda_find_mixer_ctl(codec, name, 0);
1498 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1500 /* Add a control element and assign to the codec */
1501 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1504 struct snd_kcontrol **knewp;
1506 err = snd_ctl_add(codec->bus->card, kctl);
1509 knewp = snd_array_new(&codec->mixers);
1515 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1517 /* Clear all controls assigned to the given codec */
1518 void snd_hda_ctls_clear(struct hda_codec *codec)
1521 struct snd_kcontrol **kctls = codec->mixers.list;
1522 for (i = 0; i < codec->mixers.used; i++)
1523 snd_ctl_remove(codec->bus->card, kctls[i]);
1524 snd_array_free(&codec->mixers);
1527 /* pseudo device locking
1528 * toggle card->shutdown to allow/disallow the device access (as a hack)
1530 static int hda_lock_devices(struct snd_card *card)
1532 spin_lock(&card->files_lock);
1533 if (card->shutdown) {
1534 spin_unlock(&card->files_lock);
1538 spin_unlock(&card->files_lock);
1542 static void hda_unlock_devices(struct snd_card *card)
1544 spin_lock(&card->files_lock);
1546 spin_unlock(&card->files_lock);
1549 int snd_hda_codec_reset(struct hda_codec *codec)
1551 struct snd_card *card = codec->bus->card;
1554 if (hda_lock_devices(card) < 0)
1556 /* check whether the codec isn't used by any mixer or PCM streams */
1557 if (!list_empty(&card->ctl_files)) {
1558 hda_unlock_devices(card);
1561 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1562 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1565 if (cpcm->pcm->streams[0].substream_opened ||
1566 cpcm->pcm->streams[1].substream_opened) {
1567 hda_unlock_devices(card);
1572 /* OK, let it free */
1574 #ifdef CONFIG_SND_HDA_POWER_SAVE
1575 cancel_delayed_work(&codec->power_work);
1576 flush_workqueue(codec->bus->workq);
1578 snd_hda_ctls_clear(codec);
1580 for (i = 0; i < codec->num_pcms; i++) {
1581 if (codec->pcm_info[i].pcm) {
1582 snd_device_free(card, codec->pcm_info[i].pcm);
1583 clear_bit(codec->pcm_info[i].device,
1584 codec->bus->pcm_dev_bits);
1587 if (codec->patch_ops.free)
1588 codec->patch_ops.free(codec);
1589 codec->proc_widget_hook = NULL;
1591 free_hda_cache(&codec->amp_cache);
1592 free_hda_cache(&codec->cmd_cache);
1593 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1594 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1595 /* free only driver_pins so that init_pins + user_pins are restored */
1596 snd_array_free(&codec->driver_pins);
1597 restore_pincfgs(codec);
1598 codec->num_pcms = 0;
1599 codec->pcm_info = NULL;
1600 codec->preset = NULL;
1601 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1602 codec->slave_dig_outs = NULL;
1603 codec->spdif_status_reset = 0;
1604 module_put(codec->owner);
1605 codec->owner = NULL;
1607 /* allow device access again */
1608 hda_unlock_devices(card);
1612 /* create a virtual master control and add slaves */
1613 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1614 unsigned int *tlv, const char **slaves)
1616 struct snd_kcontrol *kctl;
1620 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1623 snd_printdd("No slave found for %s\n", name);
1626 kctl = snd_ctl_make_virtual_master(name, tlv);
1629 err = snd_hda_ctl_add(codec, kctl);
1633 for (s = slaves; *s; s++) {
1634 struct snd_kcontrol *sctl;
1637 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1640 snd_printdd("Cannot find slave %s, "
1644 err = snd_ctl_add_slave(kctl, sctl);
1652 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1655 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1656 struct snd_ctl_elem_info *uinfo)
1658 int chs = get_amp_channels(kcontrol);
1660 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1661 uinfo->count = chs == 3 ? 2 : 1;
1662 uinfo->value.integer.min = 0;
1663 uinfo->value.integer.max = 1;
1666 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1668 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1669 struct snd_ctl_elem_value *ucontrol)
1671 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1672 hda_nid_t nid = get_amp_nid(kcontrol);
1673 int chs = get_amp_channels(kcontrol);
1674 int dir = get_amp_direction(kcontrol);
1675 int idx = get_amp_index(kcontrol);
1676 long *valp = ucontrol->value.integer.value;
1679 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1680 HDA_AMP_MUTE) ? 0 : 1;
1682 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1683 HDA_AMP_MUTE) ? 0 : 1;
1686 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1688 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1689 struct snd_ctl_elem_value *ucontrol)
1691 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1692 hda_nid_t nid = get_amp_nid(kcontrol);
1693 int chs = get_amp_channels(kcontrol);
1694 int dir = get_amp_direction(kcontrol);
1695 int idx = get_amp_index(kcontrol);
1696 long *valp = ucontrol->value.integer.value;
1699 snd_hda_power_up(codec);
1701 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1703 *valp ? 0 : HDA_AMP_MUTE);
1707 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1709 *valp ? 0 : HDA_AMP_MUTE);
1710 #ifdef CONFIG_SND_HDA_POWER_SAVE
1711 if (codec->patch_ops.check_power_status)
1712 codec->patch_ops.check_power_status(codec, nid);
1714 snd_hda_power_down(codec);
1717 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1720 * bound volume controls
1722 * bind multiple volumes (# indices, from 0)
1725 #define AMP_VAL_IDX_SHIFT 19
1726 #define AMP_VAL_IDX_MASK (0x0f<<19)
1728 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1729 struct snd_ctl_elem_value *ucontrol)
1731 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1735 mutex_lock(&codec->control_mutex);
1736 pval = kcontrol->private_value;
1737 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1738 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1739 kcontrol->private_value = pval;
1740 mutex_unlock(&codec->control_mutex);
1743 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1745 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1746 struct snd_ctl_elem_value *ucontrol)
1748 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1750 int i, indices, err = 0, change = 0;
1752 mutex_lock(&codec->control_mutex);
1753 pval = kcontrol->private_value;
1754 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1755 for (i = 0; i < indices; i++) {
1756 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1757 (i << AMP_VAL_IDX_SHIFT);
1758 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1763 kcontrol->private_value = pval;
1764 mutex_unlock(&codec->control_mutex);
1765 return err < 0 ? err : change;
1767 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1770 * generic bound volume/swtich controls
1772 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1773 struct snd_ctl_elem_info *uinfo)
1775 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1776 struct hda_bind_ctls *c;
1779 mutex_lock(&codec->control_mutex);
1780 c = (struct hda_bind_ctls *)kcontrol->private_value;
1781 kcontrol->private_value = *c->values;
1782 err = c->ops->info(kcontrol, uinfo);
1783 kcontrol->private_value = (long)c;
1784 mutex_unlock(&codec->control_mutex);
1787 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1789 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1790 struct snd_ctl_elem_value *ucontrol)
1792 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1793 struct hda_bind_ctls *c;
1796 mutex_lock(&codec->control_mutex);
1797 c = (struct hda_bind_ctls *)kcontrol->private_value;
1798 kcontrol->private_value = *c->values;
1799 err = c->ops->get(kcontrol, ucontrol);
1800 kcontrol->private_value = (long)c;
1801 mutex_unlock(&codec->control_mutex);
1804 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1806 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1807 struct snd_ctl_elem_value *ucontrol)
1809 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1810 struct hda_bind_ctls *c;
1811 unsigned long *vals;
1812 int err = 0, change = 0;
1814 mutex_lock(&codec->control_mutex);
1815 c = (struct hda_bind_ctls *)kcontrol->private_value;
1816 for (vals = c->values; *vals; vals++) {
1817 kcontrol->private_value = *vals;
1818 err = c->ops->put(kcontrol, ucontrol);
1823 kcontrol->private_value = (long)c;
1824 mutex_unlock(&codec->control_mutex);
1825 return err < 0 ? err : change;
1827 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1829 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1830 unsigned int size, unsigned int __user *tlv)
1832 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1833 struct hda_bind_ctls *c;
1836 mutex_lock(&codec->control_mutex);
1837 c = (struct hda_bind_ctls *)kcontrol->private_value;
1838 kcontrol->private_value = *c->values;
1839 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1840 kcontrol->private_value = (long)c;
1841 mutex_unlock(&codec->control_mutex);
1844 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1846 struct hda_ctl_ops snd_hda_bind_vol = {
1847 .info = snd_hda_mixer_amp_volume_info,
1848 .get = snd_hda_mixer_amp_volume_get,
1849 .put = snd_hda_mixer_amp_volume_put,
1850 .tlv = snd_hda_mixer_amp_tlv
1852 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1854 struct hda_ctl_ops snd_hda_bind_sw = {
1855 .info = snd_hda_mixer_amp_switch_info,
1856 .get = snd_hda_mixer_amp_switch_get,
1857 .put = snd_hda_mixer_amp_switch_put,
1858 .tlv = snd_hda_mixer_amp_tlv
1860 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1863 * SPDIF out controls
1866 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1867 struct snd_ctl_elem_info *uinfo)
1869 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1874 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1875 struct snd_ctl_elem_value *ucontrol)
1877 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1878 IEC958_AES0_NONAUDIO |
1879 IEC958_AES0_CON_EMPHASIS_5015 |
1880 IEC958_AES0_CON_NOT_COPYRIGHT;
1881 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1882 IEC958_AES1_CON_ORIGINAL;
1886 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1887 struct snd_ctl_elem_value *ucontrol)
1889 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1890 IEC958_AES0_NONAUDIO |
1891 IEC958_AES0_PRO_EMPHASIS_5015;
1895 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1896 struct snd_ctl_elem_value *ucontrol)
1898 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1900 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1901 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1902 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1903 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1908 /* convert from SPDIF status bits to HDA SPDIF bits
1909 * bit 0 (DigEn) is always set zero (to be filled later)
1911 static unsigned short convert_from_spdif_status(unsigned int sbits)
1913 unsigned short val = 0;
1915 if (sbits & IEC958_AES0_PROFESSIONAL)
1916 val |= AC_DIG1_PROFESSIONAL;
1917 if (sbits & IEC958_AES0_NONAUDIO)
1918 val |= AC_DIG1_NONAUDIO;
1919 if (sbits & IEC958_AES0_PROFESSIONAL) {
1920 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1921 IEC958_AES0_PRO_EMPHASIS_5015)
1922 val |= AC_DIG1_EMPHASIS;
1924 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1925 IEC958_AES0_CON_EMPHASIS_5015)
1926 val |= AC_DIG1_EMPHASIS;
1927 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1928 val |= AC_DIG1_COPYRIGHT;
1929 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1930 val |= AC_DIG1_LEVEL;
1931 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1936 /* convert to SPDIF status bits from HDA SPDIF bits
1938 static unsigned int convert_to_spdif_status(unsigned short val)
1940 unsigned int sbits = 0;
1942 if (val & AC_DIG1_NONAUDIO)
1943 sbits |= IEC958_AES0_NONAUDIO;
1944 if (val & AC_DIG1_PROFESSIONAL)
1945 sbits |= IEC958_AES0_PROFESSIONAL;
1946 if (sbits & IEC958_AES0_PROFESSIONAL) {
1947 if (sbits & AC_DIG1_EMPHASIS)
1948 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1950 if (val & AC_DIG1_EMPHASIS)
1951 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1952 if (!(val & AC_DIG1_COPYRIGHT))
1953 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1954 if (val & AC_DIG1_LEVEL)
1955 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1956 sbits |= val & (0x7f << 8);
1961 /* set digital convert verbs both for the given NID and its slaves */
1962 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1967 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1968 d = codec->slave_dig_outs;
1972 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1975 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1979 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1981 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1984 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1985 struct snd_ctl_elem_value *ucontrol)
1987 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1988 hda_nid_t nid = kcontrol->private_value;
1992 mutex_lock(&codec->spdif_mutex);
1993 codec->spdif_status = ucontrol->value.iec958.status[0] |
1994 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1995 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1996 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1997 val = convert_from_spdif_status(codec->spdif_status);
1998 val |= codec->spdif_ctls & 1;
1999 change = codec->spdif_ctls != val;
2000 codec->spdif_ctls = val;
2003 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2005 mutex_unlock(&codec->spdif_mutex);
2009 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2011 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2012 struct snd_ctl_elem_value *ucontrol)
2014 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2016 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
2020 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2021 struct snd_ctl_elem_value *ucontrol)
2023 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2024 hda_nid_t nid = kcontrol->private_value;
2028 mutex_lock(&codec->spdif_mutex);
2029 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2030 if (ucontrol->value.integer.value[0])
2031 val |= AC_DIG1_ENABLE;
2032 change = codec->spdif_ctls != val;
2034 codec->spdif_ctls = val;
2035 set_dig_out_convert(codec, nid, val & 0xff, -1);
2036 /* unmute amp switch (if any) */
2037 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2038 (val & AC_DIG1_ENABLE))
2039 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2042 mutex_unlock(&codec->spdif_mutex);
2046 static struct snd_kcontrol_new dig_mixes[] = {
2048 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2049 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2050 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2051 .info = snd_hda_spdif_mask_info,
2052 .get = snd_hda_spdif_cmask_get,
2055 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2056 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2057 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2058 .info = snd_hda_spdif_mask_info,
2059 .get = snd_hda_spdif_pmask_get,
2062 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2063 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2064 .info = snd_hda_spdif_mask_info,
2065 .get = snd_hda_spdif_default_get,
2066 .put = snd_hda_spdif_default_put,
2069 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2070 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2071 .info = snd_hda_spdif_out_switch_info,
2072 .get = snd_hda_spdif_out_switch_get,
2073 .put = snd_hda_spdif_out_switch_put,
2078 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2081 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2082 * @codec: the HDA codec
2083 * @nid: audio out widget NID
2085 * Creates controls related with the SPDIF output.
2086 * Called from each patch supporting the SPDIF out.
2088 * Returns 0 if successful, or a negative error code.
2090 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2093 struct snd_kcontrol *kctl;
2094 struct snd_kcontrol_new *dig_mix;
2097 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2098 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2102 if (idx >= SPDIF_MAX_IDX) {
2103 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2106 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2107 kctl = snd_ctl_new1(dig_mix, codec);
2110 kctl->id.index = idx;
2111 kctl->private_value = nid;
2112 err = snd_hda_ctl_add(codec, kctl);
2117 snd_hda_codec_read(codec, nid, 0,
2118 AC_VERB_GET_DIGI_CONVERT_1, 0);
2119 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2122 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2125 * SPDIF sharing with analog output
2127 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2128 struct snd_ctl_elem_value *ucontrol)
2130 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2131 ucontrol->value.integer.value[0] = mout->share_spdif;
2135 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2136 struct snd_ctl_elem_value *ucontrol)
2138 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2139 mout->share_spdif = !!ucontrol->value.integer.value[0];
2143 static struct snd_kcontrol_new spdif_share_sw = {
2144 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2145 .name = "IEC958 Default PCM Playback Switch",
2146 .info = snd_ctl_boolean_mono_info,
2147 .get = spdif_share_sw_get,
2148 .put = spdif_share_sw_put,
2151 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2152 struct hda_multi_out *mout)
2154 if (!mout->dig_out_nid)
2156 /* ATTENTION: here mout is passed as private_data, instead of codec */
2157 return snd_hda_ctl_add(codec,
2158 snd_ctl_new1(&spdif_share_sw, mout));
2160 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2166 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2168 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2169 struct snd_ctl_elem_value *ucontrol)
2171 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2173 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2177 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2178 struct snd_ctl_elem_value *ucontrol)
2180 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2181 hda_nid_t nid = kcontrol->private_value;
2182 unsigned int val = !!ucontrol->value.integer.value[0];
2185 mutex_lock(&codec->spdif_mutex);
2186 change = codec->spdif_in_enable != val;
2188 codec->spdif_in_enable = val;
2189 snd_hda_codec_write_cache(codec, nid, 0,
2190 AC_VERB_SET_DIGI_CONVERT_1, val);
2192 mutex_unlock(&codec->spdif_mutex);
2196 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2197 struct snd_ctl_elem_value *ucontrol)
2199 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2200 hda_nid_t nid = kcontrol->private_value;
2204 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2205 sbits = convert_to_spdif_status(val);
2206 ucontrol->value.iec958.status[0] = sbits;
2207 ucontrol->value.iec958.status[1] = sbits >> 8;
2208 ucontrol->value.iec958.status[2] = sbits >> 16;
2209 ucontrol->value.iec958.status[3] = sbits >> 24;
2213 static struct snd_kcontrol_new dig_in_ctls[] = {
2215 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2216 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2217 .info = snd_hda_spdif_in_switch_info,
2218 .get = snd_hda_spdif_in_switch_get,
2219 .put = snd_hda_spdif_in_switch_put,
2222 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2223 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2224 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2225 .info = snd_hda_spdif_mask_info,
2226 .get = snd_hda_spdif_in_status_get,
2232 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2233 * @codec: the HDA codec
2234 * @nid: audio in widget NID
2236 * Creates controls related with the SPDIF input.
2237 * Called from each patch supporting the SPDIF in.
2239 * Returns 0 if successful, or a negative error code.
2241 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2244 struct snd_kcontrol *kctl;
2245 struct snd_kcontrol_new *dig_mix;
2248 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2249 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2253 if (idx >= SPDIF_MAX_IDX) {
2254 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2257 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2258 kctl = snd_ctl_new1(dig_mix, codec);
2261 kctl->private_value = nid;
2262 err = snd_hda_ctl_add(codec, kctl);
2266 codec->spdif_in_enable =
2267 snd_hda_codec_read(codec, nid, 0,
2268 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2272 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2274 #ifdef SND_HDA_NEEDS_RESUME
2279 /* build a 32bit cache key with the widget id and the command parameter */
2280 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2281 #define get_cmd_cache_nid(key) ((key) & 0xff)
2282 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2285 * snd_hda_codec_write_cache - send a single command with caching
2286 * @codec: the HDA codec
2287 * @nid: NID to send the command
2288 * @direct: direct flag
2289 * @verb: the verb to send
2290 * @parm: the parameter for the verb
2292 * Send a single command without waiting for response.
2294 * Returns 0 if successful, or a negative error code.
2296 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2297 int direct, unsigned int verb, unsigned int parm)
2299 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2300 struct hda_cache_head *c;
2305 /* parm may contain the verb stuff for get/set amp */
2306 verb = verb | (parm >> 8);
2308 key = build_cmd_cache_key(nid, verb);
2309 mutex_lock(&codec->bus->cmd_mutex);
2310 c = get_alloc_hash(&codec->cmd_cache, key);
2313 mutex_unlock(&codec->bus->cmd_mutex);
2316 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2318 /* resume the all commands from the cache */
2319 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2321 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2324 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2325 u32 key = buffer->key;
2328 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2329 get_cmd_cache_cmd(key), buffer->val);
2332 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2335 * snd_hda_sequence_write_cache - sequence writes with caching
2336 * @codec: the HDA codec
2337 * @seq: VERB array to send
2339 * Send the commands sequentially from the given array.
2340 * Thte commands are recorded on cache for power-save and resume.
2341 * The array must be terminated with NID=0.
2343 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2344 const struct hda_verb *seq)
2346 for (; seq->nid; seq++)
2347 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2350 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2351 #endif /* SND_HDA_NEEDS_RESUME */
2354 * set power state of the codec
2356 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2357 unsigned int power_state)
2362 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2364 msleep(10); /* partial workaround for "azx_get_response timeout" */
2366 nid = codec->start_nid;
2367 for (i = 0; i < codec->num_nodes; i++, nid++) {
2368 unsigned int wcaps = get_wcaps(codec, nid);
2369 if (wcaps & AC_WCAP_POWER) {
2370 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2372 if (power_state == AC_PWRST_D3 &&
2373 wid_type == AC_WID_PIN) {
2374 unsigned int pincap;
2376 * don't power down the widget if it controls
2377 * eapd and EAPD_BTLENABLE is set.
2379 pincap = snd_hda_query_pin_caps(codec, nid);
2380 if (pincap & AC_PINCAP_EAPD) {
2381 int eapd = snd_hda_codec_read(codec,
2383 AC_VERB_GET_EAPD_BTLENABLE, 0);
2389 snd_hda_codec_write(codec, nid, 0,
2390 AC_VERB_SET_POWER_STATE,
2395 if (power_state == AC_PWRST_D0) {
2396 unsigned long end_time;
2399 /* wait until the codec reachs to D0 */
2400 end_time = jiffies + msecs_to_jiffies(500);
2402 state = snd_hda_codec_read(codec, fg, 0,
2403 AC_VERB_GET_POWER_STATE, 0);
2404 if (state == power_state)
2407 } while (time_after_eq(end_time, jiffies));
2411 #ifdef CONFIG_SND_HDA_HWDEP
2412 /* execute additional init verbs */
2413 static void hda_exec_init_verbs(struct hda_codec *codec)
2415 if (codec->init_verbs.list)
2416 snd_hda_sequence_write(codec, codec->init_verbs.list);
2419 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2422 #ifdef SND_HDA_NEEDS_RESUME
2424 * call suspend and power-down; used both from PM and power-save
2426 static void hda_call_codec_suspend(struct hda_codec *codec)
2428 if (codec->patch_ops.suspend)
2429 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2430 hda_set_power_state(codec,
2431 codec->afg ? codec->afg : codec->mfg,
2433 #ifdef CONFIG_SND_HDA_POWER_SAVE
2434 cancel_delayed_work(&codec->power_work);
2435 codec->power_on = 0;
2436 codec->power_transition = 0;
2441 * kick up codec; used both from PM and power-save
2443 static void hda_call_codec_resume(struct hda_codec *codec)
2445 hda_set_power_state(codec,
2446 codec->afg ? codec->afg : codec->mfg,
2448 restore_pincfgs(codec); /* restore all current pin configs */
2449 hda_exec_init_verbs(codec);
2450 if (codec->patch_ops.resume)
2451 codec->patch_ops.resume(codec);
2453 if (codec->patch_ops.init)
2454 codec->patch_ops.init(codec);
2455 snd_hda_codec_resume_amp(codec);
2456 snd_hda_codec_resume_cache(codec);
2459 #endif /* SND_HDA_NEEDS_RESUME */
2463 * snd_hda_build_controls - build mixer controls
2466 * Creates mixer controls for each codec included in the bus.
2468 * Returns 0 if successful, otherwise a negative error code.
2470 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2472 struct hda_codec *codec;
2474 list_for_each_entry(codec, &bus->codec_list, list) {
2475 int err = snd_hda_codec_build_controls(codec);
2477 printk(KERN_ERR "hda_codec: cannot build controls"
2478 "for #%d (error %d)\n", codec->addr, err);
2479 err = snd_hda_codec_reset(codec);
2482 "hda_codec: cannot revert codec\n");
2489 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2491 int snd_hda_codec_build_controls(struct hda_codec *codec)
2494 hda_exec_init_verbs(codec);
2495 /* continue to initialize... */
2496 if (codec->patch_ops.init)
2497 err = codec->patch_ops.init(codec);
2498 if (!err && codec->patch_ops.build_controls)
2499 err = codec->patch_ops.build_controls(codec);
2508 struct hda_rate_tbl {
2510 unsigned int alsa_bits;
2511 unsigned int hda_fmt;
2514 static struct hda_rate_tbl rate_bits[] = {
2515 /* rate in Hz, ALSA rate bitmask, HDA format value */
2517 /* autodetected value used in snd_hda_query_supported_pcm */
2518 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2519 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2520 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2521 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2522 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2523 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2524 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2525 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2526 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2527 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2528 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2529 #define AC_PAR_PCM_RATE_BITS 11
2530 /* up to bits 10, 384kHZ isn't supported properly */
2532 /* not autodetected value */
2533 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2535 { 0 } /* terminator */
2539 * snd_hda_calc_stream_format - calculate format bitset
2540 * @rate: the sample rate
2541 * @channels: the number of channels
2542 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2543 * @maxbps: the max. bps
2545 * Calculate the format bitset from the given rate, channels and th PCM format.
2547 * Return zero if invalid.
2549 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2550 unsigned int channels,
2551 unsigned int format,
2552 unsigned int maxbps)
2555 unsigned int val = 0;
2557 for (i = 0; rate_bits[i].hz; i++)
2558 if (rate_bits[i].hz == rate) {
2559 val = rate_bits[i].hda_fmt;
2562 if (!rate_bits[i].hz) {
2563 snd_printdd("invalid rate %d\n", rate);
2567 if (channels == 0 || channels > 8) {
2568 snd_printdd("invalid channels %d\n", channels);
2571 val |= channels - 1;
2573 switch (snd_pcm_format_width(format)) {
2574 case 8: val |= 0x00; break;
2575 case 16: val |= 0x10; break;
2581 else if (maxbps >= 24)
2587 snd_printdd("invalid format width %d\n",
2588 snd_pcm_format_width(format));
2594 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2596 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2598 unsigned int val = 0;
2599 if (nid != codec->afg &&
2600 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2601 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2602 if (!val || val == -1)
2603 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2604 if (!val || val == -1)
2609 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2611 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2615 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2617 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2618 if (!streams || streams == -1)
2619 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2620 if (!streams || streams == -1)
2625 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2627 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2632 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2633 * @codec: the HDA codec
2634 * @nid: NID to query
2635 * @ratesp: the pointer to store the detected rate bitflags
2636 * @formatsp: the pointer to store the detected formats
2637 * @bpsp: the pointer to store the detected format widths
2639 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2640 * or @bsps argument is ignored.
2642 * Returns 0 if successful, otherwise a negative error code.
2644 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2645 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2647 unsigned int i, val, wcaps;
2649 wcaps = get_wcaps(codec, nid);
2650 val = query_pcm_param(codec, nid);
2654 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2656 rates |= rate_bits[i].alsa_bits;
2659 snd_printk(KERN_ERR "hda_codec: rates == 0 "
2660 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2662 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2668 if (formatsp || bpsp) {
2670 unsigned int streams, bps;
2672 streams = query_stream_param(codec, nid);
2677 if (streams & AC_SUPFMT_PCM) {
2678 if (val & AC_SUPPCM_BITS_8) {
2679 formats |= SNDRV_PCM_FMTBIT_U8;
2682 if (val & AC_SUPPCM_BITS_16) {
2683 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2686 if (wcaps & AC_WCAP_DIGITAL) {
2687 if (val & AC_SUPPCM_BITS_32)
2688 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2689 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2690 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2691 if (val & AC_SUPPCM_BITS_24)
2693 else if (val & AC_SUPPCM_BITS_20)
2695 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2696 AC_SUPPCM_BITS_32)) {
2697 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2698 if (val & AC_SUPPCM_BITS_32)
2700 else if (val & AC_SUPPCM_BITS_24)
2702 else if (val & AC_SUPPCM_BITS_20)
2706 else if (streams == AC_SUPFMT_FLOAT32) {
2707 /* should be exclusive */
2708 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2710 } else if (streams == AC_SUPFMT_AC3) {
2711 /* should be exclusive */
2712 /* temporary hack: we have still no proper support
2713 * for the direct AC3 stream...
2715 formats |= SNDRV_PCM_FMTBIT_U8;
2719 snd_printk(KERN_ERR "hda_codec: formats == 0 "
2720 "(nid=0x%x, val=0x%x, ovrd=%i, "
2723 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2728 *formatsp = formats;
2737 * snd_hda_is_supported_format - check whether the given node supports
2740 * Returns 1 if supported, 0 if not.
2742 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2743 unsigned int format)
2746 unsigned int val = 0, rate, stream;
2748 val = query_pcm_param(codec, nid);
2752 rate = format & 0xff00;
2753 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2754 if (rate_bits[i].hda_fmt == rate) {
2759 if (i >= AC_PAR_PCM_RATE_BITS)
2762 stream = query_stream_param(codec, nid);
2766 if (stream & AC_SUPFMT_PCM) {
2767 switch (format & 0xf0) {
2769 if (!(val & AC_SUPPCM_BITS_8))
2773 if (!(val & AC_SUPPCM_BITS_16))
2777 if (!(val & AC_SUPPCM_BITS_20))
2781 if (!(val & AC_SUPPCM_BITS_24))
2785 if (!(val & AC_SUPPCM_BITS_32))
2792 /* FIXME: check for float32 and AC3? */
2797 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2802 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2803 struct hda_codec *codec,
2804 struct snd_pcm_substream *substream)
2809 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2810 struct hda_codec *codec,
2811 unsigned int stream_tag,
2812 unsigned int format,
2813 struct snd_pcm_substream *substream)
2815 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2819 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2820 struct hda_codec *codec,
2821 struct snd_pcm_substream *substream)
2823 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2827 static int set_pcm_default_values(struct hda_codec *codec,
2828 struct hda_pcm_stream *info)
2832 /* query support PCM information from the given NID */
2833 if (info->nid && (!info->rates || !info->formats)) {
2834 err = snd_hda_query_supported_pcm(codec, info->nid,
2835 info->rates ? NULL : &info->rates,
2836 info->formats ? NULL : &info->formats,
2837 info->maxbps ? NULL : &info->maxbps);
2841 if (info->ops.open == NULL)
2842 info->ops.open = hda_pcm_default_open_close;
2843 if (info->ops.close == NULL)
2844 info->ops.close = hda_pcm_default_open_close;
2845 if (info->ops.prepare == NULL) {
2846 if (snd_BUG_ON(!info->nid))
2848 info->ops.prepare = hda_pcm_default_prepare;
2850 if (info->ops.cleanup == NULL) {
2851 if (snd_BUG_ON(!info->nid))
2853 info->ops.cleanup = hda_pcm_default_cleanup;
2859 * get the empty PCM device number to assign
2861 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2863 static const char *dev_name[HDA_PCM_NTYPES] = {
2864 "Audio", "SPDIF", "HDMI", "Modem"
2866 /* starting device index for each PCM type */
2867 static int dev_idx[HDA_PCM_NTYPES] = {
2868 [HDA_PCM_TYPE_AUDIO] = 0,
2869 [HDA_PCM_TYPE_SPDIF] = 1,
2870 [HDA_PCM_TYPE_HDMI] = 3,
2871 [HDA_PCM_TYPE_MODEM] = 6
2873 /* normal audio device indices; not linear to keep compatibility */
2874 static int audio_idx[4] = { 0, 2, 4, 5 };
2878 case HDA_PCM_TYPE_AUDIO:
2879 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2881 if (!test_bit(dev, bus->pcm_dev_bits))
2884 snd_printk(KERN_WARNING "Too many audio devices\n");
2886 case HDA_PCM_TYPE_SPDIF:
2887 case HDA_PCM_TYPE_HDMI:
2888 case HDA_PCM_TYPE_MODEM:
2889 dev = dev_idx[type];
2890 if (test_bit(dev, bus->pcm_dev_bits)) {
2891 snd_printk(KERN_WARNING "%s already defined\n",
2897 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2901 set_bit(dev, bus->pcm_dev_bits);
2906 * attach a new PCM stream
2908 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2910 struct hda_bus *bus = codec->bus;
2911 struct hda_pcm_stream *info;
2914 if (snd_BUG_ON(!pcm->name))
2916 for (stream = 0; stream < 2; stream++) {
2917 info = &pcm->stream[stream];
2918 if (info->substreams) {
2919 err = set_pcm_default_values(codec, info);
2924 return bus->ops.attach_pcm(bus, codec, pcm);
2927 /* assign all PCMs of the given codec */
2928 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2933 if (!codec->num_pcms) {
2934 if (!codec->patch_ops.build_pcms)
2936 err = codec->patch_ops.build_pcms(codec);
2938 printk(KERN_ERR "hda_codec: cannot build PCMs"
2939 "for #%d (error %d)\n", codec->addr, err);
2940 err = snd_hda_codec_reset(codec);
2943 "hda_codec: cannot revert codec\n");
2948 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2949 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2952 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2953 continue; /* no substreams assigned */
2956 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2958 continue; /* no fatal error */
2960 err = snd_hda_attach_pcm(codec, cpcm);
2962 printk(KERN_ERR "hda_codec: cannot attach "
2963 "PCM stream %d for codec #%d\n",
2965 continue; /* no fatal error */
2973 * snd_hda_build_pcms - build PCM information
2976 * Create PCM information for each codec included in the bus.
2978 * The build_pcms codec patch is requested to set up codec->num_pcms and
2979 * codec->pcm_info properly. The array is referred by the top-level driver
2980 * to create its PCM instances.
2981 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2984 * At least, substreams, channels_min and channels_max must be filled for
2985 * each stream. substreams = 0 indicates that the stream doesn't exist.
2986 * When rates and/or formats are zero, the supported values are queried
2987 * from the given nid. The nid is used also by the default ops.prepare
2988 * and ops.cleanup callbacks.
2990 * The driver needs to call ops.open in its open callback. Similarly,
2991 * ops.close is supposed to be called in the close callback.
2992 * ops.prepare should be called in the prepare or hw_params callback
2993 * with the proper parameters for set up.
2994 * ops.cleanup should be called in hw_free for clean up of streams.
2996 * This function returns 0 if successfull, or a negative error code.
2998 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
3000 struct hda_codec *codec;
3002 list_for_each_entry(codec, &bus->codec_list, list) {
3003 int err = snd_hda_codec_build_pcms(codec);
3009 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
3012 * snd_hda_check_board_config - compare the current codec with the config table
3013 * @codec: the HDA codec
3014 * @num_configs: number of config enums
3015 * @models: array of model name strings
3016 * @tbl: configuration table, terminated by null entries
3018 * Compares the modelname or PCI subsystem id of the current codec with the
3019 * given configuration table. If a matching entry is found, returns its
3020 * config value (supposed to be 0 or positive).
3022 * If no entries are matching, the function returns a negative value.
3024 int snd_hda_check_board_config(struct hda_codec *codec,
3025 int num_configs, const char **models,
3026 const struct snd_pci_quirk *tbl)
3028 if (codec->modelname && models) {
3030 for (i = 0; i < num_configs; i++) {
3032 !strcmp(codec->modelname, models[i])) {
3033 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3034 "selected\n", models[i]);
3040 if (!codec->bus->pci || !tbl)
3043 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3046 if (tbl->value >= 0 && tbl->value < num_configs) {
3047 #ifdef CONFIG_SND_DEBUG_VERBOSE
3049 const char *model = NULL;
3051 model = models[tbl->value];
3053 sprintf(tmp, "#%d", tbl->value);
3056 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3057 "for config %x:%x (%s)\n",
3058 model, tbl->subvendor, tbl->subdevice,
3059 (tbl->name ? tbl->name : "Unknown device"));
3065 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3068 * snd_hda_check_board_codec_sid_config - compare the current codec
3069 subsystem ID with the
3072 This is important for Gateway notebooks with SB450 HDA Audio
3073 where the vendor ID of the PCI device is:
3074 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3075 and the vendor/subvendor are found only at the codec.
3077 * @codec: the HDA codec
3078 * @num_configs: number of config enums
3079 * @models: array of model name strings
3080 * @tbl: configuration table, terminated by null entries
3082 * Compares the modelname or PCI subsystem id of the current codec with the
3083 * given configuration table. If a matching entry is found, returns its
3084 * config value (supposed to be 0 or positive).
3086 * If no entries are matching, the function returns a negative value.
3088 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3089 int num_configs, const char **models,
3090 const struct snd_pci_quirk *tbl)
3092 const struct snd_pci_quirk *q;
3094 /* Search for codec ID */
3095 for (q = tbl; q->subvendor; q++) {
3096 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3098 if (vendorid == codec->subsystem_id)
3107 if (tbl->value >= 0 && tbl->value < num_configs) {
3108 #ifdef CONFIG_SND_DEBUG_DETECT
3110 const char *model = NULL;
3112 model = models[tbl->value];
3114 sprintf(tmp, "#%d", tbl->value);
3117 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3118 "for config %x:%x (%s)\n",
3119 model, tbl->subvendor, tbl->subdevice,
3120 (tbl->name ? tbl->name : "Unknown device"));
3126 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3129 * snd_hda_add_new_ctls - create controls from the array
3130 * @codec: the HDA codec
3131 * @knew: the array of struct snd_kcontrol_new
3133 * This helper function creates and add new controls in the given array.
3134 * The array must be terminated with an empty entry as terminator.
3136 * Returns 0 if successful, or a negative error code.
3138 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3142 for (; knew->name; knew++) {
3143 struct snd_kcontrol *kctl;
3144 kctl = snd_ctl_new1(knew, codec);
3147 err = snd_hda_ctl_add(codec, kctl);
3151 kctl = snd_ctl_new1(knew, codec);
3154 kctl->id.device = codec->addr;
3155 err = snd_hda_ctl_add(codec, kctl);
3162 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3164 #ifdef CONFIG_SND_HDA_POWER_SAVE
3165 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3166 unsigned int power_state);
3168 static void hda_power_work(struct work_struct *work)
3170 struct hda_codec *codec =
3171 container_of(work, struct hda_codec, power_work.work);
3172 struct hda_bus *bus = codec->bus;
3174 if (!codec->power_on || codec->power_count) {
3175 codec->power_transition = 0;
3179 hda_call_codec_suspend(codec);
3180 if (bus->ops.pm_notify)
3181 bus->ops.pm_notify(bus);
3184 static void hda_keep_power_on(struct hda_codec *codec)
3186 codec->power_count++;
3187 codec->power_on = 1;
3190 void snd_hda_power_up(struct hda_codec *codec)
3192 struct hda_bus *bus = codec->bus;
3194 codec->power_count++;
3195 if (codec->power_on || codec->power_transition)
3198 codec->power_on = 1;
3199 if (bus->ops.pm_notify)
3200 bus->ops.pm_notify(bus);
3201 hda_call_codec_resume(codec);
3202 cancel_delayed_work(&codec->power_work);
3203 codec->power_transition = 0;
3205 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3207 #define power_save(codec) \
3208 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3210 #define power_save(codec) \
3211 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3213 void snd_hda_power_down(struct hda_codec *codec)
3215 --codec->power_count;
3216 if (!codec->power_on || codec->power_count || codec->power_transition)
3218 if (power_save(codec)) {
3219 codec->power_transition = 1; /* avoid reentrance */
3220 queue_delayed_work(codec->bus->workq, &codec->power_work,
3221 msecs_to_jiffies(power_save(codec) * 1000));
3224 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3226 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3227 struct hda_loopback_check *check,
3230 struct hda_amp_list *p;
3233 if (!check->amplist)
3235 for (p = check->amplist; p->nid; p++) {
3240 return 0; /* nothing changed */
3242 for (p = check->amplist; p->nid; p++) {
3243 for (ch = 0; ch < 2; ch++) {
3244 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3246 if (!(v & HDA_AMP_MUTE) && v > 0) {
3247 if (!check->power_on) {
3248 check->power_on = 1;
3249 snd_hda_power_up(codec);
3255 if (check->power_on) {
3256 check->power_on = 0;
3257 snd_hda_power_down(codec);
3261 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3265 * Channel mode helper
3267 int snd_hda_ch_mode_info(struct hda_codec *codec,
3268 struct snd_ctl_elem_info *uinfo,
3269 const struct hda_channel_mode *chmode,
3272 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3274 uinfo->value.enumerated.items = num_chmodes;
3275 if (uinfo->value.enumerated.item >= num_chmodes)
3276 uinfo->value.enumerated.item = num_chmodes - 1;
3277 sprintf(uinfo->value.enumerated.name, "%dch",
3278 chmode[uinfo->value.enumerated.item].channels);
3281 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3283 int snd_hda_ch_mode_get(struct hda_codec *codec,
3284 struct snd_ctl_elem_value *ucontrol,
3285 const struct hda_channel_mode *chmode,
3291 for (i = 0; i < num_chmodes; i++) {
3292 if (max_channels == chmode[i].channels) {
3293 ucontrol->value.enumerated.item[0] = i;
3299 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3301 int snd_hda_ch_mode_put(struct hda_codec *codec,
3302 struct snd_ctl_elem_value *ucontrol,
3303 const struct hda_channel_mode *chmode,
3309 mode = ucontrol->value.enumerated.item[0];
3310 if (mode >= num_chmodes)
3312 if (*max_channelsp == chmode[mode].channels)
3314 /* change the current channel setting */
3315 *max_channelsp = chmode[mode].channels;
3316 if (chmode[mode].sequence)
3317 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3320 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3325 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3326 struct snd_ctl_elem_info *uinfo)
3330 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3332 uinfo->value.enumerated.items = imux->num_items;
3333 if (!imux->num_items)
3335 index = uinfo->value.enumerated.item;
3336 if (index >= imux->num_items)
3337 index = imux->num_items - 1;
3338 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3341 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3343 int snd_hda_input_mux_put(struct hda_codec *codec,
3344 const struct hda_input_mux *imux,
3345 struct snd_ctl_elem_value *ucontrol,
3347 unsigned int *cur_val)
3351 if (!imux->num_items)
3353 idx = ucontrol->value.enumerated.item[0];
3354 if (idx >= imux->num_items)
3355 idx = imux->num_items - 1;
3356 if (*cur_val == idx)
3358 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3359 imux->items[idx].index);
3363 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3367 * Multi-channel / digital-out PCM helper functions
3370 /* setup SPDIF output stream */
3371 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3372 unsigned int stream_tag, unsigned int format)
3374 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3375 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3376 set_dig_out_convert(codec, nid,
3377 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3379 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3380 if (codec->slave_dig_outs) {
3382 for (d = codec->slave_dig_outs; *d; d++)
3383 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3386 /* turn on again (if needed) */
3387 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3388 set_dig_out_convert(codec, nid,
3389 codec->spdif_ctls & 0xff, -1);
3392 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3394 snd_hda_codec_cleanup_stream(codec, nid);
3395 if (codec->slave_dig_outs) {
3397 for (d = codec->slave_dig_outs; *d; d++)
3398 snd_hda_codec_cleanup_stream(codec, *d);
3403 * open the digital out in the exclusive mode
3405 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3406 struct hda_multi_out *mout)
3408 mutex_lock(&codec->spdif_mutex);
3409 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3410 /* already opened as analog dup; reset it once */
3411 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3412 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3413 mutex_unlock(&codec->spdif_mutex);
3416 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3418 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3419 struct hda_multi_out *mout,
3420 unsigned int stream_tag,
3421 unsigned int format,
3422 struct snd_pcm_substream *substream)
3424 mutex_lock(&codec->spdif_mutex);
3425 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3426 mutex_unlock(&codec->spdif_mutex);
3429 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3431 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3432 struct hda_multi_out *mout)
3434 mutex_lock(&codec->spdif_mutex);
3435 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3436 mutex_unlock(&codec->spdif_mutex);
3439 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3442 * release the digital out
3444 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3445 struct hda_multi_out *mout)
3447 mutex_lock(&codec->spdif_mutex);
3448 mout->dig_out_used = 0;
3449 mutex_unlock(&codec->spdif_mutex);
3452 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3455 * set up more restrictions for analog out
3457 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3458 struct hda_multi_out *mout,
3459 struct snd_pcm_substream *substream,
3460 struct hda_pcm_stream *hinfo)
3462 struct snd_pcm_runtime *runtime = substream->runtime;
3463 runtime->hw.channels_max = mout->max_channels;
3464 if (mout->dig_out_nid) {
3465 if (!mout->analog_rates) {
3466 mout->analog_rates = hinfo->rates;
3467 mout->analog_formats = hinfo->formats;
3468 mout->analog_maxbps = hinfo->maxbps;
3470 runtime->hw.rates = mout->analog_rates;
3471 runtime->hw.formats = mout->analog_formats;
3472 hinfo->maxbps = mout->analog_maxbps;
3474 if (!mout->spdif_rates) {
3475 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3477 &mout->spdif_formats,
3478 &mout->spdif_maxbps);
3480 mutex_lock(&codec->spdif_mutex);
3481 if (mout->share_spdif) {
3482 runtime->hw.rates &= mout->spdif_rates;
3483 runtime->hw.formats &= mout->spdif_formats;
3484 if (mout->spdif_maxbps < hinfo->maxbps)
3485 hinfo->maxbps = mout->spdif_maxbps;
3487 mutex_unlock(&codec->spdif_mutex);
3489 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3490 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3492 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3495 * set up the i/o for analog out
3496 * when the digital out is available, copy the front out to digital out, too.
3498 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3499 struct hda_multi_out *mout,
3500 unsigned int stream_tag,
3501 unsigned int format,
3502 struct snd_pcm_substream *substream)
3504 hda_nid_t *nids = mout->dac_nids;
3505 int chs = substream->runtime->channels;
3508 mutex_lock(&codec->spdif_mutex);
3509 if (mout->dig_out_nid && mout->share_spdif &&
3510 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3512 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3514 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3515 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3516 setup_dig_out_stream(codec, mout->dig_out_nid,
3517 stream_tag, format);
3519 mout->dig_out_used = 0;
3520 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3523 mutex_unlock(&codec->spdif_mutex);
3526 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3528 if (!mout->no_share_stream &&
3529 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3530 /* headphone out will just decode front left/right (stereo) */
3531 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3533 /* extra outputs copied from front */
3534 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3535 if (!mout->no_share_stream && mout->extra_out_nid[i])
3536 snd_hda_codec_setup_stream(codec,
3537 mout->extra_out_nid[i],
3538 stream_tag, 0, format);
3541 for (i = 1; i < mout->num_dacs; i++) {
3542 if (chs >= (i + 1) * 2) /* independent out */
3543 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3545 else if (!mout->no_share_stream) /* copy front */
3546 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3551 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3554 * clean up the setting for analog out
3556 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3557 struct hda_multi_out *mout)
3559 hda_nid_t *nids = mout->dac_nids;
3562 for (i = 0; i < mout->num_dacs; i++)
3563 snd_hda_codec_cleanup_stream(codec, nids[i]);
3565 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3566 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3567 if (mout->extra_out_nid[i])
3568 snd_hda_codec_cleanup_stream(codec,
3569 mout->extra_out_nid[i]);
3570 mutex_lock(&codec->spdif_mutex);
3571 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3572 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3573 mout->dig_out_used = 0;
3575 mutex_unlock(&codec->spdif_mutex);
3578 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3581 * Helper for automatic pin configuration
3584 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3586 for (; *list; list++)
3594 * Sort an associated group of pins according to their sequence numbers.
3596 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3603 for (i = 0; i < num_pins; i++) {
3604 for (j = i + 1; j < num_pins; j++) {
3605 if (sequences[i] > sequences[j]) {
3607 sequences[i] = sequences[j];
3619 * Parse all pin widgets and store the useful pin nids to cfg
3621 * The number of line-outs or any primary output is stored in line_outs,
3622 * and the corresponding output pins are assigned to line_out_pins[],
3623 * in the order of front, rear, CLFE, side, ...
3625 * If more extra outputs (speaker and headphone) are found, the pins are
3626 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3627 * is detected, one of speaker of HP pins is assigned as the primary
3628 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3629 * if any analog output exists.
3631 * The analog input pins are assigned to input_pins array.
3632 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3635 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3636 struct auto_pin_cfg *cfg,
3637 hda_nid_t *ignore_nids)
3639 hda_nid_t nid, end_nid;
3640 short seq, assoc_line_out, assoc_speaker;
3641 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3642 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3643 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3645 memset(cfg, 0, sizeof(*cfg));
3647 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3648 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3649 memset(sequences_hp, 0, sizeof(sequences_hp));
3650 assoc_line_out = assoc_speaker = 0;
3652 end_nid = codec->start_nid + codec->num_nodes;
3653 for (nid = codec->start_nid; nid < end_nid; nid++) {
3654 unsigned int wid_caps = get_wcaps(codec, nid);
3655 unsigned int wid_type =
3656 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3657 unsigned int def_conf;
3660 /* read all default configuration for pin complex */
3661 if (wid_type != AC_WID_PIN)
3663 /* ignore the given nids (e.g. pc-beep returns error) */
3664 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3667 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3668 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3670 loc = get_defcfg_location(def_conf);
3671 switch (get_defcfg_device(def_conf)) {
3672 case AC_JACK_LINE_OUT:
3673 seq = get_defcfg_sequence(def_conf);
3674 assoc = get_defcfg_association(def_conf);
3676 if (!(wid_caps & AC_WCAP_STEREO))
3677 if (!cfg->mono_out_pin)
3678 cfg->mono_out_pin = nid;
3681 if (!assoc_line_out)
3682 assoc_line_out = assoc;
3683 else if (assoc_line_out != assoc)
3685 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3687 cfg->line_out_pins[cfg->line_outs] = nid;
3688 sequences_line_out[cfg->line_outs] = seq;
3691 case AC_JACK_SPEAKER:
3692 seq = get_defcfg_sequence(def_conf);
3693 assoc = get_defcfg_association(def_conf);
3696 if (! assoc_speaker)
3697 assoc_speaker = assoc;
3698 else if (assoc_speaker != assoc)
3700 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3702 cfg->speaker_pins[cfg->speaker_outs] = nid;
3703 sequences_speaker[cfg->speaker_outs] = seq;
3704 cfg->speaker_outs++;
3706 case AC_JACK_HP_OUT:
3707 seq = get_defcfg_sequence(def_conf);
3708 assoc = get_defcfg_association(def_conf);
3709 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3711 cfg->hp_pins[cfg->hp_outs] = nid;
3712 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3715 case AC_JACK_MIC_IN: {
3717 if (loc == AC_JACK_LOC_FRONT) {
3718 preferred = AUTO_PIN_FRONT_MIC;
3721 preferred = AUTO_PIN_MIC;
3722 alt = AUTO_PIN_FRONT_MIC;
3724 if (!cfg->input_pins[preferred])
3725 cfg->input_pins[preferred] = nid;
3726 else if (!cfg->input_pins[alt])
3727 cfg->input_pins[alt] = nid;
3730 case AC_JACK_LINE_IN:
3731 if (loc == AC_JACK_LOC_FRONT)
3732 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3734 cfg->input_pins[AUTO_PIN_LINE] = nid;
3737 cfg->input_pins[AUTO_PIN_CD] = nid;
3740 cfg->input_pins[AUTO_PIN_AUX] = nid;
3742 case AC_JACK_SPDIF_OUT:
3743 case AC_JACK_DIG_OTHER_OUT:
3744 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3746 cfg->dig_out_pins[cfg->dig_outs] = nid;
3747 cfg->dig_out_type[cfg->dig_outs] =
3748 (loc == AC_JACK_LOC_HDMI) ?
3749 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3752 case AC_JACK_SPDIF_IN:
3753 case AC_JACK_DIG_OTHER_IN:
3754 cfg->dig_in_pin = nid;
3755 if (loc == AC_JACK_LOC_HDMI)
3756 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3758 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
3764 * If no line-out is defined but multiple HPs are found,
3765 * some of them might be the real line-outs.
3767 if (!cfg->line_outs && cfg->hp_outs > 1) {
3769 while (i < cfg->hp_outs) {
3770 /* The real HPs should have the sequence 0x0f */
3771 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3775 /* Move it to the line-out table */
3776 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3777 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3780 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3781 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3782 memmove(sequences_hp + i - 1, sequences_hp + i,
3783 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3787 /* sort by sequence */
3788 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3790 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3792 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3795 /* if we have only one mic, make it AUTO_PIN_MIC */
3796 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3797 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3798 cfg->input_pins[AUTO_PIN_MIC] =
3799 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3800 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3802 /* ditto for line-in */
3803 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3804 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3805 cfg->input_pins[AUTO_PIN_LINE] =
3806 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3807 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3811 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3812 * as a primary output
3814 if (!cfg->line_outs) {
3815 if (cfg->speaker_outs) {
3816 cfg->line_outs = cfg->speaker_outs;
3817 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3818 sizeof(cfg->speaker_pins));
3819 cfg->speaker_outs = 0;
3820 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3821 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3822 } else if (cfg->hp_outs) {
3823 cfg->line_outs = cfg->hp_outs;
3824 memcpy(cfg->line_out_pins, cfg->hp_pins,
3825 sizeof(cfg->hp_pins));
3827 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3828 cfg->line_out_type = AUTO_PIN_HP_OUT;
3832 /* Reorder the surround channels
3833 * ALSA sequence is front/surr/clfe/side
3835 * 4-ch: front/surr => OK as it is
3836 * 6-ch: front/clfe/surr
3837 * 8-ch: front/clfe/rear/side|fc
3839 switch (cfg->line_outs) {
3842 nid = cfg->line_out_pins[1];
3843 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3844 cfg->line_out_pins[2] = nid;
3849 * debug prints of the parsed results
3851 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3852 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3853 cfg->line_out_pins[2], cfg->line_out_pins[3],
3854 cfg->line_out_pins[4]);
3855 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3856 cfg->speaker_outs, cfg->speaker_pins[0],
3857 cfg->speaker_pins[1], cfg->speaker_pins[2],
3858 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3859 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3860 cfg->hp_outs, cfg->hp_pins[0],
3861 cfg->hp_pins[1], cfg->hp_pins[2],
3862 cfg->hp_pins[3], cfg->hp_pins[4]);
3863 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3865 snd_printd(" dig-out=0x%x/0x%x\n",
3866 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
3867 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3868 " cd=0x%x, aux=0x%x\n",
3869 cfg->input_pins[AUTO_PIN_MIC],
3870 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3871 cfg->input_pins[AUTO_PIN_LINE],
3872 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3873 cfg->input_pins[AUTO_PIN_CD],
3874 cfg->input_pins[AUTO_PIN_AUX]);
3875 if (cfg->dig_in_pin)
3876 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
3880 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3882 /* labels for input pins */
3883 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3884 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3886 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3895 * snd_hda_suspend - suspend the codecs
3897 * @state: suspsend state
3899 * Returns 0 if successful.
3901 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3903 struct hda_codec *codec;
3905 list_for_each_entry(codec, &bus->codec_list, list) {
3906 #ifdef CONFIG_SND_HDA_POWER_SAVE
3907 if (!codec->power_on)
3910 hda_call_codec_suspend(codec);
3914 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3917 * snd_hda_resume - resume the codecs
3920 * Returns 0 if successful.
3922 * This fucntion is defined only when POWER_SAVE isn't set.
3923 * In the power-save mode, the codec is resumed dynamically.
3925 int snd_hda_resume(struct hda_bus *bus)
3927 struct hda_codec *codec;
3929 list_for_each_entry(codec, &bus->codec_list, list) {
3930 if (snd_hda_codec_needs_resume(codec))
3931 hda_call_codec_resume(codec);
3935 EXPORT_SYMBOL_HDA(snd_hda_resume);
3936 #endif /* CONFIG_PM */
3942 /* get a new element from the given array
3943 * if it exceeds the pre-allocated array size, re-allocate the array
3945 void *snd_array_new(struct snd_array *array)
3947 if (array->used >= array->alloced) {
3948 int num = array->alloced + array->alloc_align;
3950 if (snd_BUG_ON(num >= 4096))
3952 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3956 memcpy(nlist, array->list,
3957 array->elem_size * array->alloced);
3960 array->list = nlist;
3961 array->alloced = num;
3963 return snd_array_elem(array, array->used++);
3965 EXPORT_SYMBOL_HDA(snd_array_new);
3967 /* free the given array elements */
3968 void snd_array_free(struct snd_array *array)
3975 EXPORT_SYMBOL_HDA(snd_array_free);
3978 * used by hda_proc.c and hda_eld.c
3980 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3982 static unsigned int rates[] = {
3983 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3984 96000, 176400, 192000, 384000
3988 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3990 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3992 buf[j] = '\0'; /* necessary when j == 0 */
3994 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3996 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3998 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
4001 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4002 if (pcm & (AC_SUPPCM_BITS_8 << i))
4003 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
4005 buf[j] = '\0'; /* necessary when j == 0 */
4007 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
4009 MODULE_DESCRIPTION("HDA codec core");
4010 MODULE_LICENSE("GPL");