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 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
154 (verb & ~0xfff) || (parm & ~0xffff)) {
155 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
156 codec->addr, direct, nid, verb, parm);
160 val = (u32)codec->addr << 28;
161 val |= (u32)direct << 27;
162 val |= (u32)nid << 20;
169 * Send and receive a verb
171 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
174 struct hda_bus *bus = codec->bus;
183 snd_hda_power_up(codec);
184 mutex_lock(&bus->cmd_mutex);
185 err = bus->ops.command(bus, cmd);
187 *res = bus->ops.get_response(bus);
188 mutex_unlock(&bus->cmd_mutex);
189 snd_hda_power_down(codec);
190 if (res && *res == -1 && bus->rirb_error) {
191 if (bus->response_reset) {
192 snd_printd("hda_codec: resetting BUS due to "
193 "fatal communication error\n");
194 bus->ops.bus_reset(bus);
198 /* clear reset-flag when the communication gets recovered */
200 bus->response_reset = 0;
205 * snd_hda_codec_read - send a command and get the response
206 * @codec: the HDA codec
207 * @nid: NID to send the command
208 * @direct: direct flag
209 * @verb: the verb to send
210 * @parm: the parameter for the verb
212 * Send a single command and read the corresponding response.
214 * Returns the obtained response value, or -1 for an error.
216 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
218 unsigned int verb, unsigned int parm)
220 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
222 codec_exec_verb(codec, cmd, &res);
225 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
228 * snd_hda_codec_write - send a single command without waiting for response
229 * @codec: the HDA codec
230 * @nid: NID to send the command
231 * @direct: direct flag
232 * @verb: the verb to send
233 * @parm: the parameter for the verb
235 * Send a single command without waiting for response.
237 * Returns 0 if successful, or a negative error code.
239 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
240 unsigned int verb, unsigned int parm)
242 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
244 return codec_exec_verb(codec, cmd,
245 codec->bus->sync_write ? &res : NULL);
247 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
250 * snd_hda_sequence_write - sequence writes
251 * @codec: the HDA codec
252 * @seq: VERB array to send
254 * Send the commands sequentially from the given array.
255 * The array must be terminated with NID=0.
257 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
259 for (; seq->nid; seq++)
260 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
262 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
265 * snd_hda_get_sub_nodes - get the range of sub nodes
266 * @codec: the HDA codec
268 * @start_id: the pointer to store the start NID
270 * Parse the NID and store the start NID of its sub-nodes.
271 * Returns the number of sub-nodes.
273 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
278 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
281 *start_id = (parm >> 16) & 0x7fff;
282 return (int)(parm & 0x7fff);
284 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
287 * snd_hda_get_connections - get connection list
288 * @codec: the HDA codec
290 * @conn_list: connection list array
291 * @max_conns: max. number of connections to store
293 * Parses the connection list of the given widget and stores the list
296 * Returns the number of connections, or a negative error code.
298 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
299 hda_nid_t *conn_list, int max_conns)
302 int i, conn_len, conns;
303 unsigned int shift, num_elems, mask;
306 if (snd_BUG_ON(!conn_list || max_conns <= 0))
309 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
310 if (parm & AC_CLIST_LONG) {
319 conn_len = parm & AC_CLIST_LENGTH;
320 mask = (1 << (shift-1)) - 1;
323 return 0; /* no connection */
326 /* single connection */
327 parm = snd_hda_codec_read(codec, nid, 0,
328 AC_VERB_GET_CONNECT_LIST, 0);
329 if (parm == -1 && codec->bus->rirb_error)
331 conn_list[0] = parm & mask;
335 /* multi connection */
338 for (i = 0; i < conn_len; i++) {
342 if (i % num_elems == 0) {
343 parm = snd_hda_codec_read(codec, nid, 0,
344 AC_VERB_GET_CONNECT_LIST, i);
345 if (parm == -1 && codec->bus->rirb_error)
348 range_val = !!(parm & (1 << (shift-1))); /* ranges */
351 snd_printk(KERN_WARNING "hda_codec: "
352 "invalid CONNECT_LIST verb %x[%i]:%x\n",
358 /* ranges between the previous and this one */
359 if (!prev_nid || prev_nid >= val) {
360 snd_printk(KERN_WARNING "hda_codec: "
361 "invalid dep_range_val %x:%x\n",
365 for (n = prev_nid + 1; n <= val; n++) {
366 if (conns >= max_conns) {
368 "Too many connections\n");
371 conn_list[conns++] = n;
374 if (conns >= max_conns) {
375 snd_printk(KERN_ERR "Too many connections\n");
378 conn_list[conns++] = val;
384 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
388 * snd_hda_queue_unsol_event - add an unsolicited event to queue
390 * @res: unsolicited event (lower 32bit of RIRB entry)
391 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
393 * Adds the given event to the queue. The events are processed in
394 * the workqueue asynchronously. Call this function in the interrupt
395 * hanlder when RIRB receives an unsolicited event.
397 * Returns 0 if successful, or a negative error code.
399 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
401 struct hda_bus_unsolicited *unsol;
408 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
412 unsol->queue[wp] = res;
413 unsol->queue[wp + 1] = res_ex;
415 queue_work(bus->workq, &unsol->work);
419 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
422 * process queued unsolicited events
424 static void process_unsol_events(struct work_struct *work)
426 struct hda_bus_unsolicited *unsol =
427 container_of(work, struct hda_bus_unsolicited, work);
428 struct hda_bus *bus = unsol->bus;
429 struct hda_codec *codec;
430 unsigned int rp, caddr, res;
432 while (unsol->rp != unsol->wp) {
433 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
436 res = unsol->queue[rp];
437 caddr = unsol->queue[rp + 1];
438 if (!(caddr & (1 << 4))) /* no unsolicited event? */
440 codec = bus->caddr_tbl[caddr & 0x0f];
441 if (codec && codec->patch_ops.unsol_event)
442 codec->patch_ops.unsol_event(codec, res);
447 * initialize unsolicited queue
449 static int init_unsol_queue(struct hda_bus *bus)
451 struct hda_bus_unsolicited *unsol;
453 if (bus->unsol) /* already initialized */
456 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
458 snd_printk(KERN_ERR "hda_codec: "
459 "can't allocate unsolicited queue\n");
462 INIT_WORK(&unsol->work, process_unsol_events);
471 static void snd_hda_codec_free(struct hda_codec *codec);
473 static int snd_hda_bus_free(struct hda_bus *bus)
475 struct hda_codec *codec, *n;
480 flush_workqueue(bus->workq);
483 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
484 snd_hda_codec_free(codec);
486 if (bus->ops.private_free)
487 bus->ops.private_free(bus);
489 destroy_workqueue(bus->workq);
494 static int snd_hda_bus_dev_free(struct snd_device *device)
496 struct hda_bus *bus = device->device_data;
498 return snd_hda_bus_free(bus);
501 #ifdef CONFIG_SND_HDA_HWDEP
502 static int snd_hda_bus_dev_register(struct snd_device *device)
504 struct hda_bus *bus = device->device_data;
505 struct hda_codec *codec;
506 list_for_each_entry(codec, &bus->codec_list, list) {
507 snd_hda_hwdep_add_sysfs(codec);
512 #define snd_hda_bus_dev_register NULL
516 * snd_hda_bus_new - create a HDA bus
517 * @card: the card entry
518 * @temp: the template for hda_bus information
519 * @busp: the pointer to store the created bus instance
521 * Returns 0 if successful, or a negative error code.
523 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
524 const struct hda_bus_template *temp,
525 struct hda_bus **busp)
529 static struct snd_device_ops dev_ops = {
530 .dev_register = snd_hda_bus_dev_register,
531 .dev_free = snd_hda_bus_dev_free,
534 if (snd_BUG_ON(!temp))
536 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
542 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
544 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
549 bus->private_data = temp->private_data;
550 bus->pci = temp->pci;
551 bus->modelname = temp->modelname;
552 bus->power_save = temp->power_save;
553 bus->ops = temp->ops;
555 mutex_init(&bus->cmd_mutex);
556 INIT_LIST_HEAD(&bus->codec_list);
558 snprintf(bus->workq_name, sizeof(bus->workq_name),
559 "hd-audio%d", card->number);
560 bus->workq = create_singlethread_workqueue(bus->workq_name);
562 snd_printk(KERN_ERR "cannot create workqueue %s\n",
568 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
570 snd_hda_bus_free(bus);
577 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
579 #ifdef CONFIG_SND_HDA_GENERIC
580 #define is_generic_config(codec) \
581 (codec->modelname && !strcmp(codec->modelname, "generic"))
583 #define is_generic_config(codec) 0
587 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
589 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
593 * find a matching codec preset
595 static const struct hda_codec_preset *
596 find_codec_preset(struct hda_codec *codec)
598 struct hda_codec_preset_list *tbl;
599 const struct hda_codec_preset *preset;
600 int mod_requested = 0;
602 if (is_generic_config(codec))
603 return NULL; /* use the generic parser */
606 mutex_lock(&preset_mutex);
607 list_for_each_entry(tbl, &hda_preset_tables, list) {
608 if (!try_module_get(tbl->owner)) {
609 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
612 for (preset = tbl->preset; preset->id; preset++) {
613 u32 mask = preset->mask;
614 if (preset->afg && preset->afg != codec->afg)
616 if (preset->mfg && preset->mfg != codec->mfg)
620 if (preset->id == (codec->vendor_id & mask) &&
622 preset->rev == codec->revision_id)) {
623 mutex_unlock(&preset_mutex);
624 codec->owner = tbl->owner;
628 module_put(tbl->owner);
630 mutex_unlock(&preset_mutex);
632 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
635 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
638 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
639 (codec->vendor_id >> 16) & 0xffff);
640 request_module(name);
648 * get_codec_name - store the codec name
650 static int get_codec_name(struct hda_codec *codec)
652 const struct hda_vendor_id *c;
653 const char *vendor = NULL;
654 u16 vendor_id = codec->vendor_id >> 16;
657 if (codec->vendor_name)
660 for (c = hda_vendor_ids; c->id; c++) {
661 if (c->id == vendor_id) {
667 sprintf(tmp, "Generic %04x", vendor_id);
670 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
671 if (!codec->vendor_name)
675 if (codec->chip_name)
678 if (codec->preset && codec->preset->name)
679 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
681 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
682 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
684 if (!codec->chip_name)
690 * look for an AFG and MFG nodes
692 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
694 int i, total_nodes, function_id;
697 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
698 for (i = 0; i < total_nodes; i++, nid++) {
699 function_id = snd_hda_param_read(codec, nid,
700 AC_PAR_FUNCTION_TYPE) & 0xff;
701 switch (function_id) {
702 case AC_GRP_AUDIO_FUNCTION:
704 codec->function_id = function_id;
706 case AC_GRP_MODEM_FUNCTION:
708 codec->function_id = function_id;
717 * read widget caps for each widget and store in cache
719 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
724 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
726 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
729 nid = codec->start_nid;
730 for (i = 0; i < codec->num_nodes; i++, nid++)
731 codec->wcaps[i] = snd_hda_param_read(codec, nid,
732 AC_PAR_AUDIO_WIDGET_CAP);
736 /* read all pin default configurations and save codec->init_pins */
737 static int read_pin_defaults(struct hda_codec *codec)
740 hda_nid_t nid = codec->start_nid;
742 for (i = 0; i < codec->num_nodes; i++, nid++) {
743 struct hda_pincfg *pin;
744 unsigned int wcaps = get_wcaps(codec, nid);
745 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
747 if (wid_type != AC_WID_PIN)
749 pin = snd_array_new(&codec->init_pins);
753 pin->cfg = snd_hda_codec_read(codec, nid, 0,
754 AC_VERB_GET_CONFIG_DEFAULT, 0);
759 /* look up the given pin config list and return the item matching with NID */
760 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
761 struct snd_array *array,
765 for (i = 0; i < array->used; i++) {
766 struct hda_pincfg *pin = snd_array_elem(array, i);
773 /* write a config value for the given NID */
774 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
778 for (i = 0; i < 4; i++) {
779 snd_hda_codec_write(codec, nid, 0,
780 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
786 /* set the current pin config value for the given NID.
787 * the value is cached, and read via snd_hda_codec_get_pincfg()
789 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
790 hda_nid_t nid, unsigned int cfg)
792 struct hda_pincfg *pin;
795 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
796 pin = look_up_pincfg(codec, list, nid);
798 pin = snd_array_new(list);
805 /* change only when needed; e.g. if the pincfg is already present
806 * in user_pins[], don't write it
808 cfg = snd_hda_codec_get_pincfg(codec, nid);
810 set_pincfg(codec, nid, cfg);
814 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
815 hda_nid_t nid, unsigned int cfg)
817 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
819 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
821 /* get the current pin config value of the given pin NID */
822 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
824 struct hda_pincfg *pin;
826 #ifdef CONFIG_SND_HDA_HWDEP
827 pin = look_up_pincfg(codec, &codec->user_pins, nid);
831 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
834 pin = look_up_pincfg(codec, &codec->init_pins, nid);
839 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
841 /* restore all current pin configs */
842 static void restore_pincfgs(struct hda_codec *codec)
845 for (i = 0; i < codec->init_pins.used; i++) {
846 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
847 set_pincfg(codec, pin->nid,
848 snd_hda_codec_get_pincfg(codec, pin->nid));
852 static void init_hda_cache(struct hda_cache_rec *cache,
853 unsigned int record_size);
854 static void free_hda_cache(struct hda_cache_rec *cache);
856 /* restore the initial pin cfgs and release all pincfg lists */
857 static void restore_init_pincfgs(struct hda_codec *codec)
859 /* first free driver_pins and user_pins, then call restore_pincfg
860 * so that only the values in init_pins are restored
862 snd_array_free(&codec->driver_pins);
863 #ifdef CONFIG_SND_HDA_HWDEP
864 snd_array_free(&codec->user_pins);
866 restore_pincfgs(codec);
867 snd_array_free(&codec->init_pins);
873 static void snd_hda_codec_free(struct hda_codec *codec)
877 restore_init_pincfgs(codec);
878 #ifdef CONFIG_SND_HDA_POWER_SAVE
879 cancel_delayed_work(&codec->power_work);
880 flush_workqueue(codec->bus->workq);
882 list_del(&codec->list);
883 snd_array_free(&codec->mixers);
884 codec->bus->caddr_tbl[codec->addr] = NULL;
885 if (codec->patch_ops.free)
886 codec->patch_ops.free(codec);
887 module_put(codec->owner);
888 free_hda_cache(&codec->amp_cache);
889 free_hda_cache(&codec->cmd_cache);
890 kfree(codec->vendor_name);
891 kfree(codec->chip_name);
892 kfree(codec->modelname);
897 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
898 unsigned int power_state);
901 * snd_hda_codec_new - create a HDA codec
902 * @bus: the bus to assign
903 * @codec_addr: the codec address
904 * @codecp: the pointer to store the generated codec
906 * Returns 0 if successful, or a negative error code.
908 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
909 struct hda_codec **codecp)
911 struct hda_codec *codec;
915 if (snd_BUG_ON(!bus))
917 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
920 if (bus->caddr_tbl[codec_addr]) {
921 snd_printk(KERN_ERR "hda_codec: "
922 "address 0x%x is already occupied\n", codec_addr);
926 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
928 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
933 codec->addr = codec_addr;
934 mutex_init(&codec->spdif_mutex);
935 mutex_init(&codec->control_mutex);
936 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
937 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
938 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
939 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
940 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
941 if (codec->bus->modelname) {
942 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
943 if (!codec->modelname) {
944 snd_hda_codec_free(codec);
949 #ifdef CONFIG_SND_HDA_POWER_SAVE
950 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
951 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
952 * the caller has to power down appropriatley after initialization
955 hda_keep_power_on(codec);
958 list_add_tail(&codec->list, &bus->codec_list);
959 bus->caddr_tbl[codec_addr] = codec;
961 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
963 if (codec->vendor_id == -1)
964 /* read again, hopefully the access method was corrected
965 * in the last read...
967 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
969 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
970 AC_PAR_SUBSYSTEM_ID);
971 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
974 setup_fg_nodes(codec);
975 if (!codec->afg && !codec->mfg) {
976 snd_printdd("hda_codec: no AFG or MFG node found\n");
981 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
983 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
986 err = read_pin_defaults(codec);
990 if (!codec->subsystem_id) {
991 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
992 codec->subsystem_id =
993 snd_hda_codec_read(codec, nid, 0,
994 AC_VERB_GET_SUBSYSTEM_ID, 0);
997 /* power-up all before initialization */
998 hda_set_power_state(codec,
999 codec->afg ? codec->afg : codec->mfg,
1002 snd_hda_codec_proc_new(codec);
1004 snd_hda_create_hwdep(codec);
1006 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1007 codec->subsystem_id, codec->revision_id);
1008 snd_component_add(codec->bus->card, component);
1015 snd_hda_codec_free(codec);
1018 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1020 int snd_hda_codec_configure(struct hda_codec *codec)
1024 codec->preset = find_codec_preset(codec);
1025 if (!codec->vendor_name || !codec->chip_name) {
1026 err = get_codec_name(codec);
1030 /* audio codec should override the mixer name */
1031 if (codec->afg || !*codec->bus->card->mixername)
1032 snprintf(codec->bus->card->mixername,
1033 sizeof(codec->bus->card->mixername),
1034 "%s %s", codec->vendor_name, codec->chip_name);
1036 if (is_generic_config(codec)) {
1037 err = snd_hda_parse_generic_codec(codec);
1040 if (codec->preset && codec->preset->patch) {
1041 err = codec->preset->patch(codec);
1045 /* call the default parser */
1046 err = snd_hda_parse_generic_codec(codec);
1048 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1051 if (!err && codec->patch_ops.unsol_event)
1052 err = init_unsol_queue(codec->bus);
1055 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1058 * snd_hda_codec_setup_stream - set up the codec for streaming
1059 * @codec: the CODEC to set up
1060 * @nid: the NID to set up
1061 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1062 * @channel_id: channel id to pass, zero based.
1063 * @format: stream format.
1065 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1067 int channel_id, int format)
1072 snd_printdd("hda_codec_setup_stream: "
1073 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1074 nid, stream_tag, channel_id, format);
1075 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1076 (stream_tag << 4) | channel_id);
1078 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1080 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1082 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1087 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1088 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1089 #if 0 /* keep the format */
1091 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1094 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
1097 * amp access functions
1100 /* FIXME: more better hash key? */
1101 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1102 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1103 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1104 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1105 #define INFO_AMP_CAPS (1<<0)
1106 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1108 /* initialize the hash table */
1109 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1110 unsigned int record_size)
1112 memset(cache, 0, sizeof(*cache));
1113 memset(cache->hash, 0xff, sizeof(cache->hash));
1114 snd_array_init(&cache->buf, record_size, 64);
1117 static void free_hda_cache(struct hda_cache_rec *cache)
1119 snd_array_free(&cache->buf);
1122 /* query the hash. allocate an entry if not found. */
1123 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1126 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1127 u16 cur = cache->hash[idx];
1128 struct hda_cache_head *info;
1130 while (cur != 0xffff) {
1131 info = snd_array_elem(&cache->buf, cur);
1132 if (info->key == key)
1137 /* add a new hash entry */
1138 info = snd_array_new(&cache->buf);
1141 cur = snd_array_index(&cache->buf, info);
1144 info->next = cache->hash[idx];
1145 cache->hash[idx] = cur;
1150 /* query and allocate an amp hash entry */
1151 static inline struct hda_amp_info *
1152 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1154 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1158 * query AMP capabilities for the given widget and direction
1160 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1162 struct hda_amp_info *info;
1164 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1167 if (!(info->head.val & INFO_AMP_CAPS)) {
1168 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1170 info->amp_caps = snd_hda_param_read(codec, nid,
1171 direction == HDA_OUTPUT ?
1172 AC_PAR_AMP_OUT_CAP :
1175 info->head.val |= INFO_AMP_CAPS;
1177 return info->amp_caps;
1179 EXPORT_SYMBOL_HDA(query_amp_caps);
1181 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1184 struct hda_amp_info *info;
1186 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1189 info->amp_caps = caps;
1190 info->head.val |= INFO_AMP_CAPS;
1193 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1196 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1197 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1199 struct hda_amp_info *info;
1201 info = get_alloc_amp_hash(codec, key);
1204 if (!info->head.val) {
1205 info->head.val |= INFO_AMP_CAPS;
1206 info->amp_caps = func(codec, nid);
1208 return info->amp_caps;
1211 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1213 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1216 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1218 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1221 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1224 * read the current volume to info
1225 * if the cache exists, read the cache value.
1227 static unsigned int get_vol_mute(struct hda_codec *codec,
1228 struct hda_amp_info *info, hda_nid_t nid,
1229 int ch, int direction, int index)
1233 if (info->head.val & INFO_AMP_VOL(ch))
1234 return info->vol[ch];
1236 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1237 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1239 val = snd_hda_codec_read(codec, nid, 0,
1240 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1241 info->vol[ch] = val & 0xff;
1242 info->head.val |= INFO_AMP_VOL(ch);
1243 return info->vol[ch];
1247 * write the current volume in info to the h/w and update the cache
1249 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1250 hda_nid_t nid, int ch, int direction, int index,
1255 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1256 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1257 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1259 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1260 info->vol[ch] = val;
1264 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1266 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1267 int direction, int index)
1269 struct hda_amp_info *info;
1270 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1273 return get_vol_mute(codec, info, nid, ch, direction, index);
1275 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1278 * update the AMP value, mask = bit mask to set, val = the value
1280 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1281 int direction, int idx, int mask, int val)
1283 struct hda_amp_info *info;
1285 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1289 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1290 if (info->vol[ch] == val)
1292 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1295 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1298 * update the AMP stereo with the same mask and value
1300 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1301 int direction, int idx, int mask, int val)
1304 for (ch = 0; ch < 2; ch++)
1305 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1309 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1311 #ifdef SND_HDA_NEEDS_RESUME
1312 /* resume the all amp commands from the cache */
1313 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1315 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1318 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1319 u32 key = buffer->head.key;
1321 unsigned int idx, dir, ch;
1325 idx = (key >> 16) & 0xff;
1326 dir = (key >> 24) & 0xff;
1327 for (ch = 0; ch < 2; ch++) {
1328 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1330 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1335 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1336 #endif /* SND_HDA_NEEDS_RESUME */
1339 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1340 struct snd_ctl_elem_info *uinfo)
1342 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1343 u16 nid = get_amp_nid(kcontrol);
1344 u8 chs = get_amp_channels(kcontrol);
1345 int dir = get_amp_direction(kcontrol);
1346 unsigned int ofs = get_amp_offset(kcontrol);
1349 caps = query_amp_caps(codec, nid, dir);
1351 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1353 printk(KERN_WARNING "hda_codec: "
1354 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1360 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1361 uinfo->count = chs == 3 ? 2 : 1;
1362 uinfo->value.integer.min = 0;
1363 uinfo->value.integer.max = caps;
1366 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1369 static inline unsigned int
1370 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1371 int ch, int dir, int idx, unsigned int ofs)
1374 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1375 val &= HDA_AMP_VOLMASK;
1384 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1385 int ch, int dir, int idx, unsigned int ofs,
1390 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1391 HDA_AMP_VOLMASK, val);
1394 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1395 struct snd_ctl_elem_value *ucontrol)
1397 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1398 hda_nid_t nid = get_amp_nid(kcontrol);
1399 int chs = get_amp_channels(kcontrol);
1400 int dir = get_amp_direction(kcontrol);
1401 int idx = get_amp_index(kcontrol);
1402 unsigned int ofs = get_amp_offset(kcontrol);
1403 long *valp = ucontrol->value.integer.value;
1406 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1408 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1411 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1413 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1414 struct snd_ctl_elem_value *ucontrol)
1416 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1417 hda_nid_t nid = get_amp_nid(kcontrol);
1418 int chs = get_amp_channels(kcontrol);
1419 int dir = get_amp_direction(kcontrol);
1420 int idx = get_amp_index(kcontrol);
1421 unsigned int ofs = get_amp_offset(kcontrol);
1422 long *valp = ucontrol->value.integer.value;
1425 snd_hda_power_up(codec);
1427 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1431 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1432 snd_hda_power_down(codec);
1435 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1437 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1438 unsigned int size, unsigned int __user *_tlv)
1440 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1441 hda_nid_t nid = get_amp_nid(kcontrol);
1442 int dir = get_amp_direction(kcontrol);
1443 unsigned int ofs = get_amp_offset(kcontrol);
1444 u32 caps, val1, val2;
1446 if (size < 4 * sizeof(unsigned int))
1448 caps = query_amp_caps(codec, nid, dir);
1449 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1450 val2 = (val2 + 1) * 25;
1451 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1453 val1 = ((int)val1) * ((int)val2);
1454 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1456 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1458 if (put_user(val1, _tlv + 2))
1460 if (put_user(val2, _tlv + 3))
1464 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1467 * set (static) TLV for virtual master volume; recalculated as max 0dB
1469 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1475 caps = query_amp_caps(codec, nid, dir);
1476 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1477 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1478 step = (step + 1) * 25;
1479 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1480 tlv[1] = 2 * sizeof(unsigned int);
1481 tlv[2] = -nums * step;
1484 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1486 /* find a mixer control element with the given name */
1487 static struct snd_kcontrol *
1488 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1489 const char *name, int idx)
1491 struct snd_ctl_elem_id id;
1492 memset(&id, 0, sizeof(id));
1493 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1495 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1497 strcpy(id.name, name);
1498 return snd_ctl_find_id(codec->bus->card, &id);
1501 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1504 return _snd_hda_find_mixer_ctl(codec, name, 0);
1506 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1508 /* Add a control element and assign to the codec */
1509 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1512 struct snd_kcontrol **knewp;
1514 err = snd_ctl_add(codec->bus->card, kctl);
1517 knewp = snd_array_new(&codec->mixers);
1523 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1525 /* Clear all controls assigned to the given codec */
1526 void snd_hda_ctls_clear(struct hda_codec *codec)
1529 struct snd_kcontrol **kctls = codec->mixers.list;
1530 for (i = 0; i < codec->mixers.used; i++)
1531 snd_ctl_remove(codec->bus->card, kctls[i]);
1532 snd_array_free(&codec->mixers);
1535 /* pseudo device locking
1536 * toggle card->shutdown to allow/disallow the device access (as a hack)
1538 static int hda_lock_devices(struct snd_card *card)
1540 spin_lock(&card->files_lock);
1541 if (card->shutdown) {
1542 spin_unlock(&card->files_lock);
1546 spin_unlock(&card->files_lock);
1550 static void hda_unlock_devices(struct snd_card *card)
1552 spin_lock(&card->files_lock);
1554 spin_unlock(&card->files_lock);
1557 int snd_hda_codec_reset(struct hda_codec *codec)
1559 struct snd_card *card = codec->bus->card;
1562 if (hda_lock_devices(card) < 0)
1564 /* check whether the codec isn't used by any mixer or PCM streams */
1565 if (!list_empty(&card->ctl_files)) {
1566 hda_unlock_devices(card);
1569 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1570 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1573 if (cpcm->pcm->streams[0].substream_opened ||
1574 cpcm->pcm->streams[1].substream_opened) {
1575 hda_unlock_devices(card);
1580 /* OK, let it free */
1582 #ifdef CONFIG_SND_HDA_POWER_SAVE
1583 cancel_delayed_work(&codec->power_work);
1584 flush_workqueue(codec->bus->workq);
1586 snd_hda_ctls_clear(codec);
1588 for (i = 0; i < codec->num_pcms; i++) {
1589 if (codec->pcm_info[i].pcm) {
1590 snd_device_free(card, codec->pcm_info[i].pcm);
1591 clear_bit(codec->pcm_info[i].device,
1592 codec->bus->pcm_dev_bits);
1595 if (codec->patch_ops.free)
1596 codec->patch_ops.free(codec);
1597 codec->proc_widget_hook = NULL;
1599 free_hda_cache(&codec->amp_cache);
1600 free_hda_cache(&codec->cmd_cache);
1601 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1602 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1603 /* free only driver_pins so that init_pins + user_pins are restored */
1604 snd_array_free(&codec->driver_pins);
1605 restore_pincfgs(codec);
1606 codec->num_pcms = 0;
1607 codec->pcm_info = NULL;
1608 codec->preset = NULL;
1609 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1610 codec->slave_dig_outs = NULL;
1611 codec->spdif_status_reset = 0;
1612 module_put(codec->owner);
1613 codec->owner = NULL;
1615 /* allow device access again */
1616 hda_unlock_devices(card);
1620 /* create a virtual master control and add slaves */
1621 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1622 unsigned int *tlv, const char **slaves)
1624 struct snd_kcontrol *kctl;
1628 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1631 snd_printdd("No slave found for %s\n", name);
1634 kctl = snd_ctl_make_virtual_master(name, tlv);
1637 err = snd_hda_ctl_add(codec, kctl);
1641 for (s = slaves; *s; s++) {
1642 struct snd_kcontrol *sctl;
1645 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1648 snd_printdd("Cannot find slave %s, "
1652 err = snd_ctl_add_slave(kctl, sctl);
1660 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1663 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1664 struct snd_ctl_elem_info *uinfo)
1666 int chs = get_amp_channels(kcontrol);
1668 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1669 uinfo->count = chs == 3 ? 2 : 1;
1670 uinfo->value.integer.min = 0;
1671 uinfo->value.integer.max = 1;
1674 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1676 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1677 struct snd_ctl_elem_value *ucontrol)
1679 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1680 hda_nid_t nid = get_amp_nid(kcontrol);
1681 int chs = get_amp_channels(kcontrol);
1682 int dir = get_amp_direction(kcontrol);
1683 int idx = get_amp_index(kcontrol);
1684 long *valp = ucontrol->value.integer.value;
1687 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1688 HDA_AMP_MUTE) ? 0 : 1;
1690 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1691 HDA_AMP_MUTE) ? 0 : 1;
1694 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1696 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1697 struct snd_ctl_elem_value *ucontrol)
1699 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1700 hda_nid_t nid = get_amp_nid(kcontrol);
1701 int chs = get_amp_channels(kcontrol);
1702 int dir = get_amp_direction(kcontrol);
1703 int idx = get_amp_index(kcontrol);
1704 long *valp = ucontrol->value.integer.value;
1707 snd_hda_power_up(codec);
1709 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1711 *valp ? 0 : HDA_AMP_MUTE);
1715 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1717 *valp ? 0 : HDA_AMP_MUTE);
1718 #ifdef CONFIG_SND_HDA_POWER_SAVE
1719 if (codec->patch_ops.check_power_status)
1720 codec->patch_ops.check_power_status(codec, nid);
1722 snd_hda_power_down(codec);
1725 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1728 * bound volume controls
1730 * bind multiple volumes (# indices, from 0)
1733 #define AMP_VAL_IDX_SHIFT 19
1734 #define AMP_VAL_IDX_MASK (0x0f<<19)
1736 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1737 struct snd_ctl_elem_value *ucontrol)
1739 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1743 mutex_lock(&codec->control_mutex);
1744 pval = kcontrol->private_value;
1745 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1746 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1747 kcontrol->private_value = pval;
1748 mutex_unlock(&codec->control_mutex);
1751 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1753 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1754 struct snd_ctl_elem_value *ucontrol)
1756 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1758 int i, indices, err = 0, change = 0;
1760 mutex_lock(&codec->control_mutex);
1761 pval = kcontrol->private_value;
1762 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1763 for (i = 0; i < indices; i++) {
1764 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1765 (i << AMP_VAL_IDX_SHIFT);
1766 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1771 kcontrol->private_value = pval;
1772 mutex_unlock(&codec->control_mutex);
1773 return err < 0 ? err : change;
1775 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1778 * generic bound volume/swtich controls
1780 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1781 struct snd_ctl_elem_info *uinfo)
1783 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1784 struct hda_bind_ctls *c;
1787 mutex_lock(&codec->control_mutex);
1788 c = (struct hda_bind_ctls *)kcontrol->private_value;
1789 kcontrol->private_value = *c->values;
1790 err = c->ops->info(kcontrol, uinfo);
1791 kcontrol->private_value = (long)c;
1792 mutex_unlock(&codec->control_mutex);
1795 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1797 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1798 struct snd_ctl_elem_value *ucontrol)
1800 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1801 struct hda_bind_ctls *c;
1804 mutex_lock(&codec->control_mutex);
1805 c = (struct hda_bind_ctls *)kcontrol->private_value;
1806 kcontrol->private_value = *c->values;
1807 err = c->ops->get(kcontrol, ucontrol);
1808 kcontrol->private_value = (long)c;
1809 mutex_unlock(&codec->control_mutex);
1812 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1814 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1815 struct snd_ctl_elem_value *ucontrol)
1817 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1818 struct hda_bind_ctls *c;
1819 unsigned long *vals;
1820 int err = 0, change = 0;
1822 mutex_lock(&codec->control_mutex);
1823 c = (struct hda_bind_ctls *)kcontrol->private_value;
1824 for (vals = c->values; *vals; vals++) {
1825 kcontrol->private_value = *vals;
1826 err = c->ops->put(kcontrol, ucontrol);
1831 kcontrol->private_value = (long)c;
1832 mutex_unlock(&codec->control_mutex);
1833 return err < 0 ? err : change;
1835 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1837 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1838 unsigned int size, unsigned int __user *tlv)
1840 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1841 struct hda_bind_ctls *c;
1844 mutex_lock(&codec->control_mutex);
1845 c = (struct hda_bind_ctls *)kcontrol->private_value;
1846 kcontrol->private_value = *c->values;
1847 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1848 kcontrol->private_value = (long)c;
1849 mutex_unlock(&codec->control_mutex);
1852 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1854 struct hda_ctl_ops snd_hda_bind_vol = {
1855 .info = snd_hda_mixer_amp_volume_info,
1856 .get = snd_hda_mixer_amp_volume_get,
1857 .put = snd_hda_mixer_amp_volume_put,
1858 .tlv = snd_hda_mixer_amp_tlv
1860 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1862 struct hda_ctl_ops snd_hda_bind_sw = {
1863 .info = snd_hda_mixer_amp_switch_info,
1864 .get = snd_hda_mixer_amp_switch_get,
1865 .put = snd_hda_mixer_amp_switch_put,
1866 .tlv = snd_hda_mixer_amp_tlv
1868 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1871 * SPDIF out controls
1874 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1875 struct snd_ctl_elem_info *uinfo)
1877 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1882 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1883 struct snd_ctl_elem_value *ucontrol)
1885 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1886 IEC958_AES0_NONAUDIO |
1887 IEC958_AES0_CON_EMPHASIS_5015 |
1888 IEC958_AES0_CON_NOT_COPYRIGHT;
1889 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1890 IEC958_AES1_CON_ORIGINAL;
1894 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1895 struct snd_ctl_elem_value *ucontrol)
1897 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1898 IEC958_AES0_NONAUDIO |
1899 IEC958_AES0_PRO_EMPHASIS_5015;
1903 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1904 struct snd_ctl_elem_value *ucontrol)
1906 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1908 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1909 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1910 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1911 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1916 /* convert from SPDIF status bits to HDA SPDIF bits
1917 * bit 0 (DigEn) is always set zero (to be filled later)
1919 static unsigned short convert_from_spdif_status(unsigned int sbits)
1921 unsigned short val = 0;
1923 if (sbits & IEC958_AES0_PROFESSIONAL)
1924 val |= AC_DIG1_PROFESSIONAL;
1925 if (sbits & IEC958_AES0_NONAUDIO)
1926 val |= AC_DIG1_NONAUDIO;
1927 if (sbits & IEC958_AES0_PROFESSIONAL) {
1928 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1929 IEC958_AES0_PRO_EMPHASIS_5015)
1930 val |= AC_DIG1_EMPHASIS;
1932 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1933 IEC958_AES0_CON_EMPHASIS_5015)
1934 val |= AC_DIG1_EMPHASIS;
1935 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1936 val |= AC_DIG1_COPYRIGHT;
1937 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1938 val |= AC_DIG1_LEVEL;
1939 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1944 /* convert to SPDIF status bits from HDA SPDIF bits
1946 static unsigned int convert_to_spdif_status(unsigned short val)
1948 unsigned int sbits = 0;
1950 if (val & AC_DIG1_NONAUDIO)
1951 sbits |= IEC958_AES0_NONAUDIO;
1952 if (val & AC_DIG1_PROFESSIONAL)
1953 sbits |= IEC958_AES0_PROFESSIONAL;
1954 if (sbits & IEC958_AES0_PROFESSIONAL) {
1955 if (sbits & AC_DIG1_EMPHASIS)
1956 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1958 if (val & AC_DIG1_EMPHASIS)
1959 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1960 if (!(val & AC_DIG1_COPYRIGHT))
1961 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1962 if (val & AC_DIG1_LEVEL)
1963 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1964 sbits |= val & (0x7f << 8);
1969 /* set digital convert verbs both for the given NID and its slaves */
1970 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1975 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1976 d = codec->slave_dig_outs;
1980 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1983 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1987 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1989 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1992 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1993 struct snd_ctl_elem_value *ucontrol)
1995 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1996 hda_nid_t nid = kcontrol->private_value;
2000 mutex_lock(&codec->spdif_mutex);
2001 codec->spdif_status = ucontrol->value.iec958.status[0] |
2002 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2003 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2004 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2005 val = convert_from_spdif_status(codec->spdif_status);
2006 val |= codec->spdif_ctls & 1;
2007 change = codec->spdif_ctls != val;
2008 codec->spdif_ctls = val;
2011 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2013 mutex_unlock(&codec->spdif_mutex);
2017 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2019 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2020 struct snd_ctl_elem_value *ucontrol)
2022 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2024 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
2028 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2029 struct snd_ctl_elem_value *ucontrol)
2031 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2032 hda_nid_t nid = kcontrol->private_value;
2036 mutex_lock(&codec->spdif_mutex);
2037 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2038 if (ucontrol->value.integer.value[0])
2039 val |= AC_DIG1_ENABLE;
2040 change = codec->spdif_ctls != val;
2042 codec->spdif_ctls = val;
2043 set_dig_out_convert(codec, nid, val & 0xff, -1);
2044 /* unmute amp switch (if any) */
2045 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2046 (val & AC_DIG1_ENABLE))
2047 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2050 mutex_unlock(&codec->spdif_mutex);
2054 static struct snd_kcontrol_new dig_mixes[] = {
2056 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2057 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2058 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2059 .info = snd_hda_spdif_mask_info,
2060 .get = snd_hda_spdif_cmask_get,
2063 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2064 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2065 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2066 .info = snd_hda_spdif_mask_info,
2067 .get = snd_hda_spdif_pmask_get,
2070 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2071 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2072 .info = snd_hda_spdif_mask_info,
2073 .get = snd_hda_spdif_default_get,
2074 .put = snd_hda_spdif_default_put,
2077 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2078 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2079 .info = snd_hda_spdif_out_switch_info,
2080 .get = snd_hda_spdif_out_switch_get,
2081 .put = snd_hda_spdif_out_switch_put,
2086 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2089 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2090 * @codec: the HDA codec
2091 * @nid: audio out widget NID
2093 * Creates controls related with the SPDIF output.
2094 * Called from each patch supporting the SPDIF out.
2096 * Returns 0 if successful, or a negative error code.
2098 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2101 struct snd_kcontrol *kctl;
2102 struct snd_kcontrol_new *dig_mix;
2105 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2106 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2110 if (idx >= SPDIF_MAX_IDX) {
2111 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2114 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2115 kctl = snd_ctl_new1(dig_mix, codec);
2118 kctl->id.index = idx;
2119 kctl->private_value = nid;
2120 err = snd_hda_ctl_add(codec, kctl);
2125 snd_hda_codec_read(codec, nid, 0,
2126 AC_VERB_GET_DIGI_CONVERT_1, 0);
2127 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2130 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2133 * SPDIF sharing with analog output
2135 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2136 struct snd_ctl_elem_value *ucontrol)
2138 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2139 ucontrol->value.integer.value[0] = mout->share_spdif;
2143 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2144 struct snd_ctl_elem_value *ucontrol)
2146 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2147 mout->share_spdif = !!ucontrol->value.integer.value[0];
2151 static struct snd_kcontrol_new spdif_share_sw = {
2152 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2153 .name = "IEC958 Default PCM Playback Switch",
2154 .info = snd_ctl_boolean_mono_info,
2155 .get = spdif_share_sw_get,
2156 .put = spdif_share_sw_put,
2159 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2160 struct hda_multi_out *mout)
2162 if (!mout->dig_out_nid)
2164 /* ATTENTION: here mout is passed as private_data, instead of codec */
2165 return snd_hda_ctl_add(codec,
2166 snd_ctl_new1(&spdif_share_sw, mout));
2168 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2174 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2176 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2177 struct snd_ctl_elem_value *ucontrol)
2179 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2181 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2185 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2186 struct snd_ctl_elem_value *ucontrol)
2188 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2189 hda_nid_t nid = kcontrol->private_value;
2190 unsigned int val = !!ucontrol->value.integer.value[0];
2193 mutex_lock(&codec->spdif_mutex);
2194 change = codec->spdif_in_enable != val;
2196 codec->spdif_in_enable = val;
2197 snd_hda_codec_write_cache(codec, nid, 0,
2198 AC_VERB_SET_DIGI_CONVERT_1, val);
2200 mutex_unlock(&codec->spdif_mutex);
2204 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2205 struct snd_ctl_elem_value *ucontrol)
2207 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2208 hda_nid_t nid = kcontrol->private_value;
2212 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2213 sbits = convert_to_spdif_status(val);
2214 ucontrol->value.iec958.status[0] = sbits;
2215 ucontrol->value.iec958.status[1] = sbits >> 8;
2216 ucontrol->value.iec958.status[2] = sbits >> 16;
2217 ucontrol->value.iec958.status[3] = sbits >> 24;
2221 static struct snd_kcontrol_new dig_in_ctls[] = {
2223 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2224 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2225 .info = snd_hda_spdif_in_switch_info,
2226 .get = snd_hda_spdif_in_switch_get,
2227 .put = snd_hda_spdif_in_switch_put,
2230 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2231 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2232 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2233 .info = snd_hda_spdif_mask_info,
2234 .get = snd_hda_spdif_in_status_get,
2240 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2241 * @codec: the HDA codec
2242 * @nid: audio in widget NID
2244 * Creates controls related with the SPDIF input.
2245 * Called from each patch supporting the SPDIF in.
2247 * Returns 0 if successful, or a negative error code.
2249 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2252 struct snd_kcontrol *kctl;
2253 struct snd_kcontrol_new *dig_mix;
2256 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2257 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2261 if (idx >= SPDIF_MAX_IDX) {
2262 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2265 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2266 kctl = snd_ctl_new1(dig_mix, codec);
2269 kctl->private_value = nid;
2270 err = snd_hda_ctl_add(codec, kctl);
2274 codec->spdif_in_enable =
2275 snd_hda_codec_read(codec, nid, 0,
2276 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2280 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2282 #ifdef SND_HDA_NEEDS_RESUME
2287 /* build a 32bit cache key with the widget id and the command parameter */
2288 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2289 #define get_cmd_cache_nid(key) ((key) & 0xff)
2290 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2293 * snd_hda_codec_write_cache - send a single command with caching
2294 * @codec: the HDA codec
2295 * @nid: NID to send the command
2296 * @direct: direct flag
2297 * @verb: the verb to send
2298 * @parm: the parameter for the verb
2300 * Send a single command without waiting for response.
2302 * Returns 0 if successful, or a negative error code.
2304 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2305 int direct, unsigned int verb, unsigned int parm)
2307 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2308 struct hda_cache_head *c;
2313 /* parm may contain the verb stuff for get/set amp */
2314 verb = verb | (parm >> 8);
2316 key = build_cmd_cache_key(nid, verb);
2317 mutex_lock(&codec->bus->cmd_mutex);
2318 c = get_alloc_hash(&codec->cmd_cache, key);
2321 mutex_unlock(&codec->bus->cmd_mutex);
2324 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2326 /* resume the all commands from the cache */
2327 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2329 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2332 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2333 u32 key = buffer->key;
2336 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2337 get_cmd_cache_cmd(key), buffer->val);
2340 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2343 * snd_hda_sequence_write_cache - sequence writes with caching
2344 * @codec: the HDA codec
2345 * @seq: VERB array to send
2347 * Send the commands sequentially from the given array.
2348 * Thte commands are recorded on cache for power-save and resume.
2349 * The array must be terminated with NID=0.
2351 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2352 const struct hda_verb *seq)
2354 for (; seq->nid; seq++)
2355 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2358 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2359 #endif /* SND_HDA_NEEDS_RESUME */
2362 * set power state of the codec
2364 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2365 unsigned int power_state)
2370 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2372 msleep(10); /* partial workaround for "azx_get_response timeout" */
2374 nid = codec->start_nid;
2375 for (i = 0; i < codec->num_nodes; i++, nid++) {
2376 unsigned int wcaps = get_wcaps(codec, nid);
2377 if (wcaps & AC_WCAP_POWER) {
2378 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2380 if (power_state == AC_PWRST_D3 &&
2381 wid_type == AC_WID_PIN) {
2382 unsigned int pincap;
2384 * don't power down the widget if it controls
2385 * eapd and EAPD_BTLENABLE is set.
2387 pincap = snd_hda_query_pin_caps(codec, nid);
2388 if (pincap & AC_PINCAP_EAPD) {
2389 int eapd = snd_hda_codec_read(codec,
2391 AC_VERB_GET_EAPD_BTLENABLE, 0);
2397 snd_hda_codec_write(codec, nid, 0,
2398 AC_VERB_SET_POWER_STATE,
2403 if (power_state == AC_PWRST_D0) {
2404 unsigned long end_time;
2407 /* wait until the codec reachs to D0 */
2408 end_time = jiffies + msecs_to_jiffies(500);
2410 state = snd_hda_codec_read(codec, fg, 0,
2411 AC_VERB_GET_POWER_STATE, 0);
2412 if (state == power_state)
2415 } while (time_after_eq(end_time, jiffies));
2419 #ifdef CONFIG_SND_HDA_HWDEP
2420 /* execute additional init verbs */
2421 static void hda_exec_init_verbs(struct hda_codec *codec)
2423 if (codec->init_verbs.list)
2424 snd_hda_sequence_write(codec, codec->init_verbs.list);
2427 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2430 #ifdef SND_HDA_NEEDS_RESUME
2432 * call suspend and power-down; used both from PM and power-save
2434 static void hda_call_codec_suspend(struct hda_codec *codec)
2436 if (codec->patch_ops.suspend)
2437 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2438 hda_set_power_state(codec,
2439 codec->afg ? codec->afg : codec->mfg,
2441 #ifdef CONFIG_SND_HDA_POWER_SAVE
2442 cancel_delayed_work(&codec->power_work);
2443 codec->power_on = 0;
2444 codec->power_transition = 0;
2449 * kick up codec; used both from PM and power-save
2451 static void hda_call_codec_resume(struct hda_codec *codec)
2453 hda_set_power_state(codec,
2454 codec->afg ? codec->afg : codec->mfg,
2456 restore_pincfgs(codec); /* restore all current pin configs */
2457 hda_exec_init_verbs(codec);
2458 if (codec->patch_ops.resume)
2459 codec->patch_ops.resume(codec);
2461 if (codec->patch_ops.init)
2462 codec->patch_ops.init(codec);
2463 snd_hda_codec_resume_amp(codec);
2464 snd_hda_codec_resume_cache(codec);
2467 #endif /* SND_HDA_NEEDS_RESUME */
2471 * snd_hda_build_controls - build mixer controls
2474 * Creates mixer controls for each codec included in the bus.
2476 * Returns 0 if successful, otherwise a negative error code.
2478 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2480 struct hda_codec *codec;
2482 list_for_each_entry(codec, &bus->codec_list, list) {
2483 int err = snd_hda_codec_build_controls(codec);
2485 printk(KERN_ERR "hda_codec: cannot build controls"
2486 "for #%d (error %d)\n", codec->addr, err);
2487 err = snd_hda_codec_reset(codec);
2490 "hda_codec: cannot revert codec\n");
2497 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2499 int snd_hda_codec_build_controls(struct hda_codec *codec)
2502 hda_exec_init_verbs(codec);
2503 /* continue to initialize... */
2504 if (codec->patch_ops.init)
2505 err = codec->patch_ops.init(codec);
2506 if (!err && codec->patch_ops.build_controls)
2507 err = codec->patch_ops.build_controls(codec);
2516 struct hda_rate_tbl {
2518 unsigned int alsa_bits;
2519 unsigned int hda_fmt;
2522 static struct hda_rate_tbl rate_bits[] = {
2523 /* rate in Hz, ALSA rate bitmask, HDA format value */
2525 /* autodetected value used in snd_hda_query_supported_pcm */
2526 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2527 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2528 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2529 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2530 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2531 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2532 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2533 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2534 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2535 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2536 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2537 #define AC_PAR_PCM_RATE_BITS 11
2538 /* up to bits 10, 384kHZ isn't supported properly */
2540 /* not autodetected value */
2541 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2543 { 0 } /* terminator */
2547 * snd_hda_calc_stream_format - calculate format bitset
2548 * @rate: the sample rate
2549 * @channels: the number of channels
2550 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2551 * @maxbps: the max. bps
2553 * Calculate the format bitset from the given rate, channels and th PCM format.
2555 * Return zero if invalid.
2557 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2558 unsigned int channels,
2559 unsigned int format,
2560 unsigned int maxbps)
2563 unsigned int val = 0;
2565 for (i = 0; rate_bits[i].hz; i++)
2566 if (rate_bits[i].hz == rate) {
2567 val = rate_bits[i].hda_fmt;
2570 if (!rate_bits[i].hz) {
2571 snd_printdd("invalid rate %d\n", rate);
2575 if (channels == 0 || channels > 8) {
2576 snd_printdd("invalid channels %d\n", channels);
2579 val |= channels - 1;
2581 switch (snd_pcm_format_width(format)) {
2582 case 8: val |= 0x00; break;
2583 case 16: val |= 0x10; break;
2587 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
2589 else if (maxbps >= 24)
2595 snd_printdd("invalid format width %d\n",
2596 snd_pcm_format_width(format));
2602 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2604 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2606 unsigned int val = 0;
2607 if (nid != codec->afg &&
2608 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2609 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2610 if (!val || val == -1)
2611 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2612 if (!val || val == -1)
2617 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2619 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2623 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2625 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2626 if (!streams || streams == -1)
2627 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2628 if (!streams || streams == -1)
2633 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2635 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2640 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2641 * @codec: the HDA codec
2642 * @nid: NID to query
2643 * @ratesp: the pointer to store the detected rate bitflags
2644 * @formatsp: the pointer to store the detected formats
2645 * @bpsp: the pointer to store the detected format widths
2647 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2648 * or @bsps argument is ignored.
2650 * Returns 0 if successful, otherwise a negative error code.
2652 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2653 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2655 unsigned int i, val, wcaps;
2657 wcaps = get_wcaps(codec, nid);
2658 val = query_pcm_param(codec, nid);
2662 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2664 rates |= rate_bits[i].alsa_bits;
2667 snd_printk(KERN_ERR "hda_codec: rates == 0 "
2668 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2670 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2676 if (formatsp || bpsp) {
2678 unsigned int streams, bps;
2680 streams = query_stream_param(codec, nid);
2685 if (streams & AC_SUPFMT_PCM) {
2686 if (val & AC_SUPPCM_BITS_8) {
2687 formats |= SNDRV_PCM_FMTBIT_U8;
2690 if (val & AC_SUPPCM_BITS_16) {
2691 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2694 if (wcaps & AC_WCAP_DIGITAL) {
2695 if (val & AC_SUPPCM_BITS_32)
2696 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2697 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2698 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2699 if (val & AC_SUPPCM_BITS_24)
2701 else if (val & AC_SUPPCM_BITS_20)
2703 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2704 AC_SUPPCM_BITS_32)) {
2705 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2706 if (val & AC_SUPPCM_BITS_32)
2708 else if (val & AC_SUPPCM_BITS_24)
2710 else if (val & AC_SUPPCM_BITS_20)
2714 if (streams & AC_SUPFMT_FLOAT32) {
2715 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2719 if (streams == AC_SUPFMT_AC3) {
2720 /* should be exclusive */
2721 /* temporary hack: we have still no proper support
2722 * for the direct AC3 stream...
2724 formats |= SNDRV_PCM_FMTBIT_U8;
2728 snd_printk(KERN_ERR "hda_codec: formats == 0 "
2729 "(nid=0x%x, val=0x%x, ovrd=%i, "
2732 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2737 *formatsp = formats;
2746 * snd_hda_is_supported_format - check whether the given node supports
2749 * Returns 1 if supported, 0 if not.
2751 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2752 unsigned int format)
2755 unsigned int val = 0, rate, stream;
2757 val = query_pcm_param(codec, nid);
2761 rate = format & 0xff00;
2762 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2763 if (rate_bits[i].hda_fmt == rate) {
2768 if (i >= AC_PAR_PCM_RATE_BITS)
2771 stream = query_stream_param(codec, nid);
2775 if (stream & AC_SUPFMT_PCM) {
2776 switch (format & 0xf0) {
2778 if (!(val & AC_SUPPCM_BITS_8))
2782 if (!(val & AC_SUPPCM_BITS_16))
2786 if (!(val & AC_SUPPCM_BITS_20))
2790 if (!(val & AC_SUPPCM_BITS_24))
2794 if (!(val & AC_SUPPCM_BITS_32))
2801 /* FIXME: check for float32 and AC3? */
2806 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2811 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2812 struct hda_codec *codec,
2813 struct snd_pcm_substream *substream)
2818 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2819 struct hda_codec *codec,
2820 unsigned int stream_tag,
2821 unsigned int format,
2822 struct snd_pcm_substream *substream)
2824 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2828 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2829 struct hda_codec *codec,
2830 struct snd_pcm_substream *substream)
2832 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2836 static int set_pcm_default_values(struct hda_codec *codec,
2837 struct hda_pcm_stream *info)
2841 /* query support PCM information from the given NID */
2842 if (info->nid && (!info->rates || !info->formats)) {
2843 err = snd_hda_query_supported_pcm(codec, info->nid,
2844 info->rates ? NULL : &info->rates,
2845 info->formats ? NULL : &info->formats,
2846 info->maxbps ? NULL : &info->maxbps);
2850 if (info->ops.open == NULL)
2851 info->ops.open = hda_pcm_default_open_close;
2852 if (info->ops.close == NULL)
2853 info->ops.close = hda_pcm_default_open_close;
2854 if (info->ops.prepare == NULL) {
2855 if (snd_BUG_ON(!info->nid))
2857 info->ops.prepare = hda_pcm_default_prepare;
2859 if (info->ops.cleanup == NULL) {
2860 if (snd_BUG_ON(!info->nid))
2862 info->ops.cleanup = hda_pcm_default_cleanup;
2868 * get the empty PCM device number to assign
2870 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2872 static const char *dev_name[HDA_PCM_NTYPES] = {
2873 "Audio", "SPDIF", "HDMI", "Modem"
2875 /* starting device index for each PCM type */
2876 static int dev_idx[HDA_PCM_NTYPES] = {
2877 [HDA_PCM_TYPE_AUDIO] = 0,
2878 [HDA_PCM_TYPE_SPDIF] = 1,
2879 [HDA_PCM_TYPE_HDMI] = 3,
2880 [HDA_PCM_TYPE_MODEM] = 6
2882 /* normal audio device indices; not linear to keep compatibility */
2883 static int audio_idx[4] = { 0, 2, 4, 5 };
2887 case HDA_PCM_TYPE_AUDIO:
2888 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2890 if (!test_bit(dev, bus->pcm_dev_bits))
2893 snd_printk(KERN_WARNING "Too many audio devices\n");
2895 case HDA_PCM_TYPE_SPDIF:
2896 case HDA_PCM_TYPE_HDMI:
2897 case HDA_PCM_TYPE_MODEM:
2898 dev = dev_idx[type];
2899 if (test_bit(dev, bus->pcm_dev_bits)) {
2900 snd_printk(KERN_WARNING "%s already defined\n",
2906 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2910 set_bit(dev, bus->pcm_dev_bits);
2915 * attach a new PCM stream
2917 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2919 struct hda_bus *bus = codec->bus;
2920 struct hda_pcm_stream *info;
2923 if (snd_BUG_ON(!pcm->name))
2925 for (stream = 0; stream < 2; stream++) {
2926 info = &pcm->stream[stream];
2927 if (info->substreams) {
2928 err = set_pcm_default_values(codec, info);
2933 return bus->ops.attach_pcm(bus, codec, pcm);
2936 /* assign all PCMs of the given codec */
2937 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2942 if (!codec->num_pcms) {
2943 if (!codec->patch_ops.build_pcms)
2945 err = codec->patch_ops.build_pcms(codec);
2947 printk(KERN_ERR "hda_codec: cannot build PCMs"
2948 "for #%d (error %d)\n", codec->addr, err);
2949 err = snd_hda_codec_reset(codec);
2952 "hda_codec: cannot revert codec\n");
2957 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2958 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2961 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2962 continue; /* no substreams assigned */
2965 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2967 continue; /* no fatal error */
2969 err = snd_hda_attach_pcm(codec, cpcm);
2971 printk(KERN_ERR "hda_codec: cannot attach "
2972 "PCM stream %d for codec #%d\n",
2974 continue; /* no fatal error */
2982 * snd_hda_build_pcms - build PCM information
2985 * Create PCM information for each codec included in the bus.
2987 * The build_pcms codec patch is requested to set up codec->num_pcms and
2988 * codec->pcm_info properly. The array is referred by the top-level driver
2989 * to create its PCM instances.
2990 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2993 * At least, substreams, channels_min and channels_max must be filled for
2994 * each stream. substreams = 0 indicates that the stream doesn't exist.
2995 * When rates and/or formats are zero, the supported values are queried
2996 * from the given nid. The nid is used also by the default ops.prepare
2997 * and ops.cleanup callbacks.
2999 * The driver needs to call ops.open in its open callback. Similarly,
3000 * ops.close is supposed to be called in the close callback.
3001 * ops.prepare should be called in the prepare or hw_params callback
3002 * with the proper parameters for set up.
3003 * ops.cleanup should be called in hw_free for clean up of streams.
3005 * This function returns 0 if successfull, or a negative error code.
3007 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
3009 struct hda_codec *codec;
3011 list_for_each_entry(codec, &bus->codec_list, list) {
3012 int err = snd_hda_codec_build_pcms(codec);
3018 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
3021 * snd_hda_check_board_config - compare the current codec with the config table
3022 * @codec: the HDA codec
3023 * @num_configs: number of config enums
3024 * @models: array of model name strings
3025 * @tbl: configuration table, terminated by null entries
3027 * Compares the modelname or PCI subsystem id of the current codec with the
3028 * given configuration table. If a matching entry is found, returns its
3029 * config value (supposed to be 0 or positive).
3031 * If no entries are matching, the function returns a negative value.
3033 int snd_hda_check_board_config(struct hda_codec *codec,
3034 int num_configs, const char **models,
3035 const struct snd_pci_quirk *tbl)
3037 if (codec->modelname && models) {
3039 for (i = 0; i < num_configs; i++) {
3041 !strcmp(codec->modelname, models[i])) {
3042 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3043 "selected\n", models[i]);
3049 if (!codec->bus->pci || !tbl)
3052 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3055 if (tbl->value >= 0 && tbl->value < num_configs) {
3056 #ifdef CONFIG_SND_DEBUG_VERBOSE
3058 const char *model = NULL;
3060 model = models[tbl->value];
3062 sprintf(tmp, "#%d", tbl->value);
3065 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3066 "for config %x:%x (%s)\n",
3067 model, tbl->subvendor, tbl->subdevice,
3068 (tbl->name ? tbl->name : "Unknown device"));
3074 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3077 * snd_hda_check_board_codec_sid_config - compare the current codec
3078 subsystem ID with the
3081 This is important for Gateway notebooks with SB450 HDA Audio
3082 where the vendor ID of the PCI device is:
3083 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3084 and the vendor/subvendor are found only at the codec.
3086 * @codec: the HDA codec
3087 * @num_configs: number of config enums
3088 * @models: array of model name strings
3089 * @tbl: configuration table, terminated by null entries
3091 * Compares the modelname or PCI subsystem id of the current codec with the
3092 * given configuration table. If a matching entry is found, returns its
3093 * config value (supposed to be 0 or positive).
3095 * If no entries are matching, the function returns a negative value.
3097 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3098 int num_configs, const char **models,
3099 const struct snd_pci_quirk *tbl)
3101 const struct snd_pci_quirk *q;
3103 /* Search for codec ID */
3104 for (q = tbl; q->subvendor; q++) {
3105 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3107 if (vendorid == codec->subsystem_id)
3116 if (tbl->value >= 0 && tbl->value < num_configs) {
3117 #ifdef CONFIG_SND_DEBUG_DETECT
3119 const char *model = NULL;
3121 model = models[tbl->value];
3123 sprintf(tmp, "#%d", tbl->value);
3126 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3127 "for config %x:%x (%s)\n",
3128 model, tbl->subvendor, tbl->subdevice,
3129 (tbl->name ? tbl->name : "Unknown device"));
3135 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3138 * snd_hda_add_new_ctls - create controls from the array
3139 * @codec: the HDA codec
3140 * @knew: the array of struct snd_kcontrol_new
3142 * This helper function creates and add new controls in the given array.
3143 * The array must be terminated with an empty entry as terminator.
3145 * Returns 0 if successful, or a negative error code.
3147 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3151 for (; knew->name; knew++) {
3152 struct snd_kcontrol *kctl;
3153 kctl = snd_ctl_new1(knew, codec);
3156 err = snd_hda_ctl_add(codec, kctl);
3160 kctl = snd_ctl_new1(knew, codec);
3163 kctl->id.device = codec->addr;
3164 err = snd_hda_ctl_add(codec, kctl);
3171 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3173 #ifdef CONFIG_SND_HDA_POWER_SAVE
3174 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3175 unsigned int power_state);
3177 static void hda_power_work(struct work_struct *work)
3179 struct hda_codec *codec =
3180 container_of(work, struct hda_codec, power_work.work);
3181 struct hda_bus *bus = codec->bus;
3183 if (!codec->power_on || codec->power_count) {
3184 codec->power_transition = 0;
3188 hda_call_codec_suspend(codec);
3189 if (bus->ops.pm_notify)
3190 bus->ops.pm_notify(bus);
3193 static void hda_keep_power_on(struct hda_codec *codec)
3195 codec->power_count++;
3196 codec->power_on = 1;
3199 void snd_hda_power_up(struct hda_codec *codec)
3201 struct hda_bus *bus = codec->bus;
3203 codec->power_count++;
3204 if (codec->power_on || codec->power_transition)
3207 codec->power_on = 1;
3208 if (bus->ops.pm_notify)
3209 bus->ops.pm_notify(bus);
3210 hda_call_codec_resume(codec);
3211 cancel_delayed_work(&codec->power_work);
3212 codec->power_transition = 0;
3214 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3216 #define power_save(codec) \
3217 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3219 #define power_save(codec) \
3220 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3222 void snd_hda_power_down(struct hda_codec *codec)
3224 --codec->power_count;
3225 if (!codec->power_on || codec->power_count || codec->power_transition)
3227 if (power_save(codec)) {
3228 codec->power_transition = 1; /* avoid reentrance */
3229 queue_delayed_work(codec->bus->workq, &codec->power_work,
3230 msecs_to_jiffies(power_save(codec) * 1000));
3233 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3235 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3236 struct hda_loopback_check *check,
3239 struct hda_amp_list *p;
3242 if (!check->amplist)
3244 for (p = check->amplist; p->nid; p++) {
3249 return 0; /* nothing changed */
3251 for (p = check->amplist; p->nid; p++) {
3252 for (ch = 0; ch < 2; ch++) {
3253 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3255 if (!(v & HDA_AMP_MUTE) && v > 0) {
3256 if (!check->power_on) {
3257 check->power_on = 1;
3258 snd_hda_power_up(codec);
3264 if (check->power_on) {
3265 check->power_on = 0;
3266 snd_hda_power_down(codec);
3270 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3274 * Channel mode helper
3276 int snd_hda_ch_mode_info(struct hda_codec *codec,
3277 struct snd_ctl_elem_info *uinfo,
3278 const struct hda_channel_mode *chmode,
3281 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3283 uinfo->value.enumerated.items = num_chmodes;
3284 if (uinfo->value.enumerated.item >= num_chmodes)
3285 uinfo->value.enumerated.item = num_chmodes - 1;
3286 sprintf(uinfo->value.enumerated.name, "%dch",
3287 chmode[uinfo->value.enumerated.item].channels);
3290 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3292 int snd_hda_ch_mode_get(struct hda_codec *codec,
3293 struct snd_ctl_elem_value *ucontrol,
3294 const struct hda_channel_mode *chmode,
3300 for (i = 0; i < num_chmodes; i++) {
3301 if (max_channels == chmode[i].channels) {
3302 ucontrol->value.enumerated.item[0] = i;
3308 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3310 int snd_hda_ch_mode_put(struct hda_codec *codec,
3311 struct snd_ctl_elem_value *ucontrol,
3312 const struct hda_channel_mode *chmode,
3318 mode = ucontrol->value.enumerated.item[0];
3319 if (mode >= num_chmodes)
3321 if (*max_channelsp == chmode[mode].channels)
3323 /* change the current channel setting */
3324 *max_channelsp = chmode[mode].channels;
3325 if (chmode[mode].sequence)
3326 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3329 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3334 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3335 struct snd_ctl_elem_info *uinfo)
3339 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3341 uinfo->value.enumerated.items = imux->num_items;
3342 if (!imux->num_items)
3344 index = uinfo->value.enumerated.item;
3345 if (index >= imux->num_items)
3346 index = imux->num_items - 1;
3347 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3350 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3352 int snd_hda_input_mux_put(struct hda_codec *codec,
3353 const struct hda_input_mux *imux,
3354 struct snd_ctl_elem_value *ucontrol,
3356 unsigned int *cur_val)
3360 if (!imux->num_items)
3362 idx = ucontrol->value.enumerated.item[0];
3363 if (idx >= imux->num_items)
3364 idx = imux->num_items - 1;
3365 if (*cur_val == idx)
3367 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3368 imux->items[idx].index);
3372 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3376 * Multi-channel / digital-out PCM helper functions
3379 /* setup SPDIF output stream */
3380 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3381 unsigned int stream_tag, unsigned int format)
3383 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3384 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3385 set_dig_out_convert(codec, nid,
3386 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3388 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3389 if (codec->slave_dig_outs) {
3391 for (d = codec->slave_dig_outs; *d; d++)
3392 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3395 /* turn on again (if needed) */
3396 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3397 set_dig_out_convert(codec, nid,
3398 codec->spdif_ctls & 0xff, -1);
3401 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3403 snd_hda_codec_cleanup_stream(codec, nid);
3404 if (codec->slave_dig_outs) {
3406 for (d = codec->slave_dig_outs; *d; d++)
3407 snd_hda_codec_cleanup_stream(codec, *d);
3412 * open the digital out in the exclusive mode
3414 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3415 struct hda_multi_out *mout)
3417 mutex_lock(&codec->spdif_mutex);
3418 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3419 /* already opened as analog dup; reset it once */
3420 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3421 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3422 mutex_unlock(&codec->spdif_mutex);
3425 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3427 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3428 struct hda_multi_out *mout,
3429 unsigned int stream_tag,
3430 unsigned int format,
3431 struct snd_pcm_substream *substream)
3433 mutex_lock(&codec->spdif_mutex);
3434 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3435 mutex_unlock(&codec->spdif_mutex);
3438 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3440 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3441 struct hda_multi_out *mout)
3443 mutex_lock(&codec->spdif_mutex);
3444 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3445 mutex_unlock(&codec->spdif_mutex);
3448 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3451 * release the digital out
3453 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3454 struct hda_multi_out *mout)
3456 mutex_lock(&codec->spdif_mutex);
3457 mout->dig_out_used = 0;
3458 mutex_unlock(&codec->spdif_mutex);
3461 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3464 * set up more restrictions for analog out
3466 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3467 struct hda_multi_out *mout,
3468 struct snd_pcm_substream *substream,
3469 struct hda_pcm_stream *hinfo)
3471 struct snd_pcm_runtime *runtime = substream->runtime;
3472 runtime->hw.channels_max = mout->max_channels;
3473 if (mout->dig_out_nid) {
3474 if (!mout->analog_rates) {
3475 mout->analog_rates = hinfo->rates;
3476 mout->analog_formats = hinfo->formats;
3477 mout->analog_maxbps = hinfo->maxbps;
3479 runtime->hw.rates = mout->analog_rates;
3480 runtime->hw.formats = mout->analog_formats;
3481 hinfo->maxbps = mout->analog_maxbps;
3483 if (!mout->spdif_rates) {
3484 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3486 &mout->spdif_formats,
3487 &mout->spdif_maxbps);
3489 mutex_lock(&codec->spdif_mutex);
3490 if (mout->share_spdif) {
3491 if ((runtime->hw.rates & mout->spdif_rates) &&
3492 (runtime->hw.formats & mout->spdif_formats)) {
3493 runtime->hw.rates &= mout->spdif_rates;
3494 runtime->hw.formats &= mout->spdif_formats;
3495 if (mout->spdif_maxbps < hinfo->maxbps)
3496 hinfo->maxbps = mout->spdif_maxbps;
3498 mout->share_spdif = 0;
3499 /* FIXME: need notify? */
3502 mutex_unlock(&codec->spdif_mutex);
3504 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3505 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3507 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3510 * set up the i/o for analog out
3511 * when the digital out is available, copy the front out to digital out, too.
3513 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3514 struct hda_multi_out *mout,
3515 unsigned int stream_tag,
3516 unsigned int format,
3517 struct snd_pcm_substream *substream)
3519 hda_nid_t *nids = mout->dac_nids;
3520 int chs = substream->runtime->channels;
3523 mutex_lock(&codec->spdif_mutex);
3524 if (mout->dig_out_nid && mout->share_spdif &&
3525 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3527 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3529 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3530 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3531 setup_dig_out_stream(codec, mout->dig_out_nid,
3532 stream_tag, format);
3534 mout->dig_out_used = 0;
3535 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3538 mutex_unlock(&codec->spdif_mutex);
3541 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3543 if (!mout->no_share_stream &&
3544 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3545 /* headphone out will just decode front left/right (stereo) */
3546 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3548 /* extra outputs copied from front */
3549 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3550 if (!mout->no_share_stream && mout->extra_out_nid[i])
3551 snd_hda_codec_setup_stream(codec,
3552 mout->extra_out_nid[i],
3553 stream_tag, 0, format);
3556 for (i = 1; i < mout->num_dacs; i++) {
3557 if (chs >= (i + 1) * 2) /* independent out */
3558 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3560 else if (!mout->no_share_stream) /* copy front */
3561 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3566 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3569 * clean up the setting for analog out
3571 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3572 struct hda_multi_out *mout)
3574 hda_nid_t *nids = mout->dac_nids;
3577 for (i = 0; i < mout->num_dacs; i++)
3578 snd_hda_codec_cleanup_stream(codec, nids[i]);
3580 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3581 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3582 if (mout->extra_out_nid[i])
3583 snd_hda_codec_cleanup_stream(codec,
3584 mout->extra_out_nid[i]);
3585 mutex_lock(&codec->spdif_mutex);
3586 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3587 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3588 mout->dig_out_used = 0;
3590 mutex_unlock(&codec->spdif_mutex);
3593 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3596 * Helper for automatic pin configuration
3599 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3601 for (; *list; list++)
3609 * Sort an associated group of pins according to their sequence numbers.
3611 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3618 for (i = 0; i < num_pins; i++) {
3619 for (j = i + 1; j < num_pins; j++) {
3620 if (sequences[i] > sequences[j]) {
3622 sequences[i] = sequences[j];
3634 * Parse all pin widgets and store the useful pin nids to cfg
3636 * The number of line-outs or any primary output is stored in line_outs,
3637 * and the corresponding output pins are assigned to line_out_pins[],
3638 * in the order of front, rear, CLFE, side, ...
3640 * If more extra outputs (speaker and headphone) are found, the pins are
3641 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3642 * is detected, one of speaker of HP pins is assigned as the primary
3643 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3644 * if any analog output exists.
3646 * The analog input pins are assigned to input_pins array.
3647 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3650 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3651 struct auto_pin_cfg *cfg,
3652 hda_nid_t *ignore_nids)
3654 hda_nid_t nid, end_nid;
3655 short seq, assoc_line_out, assoc_speaker;
3656 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3657 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3658 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3660 memset(cfg, 0, sizeof(*cfg));
3662 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3663 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3664 memset(sequences_hp, 0, sizeof(sequences_hp));
3665 assoc_line_out = assoc_speaker = 0;
3667 end_nid = codec->start_nid + codec->num_nodes;
3668 for (nid = codec->start_nid; nid < end_nid; nid++) {
3669 unsigned int wid_caps = get_wcaps(codec, nid);
3670 unsigned int wid_type =
3671 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3672 unsigned int def_conf;
3675 /* read all default configuration for pin complex */
3676 if (wid_type != AC_WID_PIN)
3678 /* ignore the given nids (e.g. pc-beep returns error) */
3679 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3682 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3683 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3685 loc = get_defcfg_location(def_conf);
3686 switch (get_defcfg_device(def_conf)) {
3687 case AC_JACK_LINE_OUT:
3688 seq = get_defcfg_sequence(def_conf);
3689 assoc = get_defcfg_association(def_conf);
3691 if (!(wid_caps & AC_WCAP_STEREO))
3692 if (!cfg->mono_out_pin)
3693 cfg->mono_out_pin = nid;
3696 if (!assoc_line_out)
3697 assoc_line_out = assoc;
3698 else if (assoc_line_out != assoc)
3700 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3702 cfg->line_out_pins[cfg->line_outs] = nid;
3703 sequences_line_out[cfg->line_outs] = seq;
3706 case AC_JACK_SPEAKER:
3707 seq = get_defcfg_sequence(def_conf);
3708 assoc = get_defcfg_association(def_conf);
3711 if (! assoc_speaker)
3712 assoc_speaker = assoc;
3713 else if (assoc_speaker != assoc)
3715 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3717 cfg->speaker_pins[cfg->speaker_outs] = nid;
3718 sequences_speaker[cfg->speaker_outs] = seq;
3719 cfg->speaker_outs++;
3721 case AC_JACK_HP_OUT:
3722 seq = get_defcfg_sequence(def_conf);
3723 assoc = get_defcfg_association(def_conf);
3724 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3726 cfg->hp_pins[cfg->hp_outs] = nid;
3727 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3730 case AC_JACK_MIC_IN: {
3732 if (loc == AC_JACK_LOC_FRONT) {
3733 preferred = AUTO_PIN_FRONT_MIC;
3736 preferred = AUTO_PIN_MIC;
3737 alt = AUTO_PIN_FRONT_MIC;
3739 if (!cfg->input_pins[preferred])
3740 cfg->input_pins[preferred] = nid;
3741 else if (!cfg->input_pins[alt])
3742 cfg->input_pins[alt] = nid;
3745 case AC_JACK_LINE_IN:
3746 if (loc == AC_JACK_LOC_FRONT)
3747 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3749 cfg->input_pins[AUTO_PIN_LINE] = nid;
3752 cfg->input_pins[AUTO_PIN_CD] = nid;
3755 cfg->input_pins[AUTO_PIN_AUX] = nid;
3757 case AC_JACK_SPDIF_OUT:
3758 case AC_JACK_DIG_OTHER_OUT:
3759 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3761 cfg->dig_out_pins[cfg->dig_outs] = nid;
3762 cfg->dig_out_type[cfg->dig_outs] =
3763 (loc == AC_JACK_LOC_HDMI) ?
3764 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3767 case AC_JACK_SPDIF_IN:
3768 case AC_JACK_DIG_OTHER_IN:
3769 cfg->dig_in_pin = nid;
3770 if (loc == AC_JACK_LOC_HDMI)
3771 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3773 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
3779 * If no line-out is defined but multiple HPs are found,
3780 * some of them might be the real line-outs.
3782 if (!cfg->line_outs && cfg->hp_outs > 1) {
3784 while (i < cfg->hp_outs) {
3785 /* The real HPs should have the sequence 0x0f */
3786 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3790 /* Move it to the line-out table */
3791 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3792 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3795 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3796 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3797 memmove(sequences_hp + i - 1, sequences_hp + i,
3798 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3802 /* sort by sequence */
3803 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3805 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3807 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3810 /* if we have only one mic, make it AUTO_PIN_MIC */
3811 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3812 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3813 cfg->input_pins[AUTO_PIN_MIC] =
3814 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3815 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3817 /* ditto for line-in */
3818 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3819 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3820 cfg->input_pins[AUTO_PIN_LINE] =
3821 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3822 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3826 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3827 * as a primary output
3829 if (!cfg->line_outs) {
3830 if (cfg->speaker_outs) {
3831 cfg->line_outs = cfg->speaker_outs;
3832 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3833 sizeof(cfg->speaker_pins));
3834 cfg->speaker_outs = 0;
3835 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3836 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3837 } else if (cfg->hp_outs) {
3838 cfg->line_outs = cfg->hp_outs;
3839 memcpy(cfg->line_out_pins, cfg->hp_pins,
3840 sizeof(cfg->hp_pins));
3842 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3843 cfg->line_out_type = AUTO_PIN_HP_OUT;
3847 /* Reorder the surround channels
3848 * ALSA sequence is front/surr/clfe/side
3850 * 4-ch: front/surr => OK as it is
3851 * 6-ch: front/clfe/surr
3852 * 8-ch: front/clfe/rear/side|fc
3854 switch (cfg->line_outs) {
3857 nid = cfg->line_out_pins[1];
3858 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3859 cfg->line_out_pins[2] = nid;
3864 * debug prints of the parsed results
3866 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3867 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3868 cfg->line_out_pins[2], cfg->line_out_pins[3],
3869 cfg->line_out_pins[4]);
3870 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3871 cfg->speaker_outs, cfg->speaker_pins[0],
3872 cfg->speaker_pins[1], cfg->speaker_pins[2],
3873 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3874 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3875 cfg->hp_outs, cfg->hp_pins[0],
3876 cfg->hp_pins[1], cfg->hp_pins[2],
3877 cfg->hp_pins[3], cfg->hp_pins[4]);
3878 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3880 snd_printd(" dig-out=0x%x/0x%x\n",
3881 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
3882 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3883 " cd=0x%x, aux=0x%x\n",
3884 cfg->input_pins[AUTO_PIN_MIC],
3885 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3886 cfg->input_pins[AUTO_PIN_LINE],
3887 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3888 cfg->input_pins[AUTO_PIN_CD],
3889 cfg->input_pins[AUTO_PIN_AUX]);
3890 if (cfg->dig_in_pin)
3891 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
3895 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3897 /* labels for input pins */
3898 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3899 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3901 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3910 * snd_hda_suspend - suspend the codecs
3913 * Returns 0 if successful.
3915 int snd_hda_suspend(struct hda_bus *bus)
3917 struct hda_codec *codec;
3919 list_for_each_entry(codec, &bus->codec_list, list) {
3920 #ifdef CONFIG_SND_HDA_POWER_SAVE
3921 if (!codec->power_on)
3924 hda_call_codec_suspend(codec);
3928 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3931 * snd_hda_resume - resume the codecs
3934 * Returns 0 if successful.
3936 * This fucntion is defined only when POWER_SAVE isn't set.
3937 * In the power-save mode, the codec is resumed dynamically.
3939 int snd_hda_resume(struct hda_bus *bus)
3941 struct hda_codec *codec;
3943 list_for_each_entry(codec, &bus->codec_list, list) {
3944 if (snd_hda_codec_needs_resume(codec))
3945 hda_call_codec_resume(codec);
3949 EXPORT_SYMBOL_HDA(snd_hda_resume);
3950 #endif /* CONFIG_PM */
3956 /* get a new element from the given array
3957 * if it exceeds the pre-allocated array size, re-allocate the array
3959 void *snd_array_new(struct snd_array *array)
3961 if (array->used >= array->alloced) {
3962 int num = array->alloced + array->alloc_align;
3964 if (snd_BUG_ON(num >= 4096))
3966 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3970 memcpy(nlist, array->list,
3971 array->elem_size * array->alloced);
3974 array->list = nlist;
3975 array->alloced = num;
3977 return snd_array_elem(array, array->used++);
3979 EXPORT_SYMBOL_HDA(snd_array_new);
3981 /* free the given array elements */
3982 void snd_array_free(struct snd_array *array)
3989 EXPORT_SYMBOL_HDA(snd_array_free);
3992 * used by hda_proc.c and hda_eld.c
3994 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3996 static unsigned int rates[] = {
3997 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3998 96000, 176400, 192000, 384000
4002 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
4004 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
4006 buf[j] = '\0'; /* necessary when j == 0 */
4008 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
4010 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4012 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
4015 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4016 if (pcm & (AC_SUPPCM_BITS_8 << i))
4017 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
4019 buf[j] = '\0'; /* necessary when j == 0 */
4021 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
4023 MODULE_DESCRIPTION("HDA codec core");
4024 MODULE_LICENSE("GPL");