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" },
54 { 0x11d4, "Analog Devices" },
55 { 0x13f6, "C-Media" },
56 { 0x14f1, "Conexant" },
57 { 0x17e8, "Chrontel" },
59 { 0x1aec, "Wolfson Microelectronics" },
60 { 0x434d, "C-Media" },
62 { 0x8384, "SigmaTel" },
66 static DEFINE_MUTEX(preset_mutex);
67 static LIST_HEAD(hda_preset_tables);
69 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
71 mutex_lock(&preset_mutex);
72 list_add_tail(&preset->list, &hda_preset_tables);
73 mutex_unlock(&preset_mutex);
76 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
78 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
80 mutex_lock(&preset_mutex);
81 list_del(&preset->list);
82 mutex_unlock(&preset_mutex);
85 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
87 #ifdef CONFIG_SND_HDA_POWER_SAVE
88 static void hda_power_work(struct work_struct *work);
89 static void hda_keep_power_on(struct hda_codec *codec);
91 static inline void hda_keep_power_on(struct hda_codec *codec) {}
94 const char *snd_hda_get_jack_location(u32 cfg)
96 static char *bases[7] = {
97 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
99 static unsigned char specials_idx[] = {
104 static char *specials[] = {
105 "Rear Panel", "Drive Bar",
106 "Riser", "HDMI", "ATAPI",
107 "Mobile-In", "Mobile-Out"
110 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
111 if ((cfg & 0x0f) < 7)
112 return bases[cfg & 0x0f];
113 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
114 if (cfg == specials_idx[i])
119 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
121 const char *snd_hda_get_jack_connectivity(u32 cfg)
123 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
125 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
127 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
129 const char *snd_hda_get_jack_type(u32 cfg)
131 static char *jack_types[16] = {
132 "Line Out", "Speaker", "HP Out", "CD",
133 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
134 "Line In", "Aux", "Mic", "Telephony",
135 "SPDIF In", "Digitial In", "Reserved", "Other"
138 return jack_types[(cfg & AC_DEFCFG_DEVICE)
139 >> AC_DEFCFG_DEVICE_SHIFT];
141 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
144 * Compose a 32bit command word to be sent to the HD-audio controller
146 static inline unsigned int
147 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
148 unsigned int verb, unsigned int parm)
152 val = (u32)(codec->addr & 0x0f) << 28;
153 val |= (u32)direct << 27;
154 val |= (u32)nid << 20;
161 * snd_hda_codec_read - send a command and get the response
162 * @codec: the HDA codec
163 * @nid: NID to send the command
164 * @direct: direct flag
165 * @verb: the verb to send
166 * @parm: the parameter for the verb
168 * Send a single command and read the corresponding response.
170 * Returns the obtained response value, or -1 for an error.
172 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
174 unsigned int verb, unsigned int parm)
176 struct hda_bus *bus = codec->bus;
179 res = make_codec_cmd(codec, nid, direct, verb, parm);
180 snd_hda_power_up(codec);
181 mutex_lock(&bus->cmd_mutex);
182 if (!bus->ops.command(bus, res))
183 res = bus->ops.get_response(bus);
185 res = (unsigned int)-1;
186 mutex_unlock(&bus->cmd_mutex);
187 snd_hda_power_down(codec);
190 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
193 * snd_hda_codec_write - send a single command without waiting for response
194 * @codec: the HDA codec
195 * @nid: NID to send the command
196 * @direct: direct flag
197 * @verb: the verb to send
198 * @parm: the parameter for the verb
200 * Send a single command without waiting for response.
202 * Returns 0 if successful, or a negative error code.
204 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
205 unsigned int verb, unsigned int parm)
207 struct hda_bus *bus = codec->bus;
211 res = make_codec_cmd(codec, nid, direct, verb, parm);
212 snd_hda_power_up(codec);
213 mutex_lock(&bus->cmd_mutex);
214 err = bus->ops.command(bus, res);
215 mutex_unlock(&bus->cmd_mutex);
216 snd_hda_power_down(codec);
219 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
222 * snd_hda_sequence_write - sequence writes
223 * @codec: the HDA codec
224 * @seq: VERB array to send
226 * Send the commands sequentially from the given array.
227 * The array must be terminated with NID=0.
229 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
231 for (; seq->nid; seq++)
232 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
234 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
237 * snd_hda_get_sub_nodes - get the range of sub nodes
238 * @codec: the HDA codec
240 * @start_id: the pointer to store the start NID
242 * Parse the NID and store the start NID of its sub-nodes.
243 * Returns the number of sub-nodes.
245 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
250 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
253 *start_id = (parm >> 16) & 0x7fff;
254 return (int)(parm & 0x7fff);
256 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
259 * snd_hda_get_connections - get connection list
260 * @codec: the HDA codec
262 * @conn_list: connection list array
263 * @max_conns: max. number of connections to store
265 * Parses the connection list of the given widget and stores the list
268 * Returns the number of connections, or a negative error code.
270 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
271 hda_nid_t *conn_list, int max_conns)
274 int i, conn_len, conns;
275 unsigned int shift, num_elems, mask;
278 if (snd_BUG_ON(!conn_list || max_conns <= 0))
281 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
282 if (parm & AC_CLIST_LONG) {
291 conn_len = parm & AC_CLIST_LENGTH;
292 mask = (1 << (shift-1)) - 1;
295 return 0; /* no connection */
298 /* single connection */
299 parm = snd_hda_codec_read(codec, nid, 0,
300 AC_VERB_GET_CONNECT_LIST, 0);
301 conn_list[0] = parm & mask;
305 /* multi connection */
308 for (i = 0; i < conn_len; i++) {
312 if (i % num_elems == 0)
313 parm = snd_hda_codec_read(codec, nid, 0,
314 AC_VERB_GET_CONNECT_LIST, i);
315 range_val = !!(parm & (1 << (shift-1))); /* ranges */
319 /* ranges between the previous and this one */
320 if (!prev_nid || prev_nid >= val) {
321 snd_printk(KERN_WARNING "hda_codec: "
322 "invalid dep_range_val %x:%x\n",
326 for (n = prev_nid + 1; n <= val; n++) {
327 if (conns >= max_conns) {
329 "Too many connections\n");
332 conn_list[conns++] = n;
335 if (conns >= max_conns) {
336 snd_printk(KERN_ERR "Too many connections\n");
339 conn_list[conns++] = val;
345 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
349 * snd_hda_queue_unsol_event - add an unsolicited event to queue
351 * @res: unsolicited event (lower 32bit of RIRB entry)
352 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
354 * Adds the given event to the queue. The events are processed in
355 * the workqueue asynchronously. Call this function in the interrupt
356 * hanlder when RIRB receives an unsolicited event.
358 * Returns 0 if successful, or a negative error code.
360 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
362 struct hda_bus_unsolicited *unsol;
369 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
373 unsol->queue[wp] = res;
374 unsol->queue[wp + 1] = res_ex;
376 queue_work(bus->workq, &unsol->work);
380 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
383 * process queued unsolicited events
385 static void process_unsol_events(struct work_struct *work)
387 struct hda_bus_unsolicited *unsol =
388 container_of(work, struct hda_bus_unsolicited, work);
389 struct hda_bus *bus = unsol->bus;
390 struct hda_codec *codec;
391 unsigned int rp, caddr, res;
393 while (unsol->rp != unsol->wp) {
394 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
397 res = unsol->queue[rp];
398 caddr = unsol->queue[rp + 1];
399 if (!(caddr & (1 << 4))) /* no unsolicited event? */
401 codec = bus->caddr_tbl[caddr & 0x0f];
402 if (codec && codec->patch_ops.unsol_event)
403 codec->patch_ops.unsol_event(codec, res);
408 * initialize unsolicited queue
410 static int init_unsol_queue(struct hda_bus *bus)
412 struct hda_bus_unsolicited *unsol;
414 if (bus->unsol) /* already initialized */
417 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
419 snd_printk(KERN_ERR "hda_codec: "
420 "can't allocate unsolicited queue\n");
423 INIT_WORK(&unsol->work, process_unsol_events);
432 static void snd_hda_codec_free(struct hda_codec *codec);
434 static int snd_hda_bus_free(struct hda_bus *bus)
436 struct hda_codec *codec, *n;
441 flush_workqueue(bus->workq);
444 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
445 snd_hda_codec_free(codec);
447 if (bus->ops.private_free)
448 bus->ops.private_free(bus);
450 destroy_workqueue(bus->workq);
455 static int snd_hda_bus_dev_free(struct snd_device *device)
457 struct hda_bus *bus = device->device_data;
459 return snd_hda_bus_free(bus);
462 #ifdef CONFIG_SND_HDA_HWDEP
463 static int snd_hda_bus_dev_register(struct snd_device *device)
465 struct hda_bus *bus = device->device_data;
466 struct hda_codec *codec;
467 list_for_each_entry(codec, &bus->codec_list, list) {
468 snd_hda_hwdep_add_sysfs(codec);
473 #define snd_hda_bus_dev_register NULL
477 * snd_hda_bus_new - create a HDA bus
478 * @card: the card entry
479 * @temp: the template for hda_bus information
480 * @busp: the pointer to store the created bus instance
482 * Returns 0 if successful, or a negative error code.
484 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
485 const struct hda_bus_template *temp,
486 struct hda_bus **busp)
490 static struct snd_device_ops dev_ops = {
491 .dev_register = snd_hda_bus_dev_register,
492 .dev_free = snd_hda_bus_dev_free,
495 if (snd_BUG_ON(!temp))
497 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
503 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
505 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
510 bus->private_data = temp->private_data;
511 bus->pci = temp->pci;
512 bus->modelname = temp->modelname;
513 bus->power_save = temp->power_save;
514 bus->ops = temp->ops;
516 mutex_init(&bus->cmd_mutex);
517 INIT_LIST_HEAD(&bus->codec_list);
519 snprintf(bus->workq_name, sizeof(bus->workq_name),
520 "hd-audio%d", card->number);
521 bus->workq = create_singlethread_workqueue(bus->workq_name);
523 snd_printk(KERN_ERR "cannot create workqueue %s\n",
529 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
531 snd_hda_bus_free(bus);
538 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
540 #ifdef CONFIG_SND_HDA_GENERIC
541 #define is_generic_config(codec) \
542 (codec->modelname && !strcmp(codec->modelname, "generic"))
544 #define is_generic_config(codec) 0
548 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
550 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
554 * find a matching codec preset
556 static const struct hda_codec_preset *
557 find_codec_preset(struct hda_codec *codec)
559 struct hda_codec_preset_list *tbl;
560 const struct hda_codec_preset *preset;
561 int mod_requested = 0;
563 if (is_generic_config(codec))
564 return NULL; /* use the generic parser */
567 mutex_lock(&preset_mutex);
568 list_for_each_entry(tbl, &hda_preset_tables, list) {
569 if (!try_module_get(tbl->owner)) {
570 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
573 for (preset = tbl->preset; preset->id; preset++) {
574 u32 mask = preset->mask;
575 if (preset->afg && preset->afg != codec->afg)
577 if (preset->mfg && preset->mfg != codec->mfg)
581 if (preset->id == (codec->vendor_id & mask) &&
583 preset->rev == codec->revision_id)) {
584 mutex_unlock(&preset_mutex);
585 codec->owner = tbl->owner;
589 module_put(tbl->owner);
591 mutex_unlock(&preset_mutex);
593 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
596 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
599 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
600 (codec->vendor_id >> 16) & 0xffff);
601 request_module(name);
609 * get_codec_name - store the codec name
611 static int get_codec_name(struct hda_codec *codec)
613 const struct hda_vendor_id *c;
614 const char *vendor = NULL;
615 u16 vendor_id = codec->vendor_id >> 16;
616 char tmp[16], name[32];
618 for (c = hda_vendor_ids; c->id; c++) {
619 if (c->id == vendor_id) {
625 sprintf(tmp, "Generic %04x", vendor_id);
628 if (codec->preset && codec->preset->name)
629 snprintf(name, sizeof(name), "%s %s", vendor,
630 codec->preset->name);
632 snprintf(name, sizeof(name), "%s ID %x", vendor,
633 codec->vendor_id & 0xffff);
634 codec->name = kstrdup(name, GFP_KERNEL);
641 * look for an AFG and MFG nodes
643 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
648 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
649 for (i = 0; i < total_nodes; i++, nid++) {
651 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
652 switch (func & 0xff) {
653 case AC_GRP_AUDIO_FUNCTION:
656 case AC_GRP_MODEM_FUNCTION:
666 * read widget caps for each widget and store in cache
668 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
673 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
675 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
678 nid = codec->start_nid;
679 for (i = 0; i < codec->num_nodes; i++, nid++)
680 codec->wcaps[i] = snd_hda_param_read(codec, nid,
681 AC_PAR_AUDIO_WIDGET_CAP);
685 /* read all pin default configurations and save codec->init_pins */
686 static int read_pin_defaults(struct hda_codec *codec)
689 hda_nid_t nid = codec->start_nid;
691 for (i = 0; i < codec->num_nodes; i++, nid++) {
692 struct hda_pincfg *pin;
693 unsigned int wcaps = get_wcaps(codec, nid);
694 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
696 if (wid_type != AC_WID_PIN)
698 pin = snd_array_new(&codec->init_pins);
702 pin->cfg = snd_hda_codec_read(codec, nid, 0,
703 AC_VERB_GET_CONFIG_DEFAULT, 0);
708 /* look up the given pin config list and return the item matching with NID */
709 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
710 struct snd_array *array,
714 for (i = 0; i < array->used; i++) {
715 struct hda_pincfg *pin = snd_array_elem(array, i);
722 /* write a config value for the given NID */
723 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
727 for (i = 0; i < 4; i++) {
728 snd_hda_codec_write(codec, nid, 0,
729 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
735 /* set the current pin config value for the given NID.
736 * the value is cached, and read via snd_hda_codec_get_pincfg()
738 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
739 hda_nid_t nid, unsigned int cfg)
741 struct hda_pincfg *pin;
743 pin = look_up_pincfg(codec, list, nid);
745 pin = snd_array_new(list);
751 set_pincfg(codec, nid, cfg);
755 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
756 hda_nid_t nid, unsigned int cfg)
758 return snd_hda_add_pincfg(codec, &codec->cur_pins, nid, cfg);
760 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
762 /* get the current pin config value of the given pin NID */
763 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
765 struct hda_pincfg *pin;
767 pin = look_up_pincfg(codec, &codec->cur_pins, nid);
770 #ifdef CONFIG_SND_HDA_HWDEP
771 pin = look_up_pincfg(codec, &codec->override_pins, nid);
775 pin = look_up_pincfg(codec, &codec->init_pins, nid);
780 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
782 /* restore all current pin configs */
783 static void restore_pincfgs(struct hda_codec *codec)
786 for (i = 0; i < codec->init_pins.used; i++) {
787 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
788 set_pincfg(codec, pin->nid,
789 snd_hda_codec_get_pincfg(codec, pin->nid));
793 static void init_hda_cache(struct hda_cache_rec *cache,
794 unsigned int record_size);
795 static void free_hda_cache(struct hda_cache_rec *cache);
797 /* restore the initial pin cfgs and release all pincfg lists */
798 static void restore_init_pincfgs(struct hda_codec *codec)
800 /* first free cur_pins and override_pins, then call restore_pincfg
801 * so that only the values in init_pins are restored
803 snd_array_free(&codec->cur_pins);
804 #ifdef CONFIG_SND_HDA_HWDEP
805 snd_array_free(&codec->override_pins);
807 restore_pincfgs(codec);
808 snd_array_free(&codec->init_pins);
814 static void snd_hda_codec_free(struct hda_codec *codec)
818 restore_init_pincfgs(codec);
819 #ifdef CONFIG_SND_HDA_POWER_SAVE
820 cancel_delayed_work(&codec->power_work);
821 flush_workqueue(codec->bus->workq);
823 list_del(&codec->list);
824 snd_array_free(&codec->mixers);
825 codec->bus->caddr_tbl[codec->addr] = NULL;
826 if (codec->patch_ops.free)
827 codec->patch_ops.free(codec);
828 module_put(codec->owner);
829 free_hda_cache(&codec->amp_cache);
830 free_hda_cache(&codec->cmd_cache);
832 kfree(codec->modelname);
838 * snd_hda_codec_new - create a HDA codec
839 * @bus: the bus to assign
840 * @codec_addr: the codec address
841 * @codecp: the pointer to store the generated codec
843 * Returns 0 if successful, or a negative error code.
845 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
846 int do_init, struct hda_codec **codecp)
848 struct hda_codec *codec;
852 if (snd_BUG_ON(!bus))
854 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
857 if (bus->caddr_tbl[codec_addr]) {
858 snd_printk(KERN_ERR "hda_codec: "
859 "address 0x%x is already occupied\n", codec_addr);
863 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
865 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
870 codec->addr = codec_addr;
871 mutex_init(&codec->spdif_mutex);
872 mutex_init(&codec->control_mutex);
873 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
874 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
875 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
876 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
877 snd_array_init(&codec->cur_pins, sizeof(struct hda_pincfg), 16);
878 if (codec->bus->modelname) {
879 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
880 if (!codec->modelname) {
881 snd_hda_codec_free(codec);
886 #ifdef CONFIG_SND_HDA_POWER_SAVE
887 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
888 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
889 * the caller has to power down appropriatley after initialization
892 hda_keep_power_on(codec);
895 list_add_tail(&codec->list, &bus->codec_list);
896 bus->caddr_tbl[codec_addr] = codec;
898 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
900 if (codec->vendor_id == -1)
901 /* read again, hopefully the access method was corrected
902 * in the last read...
904 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
906 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
907 AC_PAR_SUBSYSTEM_ID);
908 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
911 setup_fg_nodes(codec);
912 if (!codec->afg && !codec->mfg) {
913 snd_printdd("hda_codec: no AFG or MFG node found\n");
918 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
920 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
923 err = read_pin_defaults(codec);
927 if (!codec->subsystem_id) {
928 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
929 codec->subsystem_id =
930 snd_hda_codec_read(codec, nid, 0,
931 AC_VERB_GET_SUBSYSTEM_ID, 0);
934 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
937 err = snd_hda_codec_configure(codec);
941 snd_hda_codec_proc_new(codec);
943 snd_hda_create_hwdep(codec);
945 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
946 codec->subsystem_id, codec->revision_id);
947 snd_component_add(codec->bus->card, component);
954 snd_hda_codec_free(codec);
957 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
959 int snd_hda_codec_configure(struct hda_codec *codec)
963 codec->preset = find_codec_preset(codec);
965 err = get_codec_name(codec);
969 /* audio codec should override the mixer name */
970 if (codec->afg || !*codec->bus->card->mixername)
971 strlcpy(codec->bus->card->mixername, codec->name,
972 sizeof(codec->bus->card->mixername));
974 if (is_generic_config(codec)) {
975 err = snd_hda_parse_generic_codec(codec);
978 if (codec->preset && codec->preset->patch) {
979 err = codec->preset->patch(codec);
983 /* call the default parser */
984 err = snd_hda_parse_generic_codec(codec);
986 printk(KERN_ERR "hda-codec: No codec parser is available\n");
989 if (!err && codec->patch_ops.unsol_event)
990 err = init_unsol_queue(codec->bus);
995 * snd_hda_codec_setup_stream - set up the codec for streaming
996 * @codec: the CODEC to set up
997 * @nid: the NID to set up
998 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
999 * @channel_id: channel id to pass, zero based.
1000 * @format: stream format.
1002 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1004 int channel_id, int format)
1009 snd_printdd("hda_codec_setup_stream: "
1010 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1011 nid, stream_tag, channel_id, format);
1012 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1013 (stream_tag << 4) | channel_id);
1015 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1017 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1019 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1024 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1025 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1026 #if 0 /* keep the format */
1028 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1031 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
1034 * amp access functions
1037 /* FIXME: more better hash key? */
1038 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1039 #define INFO_AMP_CAPS (1<<0)
1040 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1042 /* initialize the hash table */
1043 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1044 unsigned int record_size)
1046 memset(cache, 0, sizeof(*cache));
1047 memset(cache->hash, 0xff, sizeof(cache->hash));
1048 snd_array_init(&cache->buf, record_size, 64);
1051 static void free_hda_cache(struct hda_cache_rec *cache)
1053 snd_array_free(&cache->buf);
1056 /* query the hash. allocate an entry if not found. */
1057 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1060 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1061 u16 cur = cache->hash[idx];
1062 struct hda_cache_head *info;
1064 while (cur != 0xffff) {
1065 info = snd_array_elem(&cache->buf, cur);
1066 if (info->key == key)
1071 /* add a new hash entry */
1072 info = snd_array_new(&cache->buf);
1075 cur = snd_array_index(&cache->buf, info);
1078 info->next = cache->hash[idx];
1079 cache->hash[idx] = cur;
1084 /* query and allocate an amp hash entry */
1085 static inline struct hda_amp_info *
1086 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1088 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1092 * query AMP capabilities for the given widget and direction
1094 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1096 struct hda_amp_info *info;
1098 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1101 if (!(info->head.val & INFO_AMP_CAPS)) {
1102 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1104 info->amp_caps = snd_hda_param_read(codec, nid,
1105 direction == HDA_OUTPUT ?
1106 AC_PAR_AMP_OUT_CAP :
1109 info->head.val |= INFO_AMP_CAPS;
1111 return info->amp_caps;
1113 EXPORT_SYMBOL_HDA(query_amp_caps);
1115 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1118 struct hda_amp_info *info;
1120 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1123 info->amp_caps = caps;
1124 info->head.val |= INFO_AMP_CAPS;
1127 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1130 * read the current volume to info
1131 * if the cache exists, read the cache value.
1133 static unsigned int get_vol_mute(struct hda_codec *codec,
1134 struct hda_amp_info *info, hda_nid_t nid,
1135 int ch, int direction, int index)
1139 if (info->head.val & INFO_AMP_VOL(ch))
1140 return info->vol[ch];
1142 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1143 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1145 val = snd_hda_codec_read(codec, nid, 0,
1146 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1147 info->vol[ch] = val & 0xff;
1148 info->head.val |= INFO_AMP_VOL(ch);
1149 return info->vol[ch];
1153 * write the current volume in info to the h/w and update the cache
1155 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1156 hda_nid_t nid, int ch, int direction, int index,
1161 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1162 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1163 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1165 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1166 info->vol[ch] = val;
1170 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1172 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1173 int direction, int index)
1175 struct hda_amp_info *info;
1176 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1179 return get_vol_mute(codec, info, nid, ch, direction, index);
1181 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1184 * update the AMP value, mask = bit mask to set, val = the value
1186 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1187 int direction, int idx, int mask, int val)
1189 struct hda_amp_info *info;
1191 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1195 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1196 if (info->vol[ch] == val)
1198 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1201 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1204 * update the AMP stereo with the same mask and value
1206 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1207 int direction, int idx, int mask, int val)
1210 for (ch = 0; ch < 2; ch++)
1211 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1215 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1217 #ifdef SND_HDA_NEEDS_RESUME
1218 /* resume the all amp commands from the cache */
1219 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1221 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1224 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1225 u32 key = buffer->head.key;
1227 unsigned int idx, dir, ch;
1231 idx = (key >> 16) & 0xff;
1232 dir = (key >> 24) & 0xff;
1233 for (ch = 0; ch < 2; ch++) {
1234 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1236 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1241 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1242 #endif /* SND_HDA_NEEDS_RESUME */
1245 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1246 struct snd_ctl_elem_info *uinfo)
1248 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1249 u16 nid = get_amp_nid(kcontrol);
1250 u8 chs = get_amp_channels(kcontrol);
1251 int dir = get_amp_direction(kcontrol);
1252 unsigned int ofs = get_amp_offset(kcontrol);
1255 caps = query_amp_caps(codec, nid, dir);
1257 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1259 printk(KERN_WARNING "hda_codec: "
1260 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1266 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1267 uinfo->count = chs == 3 ? 2 : 1;
1268 uinfo->value.integer.min = 0;
1269 uinfo->value.integer.max = caps;
1272 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1275 static inline unsigned int
1276 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1277 int ch, int dir, int idx, unsigned int ofs)
1280 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1281 val &= HDA_AMP_VOLMASK;
1290 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1291 int ch, int dir, int idx, unsigned int ofs,
1296 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1297 HDA_AMP_VOLMASK, val);
1300 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1301 struct snd_ctl_elem_value *ucontrol)
1303 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1304 hda_nid_t nid = get_amp_nid(kcontrol);
1305 int chs = get_amp_channels(kcontrol);
1306 int dir = get_amp_direction(kcontrol);
1307 int idx = get_amp_index(kcontrol);
1308 unsigned int ofs = get_amp_offset(kcontrol);
1309 long *valp = ucontrol->value.integer.value;
1312 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1314 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1317 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1319 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1320 struct snd_ctl_elem_value *ucontrol)
1322 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1323 hda_nid_t nid = get_amp_nid(kcontrol);
1324 int chs = get_amp_channels(kcontrol);
1325 int dir = get_amp_direction(kcontrol);
1326 int idx = get_amp_index(kcontrol);
1327 unsigned int ofs = get_amp_offset(kcontrol);
1328 long *valp = ucontrol->value.integer.value;
1331 snd_hda_power_up(codec);
1333 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1337 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1338 snd_hda_power_down(codec);
1341 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1343 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1344 unsigned int size, unsigned int __user *_tlv)
1346 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1347 hda_nid_t nid = get_amp_nid(kcontrol);
1348 int dir = get_amp_direction(kcontrol);
1349 unsigned int ofs = get_amp_offset(kcontrol);
1350 u32 caps, val1, val2;
1352 if (size < 4 * sizeof(unsigned int))
1354 caps = query_amp_caps(codec, nid, dir);
1355 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1356 val2 = (val2 + 1) * 25;
1357 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1359 val1 = ((int)val1) * ((int)val2);
1360 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1362 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1364 if (put_user(val1, _tlv + 2))
1366 if (put_user(val2, _tlv + 3))
1370 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1373 * set (static) TLV for virtual master volume; recalculated as max 0dB
1375 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1381 caps = query_amp_caps(codec, nid, dir);
1382 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1383 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1384 step = (step + 1) * 25;
1385 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1386 tlv[1] = 2 * sizeof(unsigned int);
1387 tlv[2] = -nums * step;
1390 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1392 /* find a mixer control element with the given name */
1393 static struct snd_kcontrol *
1394 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1395 const char *name, int idx)
1397 struct snd_ctl_elem_id id;
1398 memset(&id, 0, sizeof(id));
1399 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1401 strcpy(id.name, name);
1402 return snd_ctl_find_id(codec->bus->card, &id);
1405 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1408 return _snd_hda_find_mixer_ctl(codec, name, 0);
1410 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1412 /* Add a control element and assign to the codec */
1413 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1416 struct snd_kcontrol **knewp;
1418 err = snd_ctl_add(codec->bus->card, kctl);
1421 knewp = snd_array_new(&codec->mixers);
1427 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1429 #ifdef CONFIG_SND_HDA_RECONFIG
1430 /* Clear all controls assigned to the given codec */
1431 void snd_hda_ctls_clear(struct hda_codec *codec)
1434 struct snd_kcontrol **kctls = codec->mixers.list;
1435 for (i = 0; i < codec->mixers.used; i++)
1436 snd_ctl_remove(codec->bus->card, kctls[i]);
1437 snd_array_free(&codec->mixers);
1440 void snd_hda_codec_reset(struct hda_codec *codec)
1444 #ifdef CONFIG_SND_HDA_POWER_SAVE
1445 cancel_delayed_work(&codec->power_work);
1446 flush_workqueue(codec->bus->workq);
1448 snd_hda_ctls_clear(codec);
1450 for (i = 0; i < codec->num_pcms; i++) {
1451 if (codec->pcm_info[i].pcm) {
1452 snd_device_free(codec->bus->card,
1453 codec->pcm_info[i].pcm);
1454 clear_bit(codec->pcm_info[i].device,
1455 codec->bus->pcm_dev_bits);
1458 if (codec->patch_ops.free)
1459 codec->patch_ops.free(codec);
1460 codec->proc_widget_hook = NULL;
1462 free_hda_cache(&codec->amp_cache);
1463 free_hda_cache(&codec->cmd_cache);
1464 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1465 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1466 /* free only cur_pins so that init_pins + override_pins are restored */
1467 snd_array_free(&codec->cur_pins);
1468 restore_pincfgs(codec);
1469 codec->num_pcms = 0;
1470 codec->pcm_info = NULL;
1471 codec->preset = NULL;
1472 module_put(codec->owner);
1473 codec->owner = NULL;
1475 #endif /* CONFIG_SND_HDA_RECONFIG */
1477 /* create a virtual master control and add slaves */
1478 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1479 unsigned int *tlv, const char **slaves)
1481 struct snd_kcontrol *kctl;
1485 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1488 snd_printdd("No slave found for %s\n", name);
1491 kctl = snd_ctl_make_virtual_master(name, tlv);
1494 err = snd_hda_ctl_add(codec, kctl);
1498 for (s = slaves; *s; s++) {
1499 struct snd_kcontrol *sctl;
1501 sctl = snd_hda_find_mixer_ctl(codec, *s);
1503 snd_printdd("Cannot find slave %s, skipped\n", *s);
1506 err = snd_ctl_add_slave(kctl, sctl);
1512 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1515 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1516 struct snd_ctl_elem_info *uinfo)
1518 int chs = get_amp_channels(kcontrol);
1520 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1521 uinfo->count = chs == 3 ? 2 : 1;
1522 uinfo->value.integer.min = 0;
1523 uinfo->value.integer.max = 1;
1526 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1528 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1529 struct snd_ctl_elem_value *ucontrol)
1531 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1532 hda_nid_t nid = get_amp_nid(kcontrol);
1533 int chs = get_amp_channels(kcontrol);
1534 int dir = get_amp_direction(kcontrol);
1535 int idx = get_amp_index(kcontrol);
1536 long *valp = ucontrol->value.integer.value;
1539 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1540 HDA_AMP_MUTE) ? 0 : 1;
1542 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1543 HDA_AMP_MUTE) ? 0 : 1;
1546 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1548 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1549 struct snd_ctl_elem_value *ucontrol)
1551 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1552 hda_nid_t nid = get_amp_nid(kcontrol);
1553 int chs = get_amp_channels(kcontrol);
1554 int dir = get_amp_direction(kcontrol);
1555 int idx = get_amp_index(kcontrol);
1556 long *valp = ucontrol->value.integer.value;
1559 snd_hda_power_up(codec);
1561 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1563 *valp ? 0 : HDA_AMP_MUTE);
1567 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1569 *valp ? 0 : HDA_AMP_MUTE);
1570 #ifdef CONFIG_SND_HDA_POWER_SAVE
1571 if (codec->patch_ops.check_power_status)
1572 codec->patch_ops.check_power_status(codec, nid);
1574 snd_hda_power_down(codec);
1577 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1580 * bound volume controls
1582 * bind multiple volumes (# indices, from 0)
1585 #define AMP_VAL_IDX_SHIFT 19
1586 #define AMP_VAL_IDX_MASK (0x0f<<19)
1588 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1589 struct snd_ctl_elem_value *ucontrol)
1591 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1595 mutex_lock(&codec->control_mutex);
1596 pval = kcontrol->private_value;
1597 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1598 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1599 kcontrol->private_value = pval;
1600 mutex_unlock(&codec->control_mutex);
1603 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1605 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1606 struct snd_ctl_elem_value *ucontrol)
1608 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1610 int i, indices, err = 0, change = 0;
1612 mutex_lock(&codec->control_mutex);
1613 pval = kcontrol->private_value;
1614 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1615 for (i = 0; i < indices; i++) {
1616 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1617 (i << AMP_VAL_IDX_SHIFT);
1618 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1623 kcontrol->private_value = pval;
1624 mutex_unlock(&codec->control_mutex);
1625 return err < 0 ? err : change;
1627 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1630 * generic bound volume/swtich controls
1632 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1633 struct snd_ctl_elem_info *uinfo)
1635 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1636 struct hda_bind_ctls *c;
1639 mutex_lock(&codec->control_mutex);
1640 c = (struct hda_bind_ctls *)kcontrol->private_value;
1641 kcontrol->private_value = *c->values;
1642 err = c->ops->info(kcontrol, uinfo);
1643 kcontrol->private_value = (long)c;
1644 mutex_unlock(&codec->control_mutex);
1647 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1649 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1650 struct snd_ctl_elem_value *ucontrol)
1652 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1653 struct hda_bind_ctls *c;
1656 mutex_lock(&codec->control_mutex);
1657 c = (struct hda_bind_ctls *)kcontrol->private_value;
1658 kcontrol->private_value = *c->values;
1659 err = c->ops->get(kcontrol, ucontrol);
1660 kcontrol->private_value = (long)c;
1661 mutex_unlock(&codec->control_mutex);
1664 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1666 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1667 struct snd_ctl_elem_value *ucontrol)
1669 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1670 struct hda_bind_ctls *c;
1671 unsigned long *vals;
1672 int err = 0, change = 0;
1674 mutex_lock(&codec->control_mutex);
1675 c = (struct hda_bind_ctls *)kcontrol->private_value;
1676 for (vals = c->values; *vals; vals++) {
1677 kcontrol->private_value = *vals;
1678 err = c->ops->put(kcontrol, ucontrol);
1683 kcontrol->private_value = (long)c;
1684 mutex_unlock(&codec->control_mutex);
1685 return err < 0 ? err : change;
1687 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1689 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1690 unsigned int size, unsigned int __user *tlv)
1692 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1693 struct hda_bind_ctls *c;
1696 mutex_lock(&codec->control_mutex);
1697 c = (struct hda_bind_ctls *)kcontrol->private_value;
1698 kcontrol->private_value = *c->values;
1699 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1700 kcontrol->private_value = (long)c;
1701 mutex_unlock(&codec->control_mutex);
1704 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1706 struct hda_ctl_ops snd_hda_bind_vol = {
1707 .info = snd_hda_mixer_amp_volume_info,
1708 .get = snd_hda_mixer_amp_volume_get,
1709 .put = snd_hda_mixer_amp_volume_put,
1710 .tlv = snd_hda_mixer_amp_tlv
1712 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1714 struct hda_ctl_ops snd_hda_bind_sw = {
1715 .info = snd_hda_mixer_amp_switch_info,
1716 .get = snd_hda_mixer_amp_switch_get,
1717 .put = snd_hda_mixer_amp_switch_put,
1718 .tlv = snd_hda_mixer_amp_tlv
1720 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1723 * SPDIF out controls
1726 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1727 struct snd_ctl_elem_info *uinfo)
1729 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1734 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1735 struct snd_ctl_elem_value *ucontrol)
1737 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1738 IEC958_AES0_NONAUDIO |
1739 IEC958_AES0_CON_EMPHASIS_5015 |
1740 IEC958_AES0_CON_NOT_COPYRIGHT;
1741 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1742 IEC958_AES1_CON_ORIGINAL;
1746 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1747 struct snd_ctl_elem_value *ucontrol)
1749 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1750 IEC958_AES0_NONAUDIO |
1751 IEC958_AES0_PRO_EMPHASIS_5015;
1755 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1756 struct snd_ctl_elem_value *ucontrol)
1758 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1760 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1761 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1762 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1763 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1768 /* convert from SPDIF status bits to HDA SPDIF bits
1769 * bit 0 (DigEn) is always set zero (to be filled later)
1771 static unsigned short convert_from_spdif_status(unsigned int sbits)
1773 unsigned short val = 0;
1775 if (sbits & IEC958_AES0_PROFESSIONAL)
1776 val |= AC_DIG1_PROFESSIONAL;
1777 if (sbits & IEC958_AES0_NONAUDIO)
1778 val |= AC_DIG1_NONAUDIO;
1779 if (sbits & IEC958_AES0_PROFESSIONAL) {
1780 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1781 IEC958_AES0_PRO_EMPHASIS_5015)
1782 val |= AC_DIG1_EMPHASIS;
1784 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1785 IEC958_AES0_CON_EMPHASIS_5015)
1786 val |= AC_DIG1_EMPHASIS;
1787 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1788 val |= AC_DIG1_COPYRIGHT;
1789 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1790 val |= AC_DIG1_LEVEL;
1791 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1796 /* convert to SPDIF status bits from HDA SPDIF bits
1798 static unsigned int convert_to_spdif_status(unsigned short val)
1800 unsigned int sbits = 0;
1802 if (val & AC_DIG1_NONAUDIO)
1803 sbits |= IEC958_AES0_NONAUDIO;
1804 if (val & AC_DIG1_PROFESSIONAL)
1805 sbits |= IEC958_AES0_PROFESSIONAL;
1806 if (sbits & IEC958_AES0_PROFESSIONAL) {
1807 if (sbits & AC_DIG1_EMPHASIS)
1808 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1810 if (val & AC_DIG1_EMPHASIS)
1811 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1812 if (!(val & AC_DIG1_COPYRIGHT))
1813 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1814 if (val & AC_DIG1_LEVEL)
1815 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1816 sbits |= val & (0x7f << 8);
1821 /* set digital convert verbs both for the given NID and its slaves */
1822 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1827 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1828 d = codec->slave_dig_outs;
1832 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1835 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1839 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1841 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1844 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1845 struct snd_ctl_elem_value *ucontrol)
1847 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1848 hda_nid_t nid = kcontrol->private_value;
1852 mutex_lock(&codec->spdif_mutex);
1853 codec->spdif_status = ucontrol->value.iec958.status[0] |
1854 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1855 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1856 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1857 val = convert_from_spdif_status(codec->spdif_status);
1858 val |= codec->spdif_ctls & 1;
1859 change = codec->spdif_ctls != val;
1860 codec->spdif_ctls = val;
1863 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1865 mutex_unlock(&codec->spdif_mutex);
1869 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1871 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1872 struct snd_ctl_elem_value *ucontrol)
1874 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1876 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1880 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1881 struct snd_ctl_elem_value *ucontrol)
1883 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1884 hda_nid_t nid = kcontrol->private_value;
1888 mutex_lock(&codec->spdif_mutex);
1889 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1890 if (ucontrol->value.integer.value[0])
1891 val |= AC_DIG1_ENABLE;
1892 change = codec->spdif_ctls != val;
1894 codec->spdif_ctls = val;
1895 set_dig_out_convert(codec, nid, val & 0xff, -1);
1896 /* unmute amp switch (if any) */
1897 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1898 (val & AC_DIG1_ENABLE))
1899 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1902 mutex_unlock(&codec->spdif_mutex);
1906 static struct snd_kcontrol_new dig_mixes[] = {
1908 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1909 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1910 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1911 .info = snd_hda_spdif_mask_info,
1912 .get = snd_hda_spdif_cmask_get,
1915 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1916 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1917 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1918 .info = snd_hda_spdif_mask_info,
1919 .get = snd_hda_spdif_pmask_get,
1922 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1923 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1924 .info = snd_hda_spdif_mask_info,
1925 .get = snd_hda_spdif_default_get,
1926 .put = snd_hda_spdif_default_put,
1929 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1930 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1931 .info = snd_hda_spdif_out_switch_info,
1932 .get = snd_hda_spdif_out_switch_get,
1933 .put = snd_hda_spdif_out_switch_put,
1938 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1941 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1942 * @codec: the HDA codec
1943 * @nid: audio out widget NID
1945 * Creates controls related with the SPDIF output.
1946 * Called from each patch supporting the SPDIF out.
1948 * Returns 0 if successful, or a negative error code.
1950 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1953 struct snd_kcontrol *kctl;
1954 struct snd_kcontrol_new *dig_mix;
1957 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1958 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1962 if (idx >= SPDIF_MAX_IDX) {
1963 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1966 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1967 kctl = snd_ctl_new1(dig_mix, codec);
1970 kctl->id.index = idx;
1971 kctl->private_value = nid;
1972 err = snd_hda_ctl_add(codec, kctl);
1977 snd_hda_codec_read(codec, nid, 0,
1978 AC_VERB_GET_DIGI_CONVERT_1, 0);
1979 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1982 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1985 * SPDIF sharing with analog output
1987 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1988 struct snd_ctl_elem_value *ucontrol)
1990 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1991 ucontrol->value.integer.value[0] = mout->share_spdif;
1995 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1996 struct snd_ctl_elem_value *ucontrol)
1998 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1999 mout->share_spdif = !!ucontrol->value.integer.value[0];
2003 static struct snd_kcontrol_new spdif_share_sw = {
2004 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2005 .name = "IEC958 Default PCM Playback Switch",
2006 .info = snd_ctl_boolean_mono_info,
2007 .get = spdif_share_sw_get,
2008 .put = spdif_share_sw_put,
2011 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2012 struct hda_multi_out *mout)
2014 if (!mout->dig_out_nid)
2016 /* ATTENTION: here mout is passed as private_data, instead of codec */
2017 return snd_hda_ctl_add(codec,
2018 snd_ctl_new1(&spdif_share_sw, mout));
2020 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2026 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2028 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2029 struct snd_ctl_elem_value *ucontrol)
2031 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2033 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2037 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2038 struct snd_ctl_elem_value *ucontrol)
2040 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2041 hda_nid_t nid = kcontrol->private_value;
2042 unsigned int val = !!ucontrol->value.integer.value[0];
2045 mutex_lock(&codec->spdif_mutex);
2046 change = codec->spdif_in_enable != val;
2048 codec->spdif_in_enable = val;
2049 snd_hda_codec_write_cache(codec, nid, 0,
2050 AC_VERB_SET_DIGI_CONVERT_1, val);
2052 mutex_unlock(&codec->spdif_mutex);
2056 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2057 struct snd_ctl_elem_value *ucontrol)
2059 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2060 hda_nid_t nid = kcontrol->private_value;
2064 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2065 sbits = convert_to_spdif_status(val);
2066 ucontrol->value.iec958.status[0] = sbits;
2067 ucontrol->value.iec958.status[1] = sbits >> 8;
2068 ucontrol->value.iec958.status[2] = sbits >> 16;
2069 ucontrol->value.iec958.status[3] = sbits >> 24;
2073 static struct snd_kcontrol_new dig_in_ctls[] = {
2075 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2076 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2077 .info = snd_hda_spdif_in_switch_info,
2078 .get = snd_hda_spdif_in_switch_get,
2079 .put = snd_hda_spdif_in_switch_put,
2082 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2083 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2084 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2085 .info = snd_hda_spdif_mask_info,
2086 .get = snd_hda_spdif_in_status_get,
2092 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2093 * @codec: the HDA codec
2094 * @nid: audio in widget NID
2096 * Creates controls related with the SPDIF input.
2097 * Called from each patch supporting the SPDIF in.
2099 * Returns 0 if successful, or a negative error code.
2101 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2104 struct snd_kcontrol *kctl;
2105 struct snd_kcontrol_new *dig_mix;
2108 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2109 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2113 if (idx >= SPDIF_MAX_IDX) {
2114 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2117 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2118 kctl = snd_ctl_new1(dig_mix, codec);
2121 kctl->private_value = nid;
2122 err = snd_hda_ctl_add(codec, kctl);
2126 codec->spdif_in_enable =
2127 snd_hda_codec_read(codec, nid, 0,
2128 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2132 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2134 #ifdef SND_HDA_NEEDS_RESUME
2139 /* build a 32bit cache key with the widget id and the command parameter */
2140 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2141 #define get_cmd_cache_nid(key) ((key) & 0xff)
2142 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2145 * snd_hda_codec_write_cache - send a single command with caching
2146 * @codec: the HDA codec
2147 * @nid: NID to send the command
2148 * @direct: direct flag
2149 * @verb: the verb to send
2150 * @parm: the parameter for the verb
2152 * Send a single command without waiting for response.
2154 * Returns 0 if successful, or a negative error code.
2156 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2157 int direct, unsigned int verb, unsigned int parm)
2159 struct hda_bus *bus = codec->bus;
2163 res = make_codec_cmd(codec, nid, direct, verb, parm);
2164 snd_hda_power_up(codec);
2165 mutex_lock(&bus->cmd_mutex);
2166 err = bus->ops.command(bus, res);
2168 struct hda_cache_head *c;
2169 u32 key = build_cmd_cache_key(nid, verb);
2170 c = get_alloc_hash(&codec->cmd_cache, key);
2174 mutex_unlock(&bus->cmd_mutex);
2175 snd_hda_power_down(codec);
2178 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2180 /* resume the all commands from the cache */
2181 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2183 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2186 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2187 u32 key = buffer->key;
2190 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2191 get_cmd_cache_cmd(key), buffer->val);
2194 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2197 * snd_hda_sequence_write_cache - sequence writes with caching
2198 * @codec: the HDA codec
2199 * @seq: VERB array to send
2201 * Send the commands sequentially from the given array.
2202 * Thte commands are recorded on cache for power-save and resume.
2203 * The array must be terminated with NID=0.
2205 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2206 const struct hda_verb *seq)
2208 for (; seq->nid; seq++)
2209 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2212 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2213 #endif /* SND_HDA_NEEDS_RESUME */
2216 * set power state of the codec
2218 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2219 unsigned int power_state)
2224 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2226 msleep(10); /* partial workaround for "azx_get_response timeout" */
2228 nid = codec->start_nid;
2229 for (i = 0; i < codec->num_nodes; i++, nid++) {
2230 unsigned int wcaps = get_wcaps(codec, nid);
2231 if (wcaps & AC_WCAP_POWER) {
2232 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2234 if (wid_type == AC_WID_PIN) {
2235 unsigned int pincap;
2237 * don't power down the widget if it controls
2238 * eapd and EAPD_BTLENABLE is set.
2240 pincap = snd_hda_param_read(codec, nid,
2242 if (pincap & AC_PINCAP_EAPD) {
2243 int eapd = snd_hda_codec_read(codec,
2245 AC_VERB_GET_EAPD_BTLENABLE, 0);
2247 if (power_state == AC_PWRST_D3 && eapd)
2251 snd_hda_codec_write(codec, nid, 0,
2252 AC_VERB_SET_POWER_STATE,
2257 if (power_state == AC_PWRST_D0) {
2258 unsigned long end_time;
2261 /* wait until the codec reachs to D0 */
2262 end_time = jiffies + msecs_to_jiffies(500);
2264 state = snd_hda_codec_read(codec, fg, 0,
2265 AC_VERB_GET_POWER_STATE, 0);
2266 if (state == power_state)
2269 } while (time_after_eq(end_time, jiffies));
2273 #ifdef CONFIG_SND_HDA_HWDEP
2274 /* execute additional init verbs */
2275 static void hda_exec_init_verbs(struct hda_codec *codec)
2277 if (codec->init_verbs.list)
2278 snd_hda_sequence_write(codec, codec->init_verbs.list);
2281 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2284 #ifdef SND_HDA_NEEDS_RESUME
2286 * call suspend and power-down; used both from PM and power-save
2288 static void hda_call_codec_suspend(struct hda_codec *codec)
2290 if (codec->patch_ops.suspend)
2291 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2292 hda_set_power_state(codec,
2293 codec->afg ? codec->afg : codec->mfg,
2295 #ifdef CONFIG_SND_HDA_POWER_SAVE
2296 cancel_delayed_work(&codec->power_work);
2297 codec->power_on = 0;
2298 codec->power_transition = 0;
2303 * kick up codec; used both from PM and power-save
2305 static void hda_call_codec_resume(struct hda_codec *codec)
2307 hda_set_power_state(codec,
2308 codec->afg ? codec->afg : codec->mfg,
2310 restore_pincfgs(codec); /* restore all current pin configs */
2311 hda_exec_init_verbs(codec);
2312 if (codec->patch_ops.resume)
2313 codec->patch_ops.resume(codec);
2315 if (codec->patch_ops.init)
2316 codec->patch_ops.init(codec);
2317 snd_hda_codec_resume_amp(codec);
2318 snd_hda_codec_resume_cache(codec);
2321 #endif /* SND_HDA_NEEDS_RESUME */
2325 * snd_hda_build_controls - build mixer controls
2328 * Creates mixer controls for each codec included in the bus.
2330 * Returns 0 if successful, otherwise a negative error code.
2332 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2334 struct hda_codec *codec;
2336 list_for_each_entry(codec, &bus->codec_list, list) {
2337 int err = snd_hda_codec_build_controls(codec);
2343 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2345 int snd_hda_codec_build_controls(struct hda_codec *codec)
2348 /* fake as if already powered-on */
2349 hda_keep_power_on(codec);
2351 hda_set_power_state(codec,
2352 codec->afg ? codec->afg : codec->mfg,
2354 hda_exec_init_verbs(codec);
2355 /* continue to initialize... */
2356 if (codec->patch_ops.init)
2357 err = codec->patch_ops.init(codec);
2358 if (!err && codec->patch_ops.build_controls)
2359 err = codec->patch_ops.build_controls(codec);
2360 snd_hda_power_down(codec);
2369 struct hda_rate_tbl {
2371 unsigned int alsa_bits;
2372 unsigned int hda_fmt;
2375 static struct hda_rate_tbl rate_bits[] = {
2376 /* rate in Hz, ALSA rate bitmask, HDA format value */
2378 /* autodetected value used in snd_hda_query_supported_pcm */
2379 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2380 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2381 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2382 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2383 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2384 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2385 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2386 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2387 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2388 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2389 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2390 #define AC_PAR_PCM_RATE_BITS 11
2391 /* up to bits 10, 384kHZ isn't supported properly */
2393 /* not autodetected value */
2394 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2396 { 0 } /* terminator */
2400 * snd_hda_calc_stream_format - calculate format bitset
2401 * @rate: the sample rate
2402 * @channels: the number of channels
2403 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2404 * @maxbps: the max. bps
2406 * Calculate the format bitset from the given rate, channels and th PCM format.
2408 * Return zero if invalid.
2410 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2411 unsigned int channels,
2412 unsigned int format,
2413 unsigned int maxbps)
2416 unsigned int val = 0;
2418 for (i = 0; rate_bits[i].hz; i++)
2419 if (rate_bits[i].hz == rate) {
2420 val = rate_bits[i].hda_fmt;
2423 if (!rate_bits[i].hz) {
2424 snd_printdd("invalid rate %d\n", rate);
2428 if (channels == 0 || channels > 8) {
2429 snd_printdd("invalid channels %d\n", channels);
2432 val |= channels - 1;
2434 switch (snd_pcm_format_width(format)) {
2435 case 8: val |= 0x00; break;
2436 case 16: val |= 0x10; break;
2442 else if (maxbps >= 24)
2448 snd_printdd("invalid format width %d\n",
2449 snd_pcm_format_width(format));
2455 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2458 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2459 * @codec: the HDA codec
2460 * @nid: NID to query
2461 * @ratesp: the pointer to store the detected rate bitflags
2462 * @formatsp: the pointer to store the detected formats
2463 * @bpsp: the pointer to store the detected format widths
2465 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2466 * or @bsps argument is ignored.
2468 * Returns 0 if successful, otherwise a negative error code.
2470 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2471 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2474 unsigned int val, streams;
2477 if (nid != codec->afg &&
2478 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2479 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2484 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2488 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2490 rates |= rate_bits[i].alsa_bits;
2495 if (formatsp || bpsp) {
2500 wcaps = get_wcaps(codec, nid);
2501 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2505 streams = snd_hda_param_read(codec, codec->afg,
2512 if (streams & AC_SUPFMT_PCM) {
2513 if (val & AC_SUPPCM_BITS_8) {
2514 formats |= SNDRV_PCM_FMTBIT_U8;
2517 if (val & AC_SUPPCM_BITS_16) {
2518 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2521 if (wcaps & AC_WCAP_DIGITAL) {
2522 if (val & AC_SUPPCM_BITS_32)
2523 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2524 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2525 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2526 if (val & AC_SUPPCM_BITS_24)
2528 else if (val & AC_SUPPCM_BITS_20)
2530 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2531 AC_SUPPCM_BITS_32)) {
2532 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2533 if (val & AC_SUPPCM_BITS_32)
2535 else if (val & AC_SUPPCM_BITS_24)
2537 else if (val & AC_SUPPCM_BITS_20)
2541 else if (streams == AC_SUPFMT_FLOAT32) {
2542 /* should be exclusive */
2543 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2545 } else if (streams == AC_SUPFMT_AC3) {
2546 /* should be exclusive */
2547 /* temporary hack: we have still no proper support
2548 * for the direct AC3 stream...
2550 formats |= SNDRV_PCM_FMTBIT_U8;
2554 *formatsp = formats;
2563 * snd_hda_is_supported_format - check whether the given node supports
2566 * Returns 1 if supported, 0 if not.
2568 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2569 unsigned int format)
2572 unsigned int val = 0, rate, stream;
2574 if (nid != codec->afg &&
2575 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2576 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2581 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2586 rate = format & 0xff00;
2587 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2588 if (rate_bits[i].hda_fmt == rate) {
2593 if (i >= AC_PAR_PCM_RATE_BITS)
2596 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2599 if (!stream && nid != codec->afg)
2600 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2601 if (!stream || stream == -1)
2604 if (stream & AC_SUPFMT_PCM) {
2605 switch (format & 0xf0) {
2607 if (!(val & AC_SUPPCM_BITS_8))
2611 if (!(val & AC_SUPPCM_BITS_16))
2615 if (!(val & AC_SUPPCM_BITS_20))
2619 if (!(val & AC_SUPPCM_BITS_24))
2623 if (!(val & AC_SUPPCM_BITS_32))
2630 /* FIXME: check for float32 and AC3? */
2635 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2640 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2641 struct hda_codec *codec,
2642 struct snd_pcm_substream *substream)
2647 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2648 struct hda_codec *codec,
2649 unsigned int stream_tag,
2650 unsigned int format,
2651 struct snd_pcm_substream *substream)
2653 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2657 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2658 struct hda_codec *codec,
2659 struct snd_pcm_substream *substream)
2661 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2665 static int set_pcm_default_values(struct hda_codec *codec,
2666 struct hda_pcm_stream *info)
2668 /* query support PCM information from the given NID */
2669 if (info->nid && (!info->rates || !info->formats)) {
2670 snd_hda_query_supported_pcm(codec, info->nid,
2671 info->rates ? NULL : &info->rates,
2672 info->formats ? NULL : &info->formats,
2673 info->maxbps ? NULL : &info->maxbps);
2675 if (info->ops.open == NULL)
2676 info->ops.open = hda_pcm_default_open_close;
2677 if (info->ops.close == NULL)
2678 info->ops.close = hda_pcm_default_open_close;
2679 if (info->ops.prepare == NULL) {
2680 if (snd_BUG_ON(!info->nid))
2682 info->ops.prepare = hda_pcm_default_prepare;
2684 if (info->ops.cleanup == NULL) {
2685 if (snd_BUG_ON(!info->nid))
2687 info->ops.cleanup = hda_pcm_default_cleanup;
2693 * get the empty PCM device number to assign
2695 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2697 static const char *dev_name[HDA_PCM_NTYPES] = {
2698 "Audio", "SPDIF", "HDMI", "Modem"
2700 /* starting device index for each PCM type */
2701 static int dev_idx[HDA_PCM_NTYPES] = {
2702 [HDA_PCM_TYPE_AUDIO] = 0,
2703 [HDA_PCM_TYPE_SPDIF] = 1,
2704 [HDA_PCM_TYPE_HDMI] = 3,
2705 [HDA_PCM_TYPE_MODEM] = 6
2707 /* normal audio device indices; not linear to keep compatibility */
2708 static int audio_idx[4] = { 0, 2, 4, 5 };
2712 case HDA_PCM_TYPE_AUDIO:
2713 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2715 if (!test_bit(dev, bus->pcm_dev_bits))
2718 if (i >= ARRAY_SIZE(audio_idx)) {
2719 snd_printk(KERN_WARNING "Too many audio devices\n");
2723 case HDA_PCM_TYPE_SPDIF:
2724 case HDA_PCM_TYPE_HDMI:
2725 case HDA_PCM_TYPE_MODEM:
2726 dev = dev_idx[type];
2727 if (test_bit(dev, bus->pcm_dev_bits)) {
2728 snd_printk(KERN_WARNING "%s already defined\n",
2734 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2737 set_bit(dev, bus->pcm_dev_bits);
2742 * attach a new PCM stream
2744 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2746 struct hda_bus *bus = codec->bus;
2747 struct hda_pcm_stream *info;
2750 if (snd_BUG_ON(!pcm->name))
2752 for (stream = 0; stream < 2; stream++) {
2753 info = &pcm->stream[stream];
2754 if (info->substreams) {
2755 err = set_pcm_default_values(codec, info);
2760 return bus->ops.attach_pcm(bus, codec, pcm);
2763 /* assign all PCMs of the given codec */
2764 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2769 if (!codec->num_pcms) {
2770 if (!codec->patch_ops.build_pcms)
2772 err = codec->patch_ops.build_pcms(codec);
2776 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2777 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2780 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2781 continue; /* no substreams assigned */
2784 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2788 err = snd_hda_attach_pcm(codec, cpcm);
2797 * snd_hda_build_pcms - build PCM information
2800 * Create PCM information for each codec included in the bus.
2802 * The build_pcms codec patch is requested to set up codec->num_pcms and
2803 * codec->pcm_info properly. The array is referred by the top-level driver
2804 * to create its PCM instances.
2805 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2808 * At least, substreams, channels_min and channels_max must be filled for
2809 * each stream. substreams = 0 indicates that the stream doesn't exist.
2810 * When rates and/or formats are zero, the supported values are queried
2811 * from the given nid. The nid is used also by the default ops.prepare
2812 * and ops.cleanup callbacks.
2814 * The driver needs to call ops.open in its open callback. Similarly,
2815 * ops.close is supposed to be called in the close callback.
2816 * ops.prepare should be called in the prepare or hw_params callback
2817 * with the proper parameters for set up.
2818 * ops.cleanup should be called in hw_free for clean up of streams.
2820 * This function returns 0 if successfull, or a negative error code.
2822 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2824 struct hda_codec *codec;
2826 list_for_each_entry(codec, &bus->codec_list, list) {
2827 int err = snd_hda_codec_build_pcms(codec);
2833 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2836 * snd_hda_check_board_config - compare the current codec with the config table
2837 * @codec: the HDA codec
2838 * @num_configs: number of config enums
2839 * @models: array of model name strings
2840 * @tbl: configuration table, terminated by null entries
2842 * Compares the modelname or PCI subsystem id of the current codec with the
2843 * given configuration table. If a matching entry is found, returns its
2844 * config value (supposed to be 0 or positive).
2846 * If no entries are matching, the function returns a negative value.
2848 int snd_hda_check_board_config(struct hda_codec *codec,
2849 int num_configs, const char **models,
2850 const struct snd_pci_quirk *tbl)
2852 if (codec->modelname && models) {
2854 for (i = 0; i < num_configs; i++) {
2856 !strcmp(codec->modelname, models[i])) {
2857 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2858 "selected\n", models[i]);
2864 if (!codec->bus->pci || !tbl)
2867 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2870 if (tbl->value >= 0 && tbl->value < num_configs) {
2871 #ifdef CONFIG_SND_DEBUG_VERBOSE
2873 const char *model = NULL;
2875 model = models[tbl->value];
2877 sprintf(tmp, "#%d", tbl->value);
2880 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2881 "for config %x:%x (%s)\n",
2882 model, tbl->subvendor, tbl->subdevice,
2883 (tbl->name ? tbl->name : "Unknown device"));
2889 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
2892 * snd_hda_check_board_codec_sid_config - compare the current codec
2893 subsystem ID with the
2896 This is important for Gateway notebooks with SB450 HDA Audio
2897 where the vendor ID of the PCI device is:
2898 ATI Technologies Inc SB450 HDA Audio [1002:437b]
2899 and the vendor/subvendor are found only at the codec.
2901 * @codec: the HDA codec
2902 * @num_configs: number of config enums
2903 * @models: array of model name strings
2904 * @tbl: configuration table, terminated by null entries
2906 * Compares the modelname or PCI subsystem id of the current codec with the
2907 * given configuration table. If a matching entry is found, returns its
2908 * config value (supposed to be 0 or positive).
2910 * If no entries are matching, the function returns a negative value.
2912 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
2913 int num_configs, const char **models,
2914 const struct snd_pci_quirk *tbl)
2916 const struct snd_pci_quirk *q;
2918 /* Search for codec ID */
2919 for (q = tbl; q->subvendor; q++) {
2920 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
2922 if (vendorid == codec->subsystem_id)
2931 if (tbl->value >= 0 && tbl->value < num_configs) {
2932 #ifdef CONFIG_SND_DEBUG_DETECT
2934 const char *model = NULL;
2936 model = models[tbl->value];
2938 sprintf(tmp, "#%d", tbl->value);
2941 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2942 "for config %x:%x (%s)\n",
2943 model, tbl->subvendor, tbl->subdevice,
2944 (tbl->name ? tbl->name : "Unknown device"));
2950 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
2953 * snd_hda_add_new_ctls - create controls from the array
2954 * @codec: the HDA codec
2955 * @knew: the array of struct snd_kcontrol_new
2957 * This helper function creates and add new controls in the given array.
2958 * The array must be terminated with an empty entry as terminator.
2960 * Returns 0 if successful, or a negative error code.
2962 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
2966 for (; knew->name; knew++) {
2967 struct snd_kcontrol *kctl;
2968 kctl = snd_ctl_new1(knew, codec);
2971 err = snd_hda_ctl_add(codec, kctl);
2975 kctl = snd_ctl_new1(knew, codec);
2978 kctl->id.device = codec->addr;
2979 err = snd_hda_ctl_add(codec, kctl);
2986 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
2988 #ifdef CONFIG_SND_HDA_POWER_SAVE
2989 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2990 unsigned int power_state);
2992 static void hda_power_work(struct work_struct *work)
2994 struct hda_codec *codec =
2995 container_of(work, struct hda_codec, power_work.work);
2996 struct hda_bus *bus = codec->bus;
2998 if (!codec->power_on || codec->power_count) {
2999 codec->power_transition = 0;
3003 hda_call_codec_suspend(codec);
3004 if (bus->ops.pm_notify)
3005 bus->ops.pm_notify(bus);
3008 static void hda_keep_power_on(struct hda_codec *codec)
3010 codec->power_count++;
3011 codec->power_on = 1;
3014 void snd_hda_power_up(struct hda_codec *codec)
3016 struct hda_bus *bus = codec->bus;
3018 codec->power_count++;
3019 if (codec->power_on || codec->power_transition)
3022 codec->power_on = 1;
3023 if (bus->ops.pm_notify)
3024 bus->ops.pm_notify(bus);
3025 hda_call_codec_resume(codec);
3026 cancel_delayed_work(&codec->power_work);
3027 codec->power_transition = 0;
3029 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3031 #define power_save(codec) \
3032 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3034 #define power_save(codec) \
3035 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3037 void snd_hda_power_down(struct hda_codec *codec)
3039 --codec->power_count;
3040 if (!codec->power_on || codec->power_count || codec->power_transition)
3042 if (power_save(codec)) {
3043 codec->power_transition = 1; /* avoid reentrance */
3044 queue_delayed_work(codec->bus->workq, &codec->power_work,
3045 msecs_to_jiffies(power_save(codec) * 1000));
3048 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3050 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3051 struct hda_loopback_check *check,
3054 struct hda_amp_list *p;
3057 if (!check->amplist)
3059 for (p = check->amplist; p->nid; p++) {
3064 return 0; /* nothing changed */
3066 for (p = check->amplist; p->nid; p++) {
3067 for (ch = 0; ch < 2; ch++) {
3068 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3070 if (!(v & HDA_AMP_MUTE) && v > 0) {
3071 if (!check->power_on) {
3072 check->power_on = 1;
3073 snd_hda_power_up(codec);
3079 if (check->power_on) {
3080 check->power_on = 0;
3081 snd_hda_power_down(codec);
3085 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3089 * Channel mode helper
3091 int snd_hda_ch_mode_info(struct hda_codec *codec,
3092 struct snd_ctl_elem_info *uinfo,
3093 const struct hda_channel_mode *chmode,
3096 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3098 uinfo->value.enumerated.items = num_chmodes;
3099 if (uinfo->value.enumerated.item >= num_chmodes)
3100 uinfo->value.enumerated.item = num_chmodes - 1;
3101 sprintf(uinfo->value.enumerated.name, "%dch",
3102 chmode[uinfo->value.enumerated.item].channels);
3105 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3107 int snd_hda_ch_mode_get(struct hda_codec *codec,
3108 struct snd_ctl_elem_value *ucontrol,
3109 const struct hda_channel_mode *chmode,
3115 for (i = 0; i < num_chmodes; i++) {
3116 if (max_channels == chmode[i].channels) {
3117 ucontrol->value.enumerated.item[0] = i;
3123 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3125 int snd_hda_ch_mode_put(struct hda_codec *codec,
3126 struct snd_ctl_elem_value *ucontrol,
3127 const struct hda_channel_mode *chmode,
3133 mode = ucontrol->value.enumerated.item[0];
3134 if (mode >= num_chmodes)
3136 if (*max_channelsp == chmode[mode].channels)
3138 /* change the current channel setting */
3139 *max_channelsp = chmode[mode].channels;
3140 if (chmode[mode].sequence)
3141 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3144 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3149 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3150 struct snd_ctl_elem_info *uinfo)
3154 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3156 uinfo->value.enumerated.items = imux->num_items;
3157 if (!imux->num_items)
3159 index = uinfo->value.enumerated.item;
3160 if (index >= imux->num_items)
3161 index = imux->num_items - 1;
3162 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3165 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3167 int snd_hda_input_mux_put(struct hda_codec *codec,
3168 const struct hda_input_mux *imux,
3169 struct snd_ctl_elem_value *ucontrol,
3171 unsigned int *cur_val)
3175 if (!imux->num_items)
3177 idx = ucontrol->value.enumerated.item[0];
3178 if (idx >= imux->num_items)
3179 idx = imux->num_items - 1;
3180 if (*cur_val == idx)
3182 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3183 imux->items[idx].index);
3187 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3191 * Multi-channel / digital-out PCM helper functions
3194 /* setup SPDIF output stream */
3195 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3196 unsigned int stream_tag, unsigned int format)
3198 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3199 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3200 set_dig_out_convert(codec, nid,
3201 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3203 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3204 if (codec->slave_dig_outs) {
3206 for (d = codec->slave_dig_outs; *d; d++)
3207 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3210 /* turn on again (if needed) */
3211 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3212 set_dig_out_convert(codec, nid,
3213 codec->spdif_ctls & 0xff, -1);
3216 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3218 snd_hda_codec_cleanup_stream(codec, nid);
3219 if (codec->slave_dig_outs) {
3221 for (d = codec->slave_dig_outs; *d; d++)
3222 snd_hda_codec_cleanup_stream(codec, *d);
3227 * open the digital out in the exclusive mode
3229 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3230 struct hda_multi_out *mout)
3232 mutex_lock(&codec->spdif_mutex);
3233 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3234 /* already opened as analog dup; reset it once */
3235 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3236 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3237 mutex_unlock(&codec->spdif_mutex);
3240 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3242 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3243 struct hda_multi_out *mout,
3244 unsigned int stream_tag,
3245 unsigned int format,
3246 struct snd_pcm_substream *substream)
3248 mutex_lock(&codec->spdif_mutex);
3249 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3250 mutex_unlock(&codec->spdif_mutex);
3253 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3255 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3256 struct hda_multi_out *mout)
3258 mutex_lock(&codec->spdif_mutex);
3259 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3260 mutex_unlock(&codec->spdif_mutex);
3263 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3266 * release the digital out
3268 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3269 struct hda_multi_out *mout)
3271 mutex_lock(&codec->spdif_mutex);
3272 mout->dig_out_used = 0;
3273 mutex_unlock(&codec->spdif_mutex);
3276 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3279 * set up more restrictions for analog out
3281 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3282 struct hda_multi_out *mout,
3283 struct snd_pcm_substream *substream,
3284 struct hda_pcm_stream *hinfo)
3286 struct snd_pcm_runtime *runtime = substream->runtime;
3287 runtime->hw.channels_max = mout->max_channels;
3288 if (mout->dig_out_nid) {
3289 if (!mout->analog_rates) {
3290 mout->analog_rates = hinfo->rates;
3291 mout->analog_formats = hinfo->formats;
3292 mout->analog_maxbps = hinfo->maxbps;
3294 runtime->hw.rates = mout->analog_rates;
3295 runtime->hw.formats = mout->analog_formats;
3296 hinfo->maxbps = mout->analog_maxbps;
3298 if (!mout->spdif_rates) {
3299 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3301 &mout->spdif_formats,
3302 &mout->spdif_maxbps);
3304 mutex_lock(&codec->spdif_mutex);
3305 if (mout->share_spdif) {
3306 runtime->hw.rates &= mout->spdif_rates;
3307 runtime->hw.formats &= mout->spdif_formats;
3308 if (mout->spdif_maxbps < hinfo->maxbps)
3309 hinfo->maxbps = mout->spdif_maxbps;
3311 mutex_unlock(&codec->spdif_mutex);
3313 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3314 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3316 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3319 * set up the i/o for analog out
3320 * when the digital out is available, copy the front out to digital out, too.
3322 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3323 struct hda_multi_out *mout,
3324 unsigned int stream_tag,
3325 unsigned int format,
3326 struct snd_pcm_substream *substream)
3328 hda_nid_t *nids = mout->dac_nids;
3329 int chs = substream->runtime->channels;
3332 mutex_lock(&codec->spdif_mutex);
3333 if (mout->dig_out_nid && mout->share_spdif &&
3334 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3336 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3338 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3339 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3340 setup_dig_out_stream(codec, mout->dig_out_nid,
3341 stream_tag, format);
3343 mout->dig_out_used = 0;
3344 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3347 mutex_unlock(&codec->spdif_mutex);
3350 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3352 if (!mout->no_share_stream &&
3353 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3354 /* headphone out will just decode front left/right (stereo) */
3355 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3357 /* extra outputs copied from front */
3358 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3359 if (!mout->no_share_stream && mout->extra_out_nid[i])
3360 snd_hda_codec_setup_stream(codec,
3361 mout->extra_out_nid[i],
3362 stream_tag, 0, format);
3365 for (i = 1; i < mout->num_dacs; i++) {
3366 if (chs >= (i + 1) * 2) /* independent out */
3367 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3369 else if (!mout->no_share_stream) /* copy front */
3370 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3375 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3378 * clean up the setting for analog out
3380 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3381 struct hda_multi_out *mout)
3383 hda_nid_t *nids = mout->dac_nids;
3386 for (i = 0; i < mout->num_dacs; i++)
3387 snd_hda_codec_cleanup_stream(codec, nids[i]);
3389 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3390 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3391 if (mout->extra_out_nid[i])
3392 snd_hda_codec_cleanup_stream(codec,
3393 mout->extra_out_nid[i]);
3394 mutex_lock(&codec->spdif_mutex);
3395 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3396 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3397 mout->dig_out_used = 0;
3399 mutex_unlock(&codec->spdif_mutex);
3402 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3405 * Helper for automatic pin configuration
3408 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3410 for (; *list; list++)
3418 * Sort an associated group of pins according to their sequence numbers.
3420 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3427 for (i = 0; i < num_pins; i++) {
3428 for (j = i + 1; j < num_pins; j++) {
3429 if (sequences[i] > sequences[j]) {
3431 sequences[i] = sequences[j];
3443 * Parse all pin widgets and store the useful pin nids to cfg
3445 * The number of line-outs or any primary output is stored in line_outs,
3446 * and the corresponding output pins are assigned to line_out_pins[],
3447 * in the order of front, rear, CLFE, side, ...
3449 * If more extra outputs (speaker and headphone) are found, the pins are
3450 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3451 * is detected, one of speaker of HP pins is assigned as the primary
3452 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3453 * if any analog output exists.
3455 * The analog input pins are assigned to input_pins array.
3456 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3459 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3460 struct auto_pin_cfg *cfg,
3461 hda_nid_t *ignore_nids)
3463 hda_nid_t nid, end_nid;
3464 short seq, assoc_line_out, assoc_speaker;
3465 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3466 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3467 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3469 memset(cfg, 0, sizeof(*cfg));
3471 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3472 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3473 memset(sequences_hp, 0, sizeof(sequences_hp));
3474 assoc_line_out = assoc_speaker = 0;
3476 end_nid = codec->start_nid + codec->num_nodes;
3477 for (nid = codec->start_nid; nid < end_nid; nid++) {
3478 unsigned int wid_caps = get_wcaps(codec, nid);
3479 unsigned int wid_type =
3480 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3481 unsigned int def_conf;
3484 /* read all default configuration for pin complex */
3485 if (wid_type != AC_WID_PIN)
3487 /* ignore the given nids (e.g. pc-beep returns error) */
3488 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3491 def_conf = snd_hda_codec_read(codec, nid, 0,
3492 AC_VERB_GET_CONFIG_DEFAULT, 0);
3493 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3495 loc = get_defcfg_location(def_conf);
3496 switch (get_defcfg_device(def_conf)) {
3497 case AC_JACK_LINE_OUT:
3498 seq = get_defcfg_sequence(def_conf);
3499 assoc = get_defcfg_association(def_conf);
3501 if (!(wid_caps & AC_WCAP_STEREO))
3502 if (!cfg->mono_out_pin)
3503 cfg->mono_out_pin = nid;
3506 if (!assoc_line_out)
3507 assoc_line_out = assoc;
3508 else if (assoc_line_out != assoc)
3510 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3512 cfg->line_out_pins[cfg->line_outs] = nid;
3513 sequences_line_out[cfg->line_outs] = seq;
3516 case AC_JACK_SPEAKER:
3517 seq = get_defcfg_sequence(def_conf);
3518 assoc = get_defcfg_association(def_conf);
3521 if (! assoc_speaker)
3522 assoc_speaker = assoc;
3523 else if (assoc_speaker != assoc)
3525 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3527 cfg->speaker_pins[cfg->speaker_outs] = nid;
3528 sequences_speaker[cfg->speaker_outs] = seq;
3529 cfg->speaker_outs++;
3531 case AC_JACK_HP_OUT:
3532 seq = get_defcfg_sequence(def_conf);
3533 assoc = get_defcfg_association(def_conf);
3534 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3536 cfg->hp_pins[cfg->hp_outs] = nid;
3537 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3540 case AC_JACK_MIC_IN: {
3542 if (loc == AC_JACK_LOC_FRONT) {
3543 preferred = AUTO_PIN_FRONT_MIC;
3546 preferred = AUTO_PIN_MIC;
3547 alt = AUTO_PIN_FRONT_MIC;
3549 if (!cfg->input_pins[preferred])
3550 cfg->input_pins[preferred] = nid;
3551 else if (!cfg->input_pins[alt])
3552 cfg->input_pins[alt] = nid;
3555 case AC_JACK_LINE_IN:
3556 if (loc == AC_JACK_LOC_FRONT)
3557 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3559 cfg->input_pins[AUTO_PIN_LINE] = nid;
3562 cfg->input_pins[AUTO_PIN_CD] = nid;
3565 cfg->input_pins[AUTO_PIN_AUX] = nid;
3567 case AC_JACK_SPDIF_OUT:
3568 case AC_JACK_DIG_OTHER_OUT:
3569 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3571 cfg->dig_out_pins[cfg->dig_outs] = nid;
3572 cfg->dig_out_type[cfg->dig_outs] =
3573 (loc == AC_JACK_LOC_HDMI) ?
3574 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3577 case AC_JACK_SPDIF_IN:
3578 case AC_JACK_DIG_OTHER_IN:
3579 cfg->dig_in_pin = nid;
3580 if (loc == AC_JACK_LOC_HDMI)
3581 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3583 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
3589 * If no line-out is defined but multiple HPs are found,
3590 * some of them might be the real line-outs.
3592 if (!cfg->line_outs && cfg->hp_outs > 1) {
3594 while (i < cfg->hp_outs) {
3595 /* The real HPs should have the sequence 0x0f */
3596 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3600 /* Move it to the line-out table */
3601 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3602 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3605 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3606 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3607 memmove(sequences_hp + i - 1, sequences_hp + i,
3608 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3612 /* sort by sequence */
3613 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3615 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3617 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3620 /* if we have only one mic, make it AUTO_PIN_MIC */
3621 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3622 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3623 cfg->input_pins[AUTO_PIN_MIC] =
3624 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3625 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3627 /* ditto for line-in */
3628 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3629 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3630 cfg->input_pins[AUTO_PIN_LINE] =
3631 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3632 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3636 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3637 * as a primary output
3639 if (!cfg->line_outs) {
3640 if (cfg->speaker_outs) {
3641 cfg->line_outs = cfg->speaker_outs;
3642 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3643 sizeof(cfg->speaker_pins));
3644 cfg->speaker_outs = 0;
3645 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3646 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3647 } else if (cfg->hp_outs) {
3648 cfg->line_outs = cfg->hp_outs;
3649 memcpy(cfg->line_out_pins, cfg->hp_pins,
3650 sizeof(cfg->hp_pins));
3652 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3653 cfg->line_out_type = AUTO_PIN_HP_OUT;
3657 /* Reorder the surround channels
3658 * ALSA sequence is front/surr/clfe/side
3660 * 4-ch: front/surr => OK as it is
3661 * 6-ch: front/clfe/surr
3662 * 8-ch: front/clfe/rear/side|fc
3664 switch (cfg->line_outs) {
3667 nid = cfg->line_out_pins[1];
3668 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3669 cfg->line_out_pins[2] = nid;
3674 * debug prints of the parsed results
3676 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3677 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3678 cfg->line_out_pins[2], cfg->line_out_pins[3],
3679 cfg->line_out_pins[4]);
3680 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3681 cfg->speaker_outs, cfg->speaker_pins[0],
3682 cfg->speaker_pins[1], cfg->speaker_pins[2],
3683 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3684 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3685 cfg->hp_outs, cfg->hp_pins[0],
3686 cfg->hp_pins[1], cfg->hp_pins[2],
3687 cfg->hp_pins[3], cfg->hp_pins[4]);
3688 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3690 snd_printd(" dig-out=0x%x/0x%x\n",
3691 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
3692 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3693 " cd=0x%x, aux=0x%x\n",
3694 cfg->input_pins[AUTO_PIN_MIC],
3695 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3696 cfg->input_pins[AUTO_PIN_LINE],
3697 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3698 cfg->input_pins[AUTO_PIN_CD],
3699 cfg->input_pins[AUTO_PIN_AUX]);
3700 if (cfg->dig_in_pin)
3701 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
3705 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3707 /* labels for input pins */
3708 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3709 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3711 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3720 * snd_hda_suspend - suspend the codecs
3722 * @state: suspsend state
3724 * Returns 0 if successful.
3726 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3728 struct hda_codec *codec;
3730 list_for_each_entry(codec, &bus->codec_list, list) {
3731 #ifdef CONFIG_SND_HDA_POWER_SAVE
3732 if (!codec->power_on)
3735 hda_call_codec_suspend(codec);
3739 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3742 * snd_hda_resume - resume the codecs
3745 * Returns 0 if successful.
3747 * This fucntion is defined only when POWER_SAVE isn't set.
3748 * In the power-save mode, the codec is resumed dynamically.
3750 int snd_hda_resume(struct hda_bus *bus)
3752 struct hda_codec *codec;
3754 list_for_each_entry(codec, &bus->codec_list, list) {
3755 if (snd_hda_codec_needs_resume(codec))
3756 hda_call_codec_resume(codec);
3760 EXPORT_SYMBOL_HDA(snd_hda_resume);
3761 #endif /* CONFIG_PM */
3767 /* get a new element from the given array
3768 * if it exceeds the pre-allocated array size, re-allocate the array
3770 void *snd_array_new(struct snd_array *array)
3772 if (array->used >= array->alloced) {
3773 int num = array->alloced + array->alloc_align;
3775 if (snd_BUG_ON(num >= 4096))
3777 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3781 memcpy(nlist, array->list,
3782 array->elem_size * array->alloced);
3785 array->list = nlist;
3786 array->alloced = num;
3788 return snd_array_elem(array, array->used++);
3790 EXPORT_SYMBOL_HDA(snd_array_new);
3792 /* free the given array elements */
3793 void snd_array_free(struct snd_array *array)
3800 EXPORT_SYMBOL_HDA(snd_array_free);
3803 * used by hda_proc.c and hda_eld.c
3805 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3807 static unsigned int rates[] = {
3808 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3809 96000, 176400, 192000, 384000
3813 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3815 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3817 buf[j] = '\0'; /* necessary when j == 0 */
3819 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3821 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3823 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3826 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3827 if (pcm & (AC_SUPPCM_BITS_8 << i))
3828 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3830 buf[j] = '\0'; /* necessary when j == 0 */
3832 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
3834 MODULE_DESCRIPTION("HDA codec core");
3835 MODULE_LICENSE("GPL");