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"
34 #include <sound/hda_hwdep.h>
37 * vendor / preset table
40 struct hda_vendor_id {
45 /* codec vendor labels */
46 static struct hda_vendor_id hda_vendor_ids[] = {
48 { 0x1013, "Cirrus Logic" },
49 { 0x1057, "Motorola" },
50 { 0x1095, "Silicon Image" },
52 { 0x10ec, "Realtek" },
53 { 0x1102, "Creative" },
57 { 0x11d4, "Analog Devices" },
58 { 0x13f6, "C-Media" },
59 { 0x14f1, "Conexant" },
60 { 0x17e8, "Chrontel" },
62 { 0x1aec, "Wolfson Microelectronics" },
63 { 0x434d, "C-Media" },
65 { 0x8384, "SigmaTel" },
69 static DEFINE_MUTEX(preset_mutex);
70 static LIST_HEAD(hda_preset_tables);
72 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
74 mutex_lock(&preset_mutex);
75 list_add_tail(&preset->list, &hda_preset_tables);
76 mutex_unlock(&preset_mutex);
79 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
81 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
83 mutex_lock(&preset_mutex);
84 list_del(&preset->list);
85 mutex_unlock(&preset_mutex);
88 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
90 #ifdef CONFIG_SND_HDA_POWER_SAVE
91 static void hda_power_work(struct work_struct *work);
92 static void hda_keep_power_on(struct hda_codec *codec);
94 static inline void hda_keep_power_on(struct hda_codec *codec) {}
98 * snd_hda_get_jack_location - Give a location string of the jack
99 * @cfg: pin default config value
101 * Parse the pin default config value and returns the string of the
102 * jack location, e.g. "Rear", "Front", etc.
104 const char *snd_hda_get_jack_location(u32 cfg)
106 static char *bases[7] = {
107 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
109 static unsigned char specials_idx[] = {
114 static char *specials[] = {
115 "Rear Panel", "Drive Bar",
116 "Riser", "HDMI", "ATAPI",
117 "Mobile-In", "Mobile-Out"
120 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
121 if ((cfg & 0x0f) < 7)
122 return bases[cfg & 0x0f];
123 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
124 if (cfg == specials_idx[i])
129 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
132 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
133 * @cfg: pin default config value
135 * Parse the pin default config value and returns the string of the
136 * jack connectivity, i.e. external or internal connection.
138 const char *snd_hda_get_jack_connectivity(u32 cfg)
140 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
142 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
144 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
147 * snd_hda_get_jack_type - Give a type string of the jack
148 * @cfg: pin default config value
150 * Parse the pin default config value and returns the string of the
151 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
153 const char *snd_hda_get_jack_type(u32 cfg)
155 static char *jack_types[16] = {
156 "Line Out", "Speaker", "HP Out", "CD",
157 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
158 "Line In", "Aux", "Mic", "Telephony",
159 "SPDIF In", "Digitial In", "Reserved", "Other"
162 return jack_types[(cfg & AC_DEFCFG_DEVICE)
163 >> AC_DEFCFG_DEVICE_SHIFT];
165 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
168 * Compose a 32bit command word to be sent to the HD-audio controller
170 static inline unsigned int
171 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
172 unsigned int verb, unsigned int parm)
176 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
177 (verb & ~0xfff) || (parm & ~0xffff)) {
178 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
179 codec->addr, direct, nid, verb, parm);
183 val = (u32)codec->addr << 28;
184 val |= (u32)direct << 27;
185 val |= (u32)nid << 20;
192 * Send and receive a verb
194 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
197 struct hda_bus *bus = codec->bus;
206 snd_hda_power_up(codec);
207 mutex_lock(&bus->cmd_mutex);
208 err = bus->ops.command(bus, cmd);
210 *res = bus->ops.get_response(bus, codec->addr);
211 mutex_unlock(&bus->cmd_mutex);
212 snd_hda_power_down(codec);
213 if (res && *res == -1 && bus->rirb_error) {
214 if (bus->response_reset) {
215 snd_printd("hda_codec: resetting BUS due to "
216 "fatal communication error\n");
217 bus->ops.bus_reset(bus);
221 /* clear reset-flag when the communication gets recovered */
223 bus->response_reset = 0;
228 * snd_hda_codec_read - send a command and get the response
229 * @codec: the HDA codec
230 * @nid: NID to send the command
231 * @direct: direct flag
232 * @verb: the verb to send
233 * @parm: the parameter for the verb
235 * Send a single command and read the corresponding response.
237 * Returns the obtained response value, or -1 for an error.
239 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
241 unsigned int verb, unsigned int parm)
243 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
245 codec_exec_verb(codec, cmd, &res);
248 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
251 * snd_hda_codec_write - send a single command without waiting for response
252 * @codec: the HDA codec
253 * @nid: NID to send the command
254 * @direct: direct flag
255 * @verb: the verb to send
256 * @parm: the parameter for the verb
258 * Send a single command without waiting for response.
260 * Returns 0 if successful, or a negative error code.
262 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
263 unsigned int verb, unsigned int parm)
265 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
267 return codec_exec_verb(codec, cmd,
268 codec->bus->sync_write ? &res : NULL);
270 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
273 * snd_hda_sequence_write - sequence writes
274 * @codec: the HDA codec
275 * @seq: VERB array to send
277 * Send the commands sequentially from the given array.
278 * The array must be terminated with NID=0.
280 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
282 for (; seq->nid; seq++)
283 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
285 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
288 * snd_hda_get_sub_nodes - get the range of sub nodes
289 * @codec: the HDA codec
291 * @start_id: the pointer to store the start NID
293 * Parse the NID and store the start NID of its sub-nodes.
294 * Returns the number of sub-nodes.
296 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
301 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
304 *start_id = (parm >> 16) & 0x7fff;
305 return (int)(parm & 0x7fff);
307 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
310 * snd_hda_get_connections - get connection list
311 * @codec: the HDA codec
313 * @conn_list: connection list array
314 * @max_conns: max. number of connections to store
316 * Parses the connection list of the given widget and stores the list
319 * Returns the number of connections, or a negative error code.
321 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
322 hda_nid_t *conn_list, int max_conns)
325 int i, conn_len, conns;
326 unsigned int shift, num_elems, mask;
330 if (snd_BUG_ON(!conn_list || max_conns <= 0))
333 wcaps = get_wcaps(codec, nid);
334 if (!(wcaps & AC_WCAP_CONN_LIST) &&
335 get_wcaps_type(wcaps) != AC_WID_VOL_KNB) {
336 snd_printk(KERN_WARNING "hda_codec: "
337 "connection list not available for 0x%x\n", nid);
341 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
342 if (parm & AC_CLIST_LONG) {
351 conn_len = parm & AC_CLIST_LENGTH;
352 mask = (1 << (shift-1)) - 1;
355 return 0; /* no connection */
358 /* single connection */
359 parm = snd_hda_codec_read(codec, nid, 0,
360 AC_VERB_GET_CONNECT_LIST, 0);
361 if (parm == -1 && codec->bus->rirb_error)
363 conn_list[0] = parm & mask;
367 /* multi connection */
370 for (i = 0; i < conn_len; i++) {
374 if (i % num_elems == 0) {
375 parm = snd_hda_codec_read(codec, nid, 0,
376 AC_VERB_GET_CONNECT_LIST, i);
377 if (parm == -1 && codec->bus->rirb_error)
380 range_val = !!(parm & (1 << (shift-1))); /* ranges */
383 snd_printk(KERN_WARNING "hda_codec: "
384 "invalid CONNECT_LIST verb %x[%i]:%x\n",
390 /* ranges between the previous and this one */
391 if (!prev_nid || prev_nid >= val) {
392 snd_printk(KERN_WARNING "hda_codec: "
393 "invalid dep_range_val %x:%x\n",
397 for (n = prev_nid + 1; n <= val; n++) {
398 if (conns >= max_conns) {
400 "Too many connections\n");
403 conn_list[conns++] = n;
406 if (conns >= max_conns) {
407 snd_printk(KERN_ERR "Too many connections\n");
410 conn_list[conns++] = val;
416 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
420 * snd_hda_queue_unsol_event - add an unsolicited event to queue
422 * @res: unsolicited event (lower 32bit of RIRB entry)
423 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
425 * Adds the given event to the queue. The events are processed in
426 * the workqueue asynchronously. Call this function in the interrupt
427 * hanlder when RIRB receives an unsolicited event.
429 * Returns 0 if successful, or a negative error code.
431 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
433 struct hda_bus_unsolicited *unsol;
440 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
444 unsol->queue[wp] = res;
445 unsol->queue[wp + 1] = res_ex;
447 queue_work(bus->workq, &unsol->work);
451 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
454 * process queued unsolicited events
456 static void process_unsol_events(struct work_struct *work)
458 struct hda_bus_unsolicited *unsol =
459 container_of(work, struct hda_bus_unsolicited, work);
460 struct hda_bus *bus = unsol->bus;
461 struct hda_codec *codec;
462 unsigned int rp, caddr, res;
464 while (unsol->rp != unsol->wp) {
465 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
468 res = unsol->queue[rp];
469 caddr = unsol->queue[rp + 1];
470 if (!(caddr & (1 << 4))) /* no unsolicited event? */
472 codec = bus->caddr_tbl[caddr & 0x0f];
473 if (codec && codec->patch_ops.unsol_event)
474 codec->patch_ops.unsol_event(codec, res);
479 * initialize unsolicited queue
481 static int init_unsol_queue(struct hda_bus *bus)
483 struct hda_bus_unsolicited *unsol;
485 if (bus->unsol) /* already initialized */
488 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
490 snd_printk(KERN_ERR "hda_codec: "
491 "can't allocate unsolicited queue\n");
494 INIT_WORK(&unsol->work, process_unsol_events);
503 static void snd_hda_codec_free(struct hda_codec *codec);
505 static int snd_hda_bus_free(struct hda_bus *bus)
507 struct hda_codec *codec, *n;
512 flush_workqueue(bus->workq);
515 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
516 snd_hda_codec_free(codec);
518 if (bus->ops.private_free)
519 bus->ops.private_free(bus);
521 destroy_workqueue(bus->workq);
526 static int snd_hda_bus_dev_free(struct snd_device *device)
528 struct hda_bus *bus = device->device_data;
530 return snd_hda_bus_free(bus);
533 #ifdef CONFIG_SND_HDA_HWDEP
534 static int snd_hda_bus_dev_register(struct snd_device *device)
536 struct hda_bus *bus = device->device_data;
537 struct hda_codec *codec;
538 list_for_each_entry(codec, &bus->codec_list, list) {
539 snd_hda_hwdep_add_sysfs(codec);
540 snd_hda_hwdep_add_power_sysfs(codec);
545 #define snd_hda_bus_dev_register NULL
549 * snd_hda_bus_new - create a HDA bus
550 * @card: the card entry
551 * @temp: the template for hda_bus information
552 * @busp: the pointer to store the created bus instance
554 * Returns 0 if successful, or a negative error code.
556 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
557 const struct hda_bus_template *temp,
558 struct hda_bus **busp)
562 static struct snd_device_ops dev_ops = {
563 .dev_register = snd_hda_bus_dev_register,
564 .dev_free = snd_hda_bus_dev_free,
567 if (snd_BUG_ON(!temp))
569 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
575 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
577 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
582 bus->private_data = temp->private_data;
583 bus->pci = temp->pci;
584 bus->modelname = temp->modelname;
585 bus->power_save = temp->power_save;
586 bus->ops = temp->ops;
588 mutex_init(&bus->cmd_mutex);
589 INIT_LIST_HEAD(&bus->codec_list);
591 snprintf(bus->workq_name, sizeof(bus->workq_name),
592 "hd-audio%d", card->number);
593 bus->workq = create_singlethread_workqueue(bus->workq_name);
595 snd_printk(KERN_ERR "cannot create workqueue %s\n",
601 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
603 snd_hda_bus_free(bus);
610 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
612 #ifdef CONFIG_SND_HDA_GENERIC
613 #define is_generic_config(codec) \
614 (codec->modelname && !strcmp(codec->modelname, "generic"))
616 #define is_generic_config(codec) 0
620 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
622 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
626 * find a matching codec preset
628 static const struct hda_codec_preset *
629 find_codec_preset(struct hda_codec *codec)
631 struct hda_codec_preset_list *tbl;
632 const struct hda_codec_preset *preset;
633 int mod_requested = 0;
635 if (is_generic_config(codec))
636 return NULL; /* use the generic parser */
639 mutex_lock(&preset_mutex);
640 list_for_each_entry(tbl, &hda_preset_tables, list) {
641 if (!try_module_get(tbl->owner)) {
642 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
645 for (preset = tbl->preset; preset->id; preset++) {
646 u32 mask = preset->mask;
647 if (preset->afg && preset->afg != codec->afg)
649 if (preset->mfg && preset->mfg != codec->mfg)
653 if (preset->id == (codec->vendor_id & mask) &&
655 preset->rev == codec->revision_id)) {
656 mutex_unlock(&preset_mutex);
657 codec->owner = tbl->owner;
661 module_put(tbl->owner);
663 mutex_unlock(&preset_mutex);
665 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
668 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
671 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
672 (codec->vendor_id >> 16) & 0xffff);
673 request_module(name);
681 * get_codec_name - store the codec name
683 static int get_codec_name(struct hda_codec *codec)
685 const struct hda_vendor_id *c;
686 const char *vendor = NULL;
687 u16 vendor_id = codec->vendor_id >> 16;
690 if (codec->vendor_name)
693 for (c = hda_vendor_ids; c->id; c++) {
694 if (c->id == vendor_id) {
700 sprintf(tmp, "Generic %04x", vendor_id);
703 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
704 if (!codec->vendor_name)
708 if (codec->chip_name)
711 if (codec->preset && codec->preset->name)
712 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
714 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
715 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
717 if (!codec->chip_name)
723 * look for an AFG and MFG nodes
725 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
727 int i, total_nodes, function_id;
730 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
731 for (i = 0; i < total_nodes; i++, nid++) {
732 function_id = snd_hda_param_read(codec, nid,
733 AC_PAR_FUNCTION_TYPE) & 0xff;
734 switch (function_id) {
735 case AC_GRP_AUDIO_FUNCTION:
737 codec->function_id = function_id;
739 case AC_GRP_MODEM_FUNCTION:
741 codec->function_id = function_id;
750 * read widget caps for each widget and store in cache
752 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
757 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
759 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
762 nid = codec->start_nid;
763 for (i = 0; i < codec->num_nodes; i++, nid++)
764 codec->wcaps[i] = snd_hda_param_read(codec, nid,
765 AC_PAR_AUDIO_WIDGET_CAP);
769 /* read all pin default configurations and save codec->init_pins */
770 static int read_pin_defaults(struct hda_codec *codec)
773 hda_nid_t nid = codec->start_nid;
775 for (i = 0; i < codec->num_nodes; i++, nid++) {
776 struct hda_pincfg *pin;
777 unsigned int wcaps = get_wcaps(codec, nid);
778 unsigned int wid_type = get_wcaps_type(wcaps);
779 if (wid_type != AC_WID_PIN)
781 pin = snd_array_new(&codec->init_pins);
785 pin->cfg = snd_hda_codec_read(codec, nid, 0,
786 AC_VERB_GET_CONFIG_DEFAULT, 0);
791 /* look up the given pin config list and return the item matching with NID */
792 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
793 struct snd_array *array,
797 for (i = 0; i < array->used; i++) {
798 struct hda_pincfg *pin = snd_array_elem(array, i);
805 /* write a config value for the given NID */
806 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
810 for (i = 0; i < 4; i++) {
811 snd_hda_codec_write(codec, nid, 0,
812 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
818 /* set the current pin config value for the given NID.
819 * the value is cached, and read via snd_hda_codec_get_pincfg()
821 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
822 hda_nid_t nid, unsigned int cfg)
824 struct hda_pincfg *pin;
827 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
828 pin = look_up_pincfg(codec, list, nid);
830 pin = snd_array_new(list);
837 /* change only when needed; e.g. if the pincfg is already present
838 * in user_pins[], don't write it
840 cfg = snd_hda_codec_get_pincfg(codec, nid);
842 set_pincfg(codec, nid, cfg);
847 * snd_hda_codec_set_pincfg - Override a pin default configuration
848 * @codec: the HDA codec
849 * @nid: NID to set the pin config
850 * @cfg: the pin default config value
852 * Override a pin default configuration value in the cache.
853 * This value can be read by snd_hda_codec_get_pincfg() in a higher
854 * priority than the real hardware value.
856 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
857 hda_nid_t nid, unsigned int cfg)
859 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
861 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
864 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
865 * @codec: the HDA codec
866 * @nid: NID to get the pin config
868 * Get the current pin config value of the given pin NID.
869 * If the pincfg value is cached or overridden via sysfs or driver,
870 * returns the cached value.
872 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
874 struct hda_pincfg *pin;
876 #ifdef CONFIG_SND_HDA_HWDEP
877 pin = look_up_pincfg(codec, &codec->user_pins, nid);
881 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
884 pin = look_up_pincfg(codec, &codec->init_pins, nid);
889 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
891 /* restore all current pin configs */
892 static void restore_pincfgs(struct hda_codec *codec)
895 for (i = 0; i < codec->init_pins.used; i++) {
896 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
897 set_pincfg(codec, pin->nid,
898 snd_hda_codec_get_pincfg(codec, pin->nid));
902 static void init_hda_cache(struct hda_cache_rec *cache,
903 unsigned int record_size);
904 static void free_hda_cache(struct hda_cache_rec *cache);
906 /* restore the initial pin cfgs and release all pincfg lists */
907 static void restore_init_pincfgs(struct hda_codec *codec)
909 /* first free driver_pins and user_pins, then call restore_pincfg
910 * so that only the values in init_pins are restored
912 snd_array_free(&codec->driver_pins);
913 #ifdef CONFIG_SND_HDA_HWDEP
914 snd_array_free(&codec->user_pins);
916 restore_pincfgs(codec);
917 snd_array_free(&codec->init_pins);
923 static void snd_hda_codec_free(struct hda_codec *codec)
927 restore_init_pincfgs(codec);
928 #ifdef CONFIG_SND_HDA_POWER_SAVE
929 cancel_delayed_work(&codec->power_work);
930 flush_workqueue(codec->bus->workq);
932 list_del(&codec->list);
933 snd_array_free(&codec->mixers);
934 codec->bus->caddr_tbl[codec->addr] = NULL;
935 if (codec->patch_ops.free)
936 codec->patch_ops.free(codec);
937 module_put(codec->owner);
938 free_hda_cache(&codec->amp_cache);
939 free_hda_cache(&codec->cmd_cache);
940 kfree(codec->vendor_name);
941 kfree(codec->chip_name);
942 kfree(codec->modelname);
947 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
948 unsigned int power_state);
951 * snd_hda_codec_new - create a HDA codec
952 * @bus: the bus to assign
953 * @codec_addr: the codec address
954 * @codecp: the pointer to store the generated codec
956 * Returns 0 if successful, or a negative error code.
958 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
959 struct hda_codec **codecp)
961 struct hda_codec *codec;
965 if (snd_BUG_ON(!bus))
967 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
970 if (bus->caddr_tbl[codec_addr]) {
971 snd_printk(KERN_ERR "hda_codec: "
972 "address 0x%x is already occupied\n", codec_addr);
976 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
978 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
983 codec->addr = codec_addr;
984 mutex_init(&codec->spdif_mutex);
985 mutex_init(&codec->control_mutex);
986 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
987 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
988 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 60);
989 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
990 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
991 if (codec->bus->modelname) {
992 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
993 if (!codec->modelname) {
994 snd_hda_codec_free(codec);
999 #ifdef CONFIG_SND_HDA_POWER_SAVE
1000 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1001 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1002 * the caller has to power down appropriatley after initialization
1005 hda_keep_power_on(codec);
1008 list_add_tail(&codec->list, &bus->codec_list);
1009 bus->caddr_tbl[codec_addr] = codec;
1011 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1013 if (codec->vendor_id == -1)
1014 /* read again, hopefully the access method was corrected
1015 * in the last read...
1017 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1019 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1020 AC_PAR_SUBSYSTEM_ID);
1021 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1024 setup_fg_nodes(codec);
1025 if (!codec->afg && !codec->mfg) {
1026 snd_printdd("hda_codec: no AFG or MFG node found\n");
1031 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1033 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1036 err = read_pin_defaults(codec);
1040 if (!codec->subsystem_id) {
1041 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
1042 codec->subsystem_id =
1043 snd_hda_codec_read(codec, nid, 0,
1044 AC_VERB_GET_SUBSYSTEM_ID, 0);
1047 /* power-up all before initialization */
1048 hda_set_power_state(codec,
1049 codec->afg ? codec->afg : codec->mfg,
1052 snd_hda_codec_proc_new(codec);
1054 snd_hda_create_hwdep(codec);
1056 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1057 codec->subsystem_id, codec->revision_id);
1058 snd_component_add(codec->bus->card, component);
1065 snd_hda_codec_free(codec);
1068 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1071 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1072 * @codec: the HDA codec
1074 * Start parsing of the given codec tree and (re-)initialize the whole
1077 * Returns 0 if successful or a negative error code.
1079 int snd_hda_codec_configure(struct hda_codec *codec)
1083 codec->preset = find_codec_preset(codec);
1084 if (!codec->vendor_name || !codec->chip_name) {
1085 err = get_codec_name(codec);
1089 /* audio codec should override the mixer name */
1090 if (codec->afg || !*codec->bus->card->mixername)
1091 snprintf(codec->bus->card->mixername,
1092 sizeof(codec->bus->card->mixername),
1093 "%s %s", codec->vendor_name, codec->chip_name);
1095 if (is_generic_config(codec)) {
1096 err = snd_hda_parse_generic_codec(codec);
1099 if (codec->preset && codec->preset->patch) {
1100 err = codec->preset->patch(codec);
1104 /* call the default parser */
1105 err = snd_hda_parse_generic_codec(codec);
1107 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1110 if (!err && codec->patch_ops.unsol_event)
1111 err = init_unsol_queue(codec->bus);
1114 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1117 * snd_hda_codec_setup_stream - set up the codec for streaming
1118 * @codec: the CODEC to set up
1119 * @nid: the NID to set up
1120 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1121 * @channel_id: channel id to pass, zero based.
1122 * @format: stream format.
1124 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1126 int channel_id, int format)
1131 snd_printdd("hda_codec_setup_stream: "
1132 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1133 nid, stream_tag, channel_id, format);
1134 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1135 (stream_tag << 4) | channel_id);
1137 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1139 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1142 * snd_hda_codec_cleanup_stream - clean up the codec for closing
1143 * @codec: the CODEC to clean up
1144 * @nid: the NID to clean up
1146 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1151 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1152 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1153 #if 0 /* keep the format */
1155 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1158 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
1161 * amp access functions
1164 /* FIXME: more better hash key? */
1165 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1166 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1167 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1168 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1169 #define INFO_AMP_CAPS (1<<0)
1170 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1172 /* initialize the hash table */
1173 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1174 unsigned int record_size)
1176 memset(cache, 0, sizeof(*cache));
1177 memset(cache->hash, 0xff, sizeof(cache->hash));
1178 snd_array_init(&cache->buf, record_size, 64);
1181 static void free_hda_cache(struct hda_cache_rec *cache)
1183 snd_array_free(&cache->buf);
1186 /* query the hash. allocate an entry if not found. */
1187 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1190 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1191 u16 cur = cache->hash[idx];
1192 struct hda_cache_head *info;
1194 while (cur != 0xffff) {
1195 info = snd_array_elem(&cache->buf, cur);
1196 if (info->key == key)
1201 /* add a new hash entry */
1202 info = snd_array_new(&cache->buf);
1205 cur = snd_array_index(&cache->buf, info);
1208 info->next = cache->hash[idx];
1209 cache->hash[idx] = cur;
1214 /* query and allocate an amp hash entry */
1215 static inline struct hda_amp_info *
1216 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1218 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1222 * query_amp_caps - query AMP capabilities
1223 * @codec: the HD-auio codec
1224 * @nid: the NID to query
1225 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1227 * Query AMP capabilities for the given widget and direction.
1228 * Returns the obtained capability bits.
1230 * When cap bits have been already read, this doesn't read again but
1231 * returns the cached value.
1233 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1235 struct hda_amp_info *info;
1237 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1240 if (!(info->head.val & INFO_AMP_CAPS)) {
1241 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1243 info->amp_caps = snd_hda_param_read(codec, nid,
1244 direction == HDA_OUTPUT ?
1245 AC_PAR_AMP_OUT_CAP :
1248 info->head.val |= INFO_AMP_CAPS;
1250 return info->amp_caps;
1252 EXPORT_SYMBOL_HDA(query_amp_caps);
1255 * snd_hda_override_amp_caps - Override the AMP capabilities
1256 * @codec: the CODEC to clean up
1257 * @nid: the NID to clean up
1258 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1259 * @caps: the capability bits to set
1261 * Override the cached AMP caps bits value by the given one.
1262 * This function is useful if the driver needs to adjust the AMP ranges,
1263 * e.g. limit to 0dB, etc.
1265 * Returns zero if successful or a negative error code.
1267 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1270 struct hda_amp_info *info;
1272 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1275 info->amp_caps = caps;
1276 info->head.val |= INFO_AMP_CAPS;
1279 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1282 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1283 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1285 struct hda_amp_info *info;
1287 info = get_alloc_amp_hash(codec, key);
1290 if (!info->head.val) {
1291 info->head.val |= INFO_AMP_CAPS;
1292 info->amp_caps = func(codec, nid);
1294 return info->amp_caps;
1297 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1299 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1303 * snd_hda_query_pin_caps - Query PIN capabilities
1304 * @codec: the HD-auio codec
1305 * @nid: the NID to query
1307 * Query PIN capabilities for the given widget.
1308 * Returns the obtained capability bits.
1310 * When cap bits have been already read, this doesn't read again but
1311 * returns the cached value.
1313 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1315 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1318 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1321 * read the current volume to info
1322 * if the cache exists, read the cache value.
1324 static unsigned int get_vol_mute(struct hda_codec *codec,
1325 struct hda_amp_info *info, hda_nid_t nid,
1326 int ch, int direction, int index)
1330 if (info->head.val & INFO_AMP_VOL(ch))
1331 return info->vol[ch];
1333 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1334 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1336 val = snd_hda_codec_read(codec, nid, 0,
1337 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1338 info->vol[ch] = val & 0xff;
1339 info->head.val |= INFO_AMP_VOL(ch);
1340 return info->vol[ch];
1344 * write the current volume in info to the h/w and update the cache
1346 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1347 hda_nid_t nid, int ch, int direction, int index,
1352 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1353 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1354 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1356 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1357 info->vol[ch] = val;
1361 * snd_hda_codec_amp_read - Read AMP value
1362 * @codec: HD-audio codec
1363 * @nid: NID to read the AMP value
1364 * @ch: channel (left=0 or right=1)
1365 * @direction: #HDA_INPUT or #HDA_OUTPUT
1366 * @index: the index value (only for input direction)
1368 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1370 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1371 int direction, int index)
1373 struct hda_amp_info *info;
1374 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1377 return get_vol_mute(codec, info, nid, ch, direction, index);
1379 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1382 * snd_hda_codec_amp_update - update the AMP value
1383 * @codec: HD-audio codec
1384 * @nid: NID to read the AMP value
1385 * @ch: channel (left=0 or right=1)
1386 * @direction: #HDA_INPUT or #HDA_OUTPUT
1387 * @idx: the index value (only for input direction)
1388 * @mask: bit mask to set
1389 * @val: the bits value to set
1391 * Update the AMP value with a bit mask.
1392 * Returns 0 if the value is unchanged, 1 if changed.
1394 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1395 int direction, int idx, int mask, int val)
1397 struct hda_amp_info *info;
1399 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1403 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1404 if (info->vol[ch] == val)
1406 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1409 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1412 * snd_hda_codec_amp_stereo - update the AMP stereo values
1413 * @codec: HD-audio codec
1414 * @nid: NID to read the AMP value
1415 * @direction: #HDA_INPUT or #HDA_OUTPUT
1416 * @idx: the index value (only for input direction)
1417 * @mask: bit mask to set
1418 * @val: the bits value to set
1420 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1421 * stereo widget with the same mask and value.
1423 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1424 int direction, int idx, int mask, int val)
1427 for (ch = 0; ch < 2; ch++)
1428 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1432 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1434 #ifdef SND_HDA_NEEDS_RESUME
1436 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1437 * @codec: HD-audio codec
1439 * Resume the all amp commands from the cache.
1441 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1443 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1446 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1447 u32 key = buffer->head.key;
1449 unsigned int idx, dir, ch;
1453 idx = (key >> 16) & 0xff;
1454 dir = (key >> 24) & 0xff;
1455 for (ch = 0; ch < 2; ch++) {
1456 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1458 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1463 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1464 #endif /* SND_HDA_NEEDS_RESUME */
1467 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1469 * The control element is supposed to have the private_value field
1470 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1472 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1473 struct snd_ctl_elem_info *uinfo)
1475 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1476 u16 nid = get_amp_nid(kcontrol);
1477 u8 chs = get_amp_channels(kcontrol);
1478 int dir = get_amp_direction(kcontrol);
1479 unsigned int ofs = get_amp_offset(kcontrol);
1482 caps = query_amp_caps(codec, nid, dir);
1484 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1486 printk(KERN_WARNING "hda_codec: "
1487 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1493 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1494 uinfo->count = chs == 3 ? 2 : 1;
1495 uinfo->value.integer.min = 0;
1496 uinfo->value.integer.max = caps;
1499 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1502 static inline unsigned int
1503 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1504 int ch, int dir, int idx, unsigned int ofs)
1507 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1508 val &= HDA_AMP_VOLMASK;
1517 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1518 int ch, int dir, int idx, unsigned int ofs,
1523 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1524 HDA_AMP_VOLMASK, val);
1528 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1530 * The control element is supposed to have the private_value field
1531 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1533 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1534 struct snd_ctl_elem_value *ucontrol)
1536 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1537 hda_nid_t nid = get_amp_nid(kcontrol);
1538 int chs = get_amp_channels(kcontrol);
1539 int dir = get_amp_direction(kcontrol);
1540 int idx = get_amp_index(kcontrol);
1541 unsigned int ofs = get_amp_offset(kcontrol);
1542 long *valp = ucontrol->value.integer.value;
1545 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1547 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1550 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1553 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1555 * The control element is supposed to have the private_value field
1556 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1558 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1559 struct snd_ctl_elem_value *ucontrol)
1561 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1562 hda_nid_t nid = get_amp_nid(kcontrol);
1563 int chs = get_amp_channels(kcontrol);
1564 int dir = get_amp_direction(kcontrol);
1565 int idx = get_amp_index(kcontrol);
1566 unsigned int ofs = get_amp_offset(kcontrol);
1567 long *valp = ucontrol->value.integer.value;
1570 snd_hda_power_up(codec);
1572 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1576 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1577 snd_hda_power_down(codec);
1580 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1583 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
1585 * The control element is supposed to have the private_value field
1586 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1588 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1589 unsigned int size, unsigned int __user *_tlv)
1591 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1592 hda_nid_t nid = get_amp_nid(kcontrol);
1593 int dir = get_amp_direction(kcontrol);
1594 unsigned int ofs = get_amp_offset(kcontrol);
1595 u32 caps, val1, val2;
1597 if (size < 4 * sizeof(unsigned int))
1599 caps = query_amp_caps(codec, nid, dir);
1600 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1601 val2 = (val2 + 1) * 25;
1602 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1604 val1 = ((int)val1) * ((int)val2);
1605 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1607 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1609 if (put_user(val1, _tlv + 2))
1611 if (put_user(val2, _tlv + 3))
1615 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1618 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1619 * @codec: HD-audio codec
1620 * @nid: NID of a reference widget
1621 * @dir: #HDA_INPUT or #HDA_OUTPUT
1622 * @tlv: TLV data to be stored, at least 4 elements
1624 * Set (static) TLV data for a virtual master volume using the AMP caps
1625 * obtained from the reference NID.
1626 * The volume range is recalculated as if the max volume is 0dB.
1628 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1634 caps = query_amp_caps(codec, nid, dir);
1635 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1636 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1637 step = (step + 1) * 25;
1638 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1639 tlv[1] = 2 * sizeof(unsigned int);
1640 tlv[2] = -nums * step;
1643 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1645 /* find a mixer control element with the given name */
1646 static struct snd_kcontrol *
1647 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1648 const char *name, int idx)
1650 struct snd_ctl_elem_id id;
1651 memset(&id, 0, sizeof(id));
1652 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1654 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1656 strcpy(id.name, name);
1657 return snd_ctl_find_id(codec->bus->card, &id);
1661 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1662 * @codec: HD-audio codec
1663 * @name: ctl id name string
1665 * Get the control element with the given id string and IFACE_MIXER.
1667 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1670 return _snd_hda_find_mixer_ctl(codec, name, 0);
1672 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1675 * snd_hda_ctl-add - Add a control element and assign to the codec
1676 * @codec: HD-audio codec
1677 * @nid: corresponding NID (optional)
1678 * @kctl: the control element to assign
1680 * Add the given control element to an array inside the codec instance.
1681 * All control elements belonging to a codec are supposed to be added
1682 * by this function so that a proper clean-up works at the free or
1683 * reconfiguration time.
1685 * If non-zero @nid is passed, the NID is assigned to the control element.
1686 * The assignment is shown in the codec proc file.
1688 * snd_hda_ctl_add() checks the control subdev id field whether
1689 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
1690 * bits value is taken as the NID to assign.
1692 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
1693 struct snd_kcontrol *kctl)
1696 struct hda_nid_item *item;
1698 if (kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) {
1700 nid = kctl->id.subdevice & 0xffff;
1701 kctl->id.subdevice = 0;
1703 err = snd_ctl_add(codec->bus->card, kctl);
1706 item = snd_array_new(&codec->mixers);
1713 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1716 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
1717 * @codec: HD-audio codec
1719 void snd_hda_ctls_clear(struct hda_codec *codec)
1722 struct hda_nid_item *items = codec->mixers.list;
1723 for (i = 0; i < codec->mixers.used; i++)
1724 snd_ctl_remove(codec->bus->card, items[i].kctl);
1725 snd_array_free(&codec->mixers);
1728 /* pseudo device locking
1729 * toggle card->shutdown to allow/disallow the device access (as a hack)
1731 static int hda_lock_devices(struct snd_card *card)
1733 spin_lock(&card->files_lock);
1734 if (card->shutdown) {
1735 spin_unlock(&card->files_lock);
1739 spin_unlock(&card->files_lock);
1743 static void hda_unlock_devices(struct snd_card *card)
1745 spin_lock(&card->files_lock);
1747 spin_unlock(&card->files_lock);
1751 * snd_hda_codec_reset - Clear all objects assigned to the codec
1752 * @codec: HD-audio codec
1754 * This frees the all PCM and control elements assigned to the codec, and
1755 * clears the caches and restores the pin default configurations.
1757 * When a device is being used, it returns -EBSY. If successfully freed,
1760 int snd_hda_codec_reset(struct hda_codec *codec)
1762 struct snd_card *card = codec->bus->card;
1765 if (hda_lock_devices(card) < 0)
1767 /* check whether the codec isn't used by any mixer or PCM streams */
1768 if (!list_empty(&card->ctl_files)) {
1769 hda_unlock_devices(card);
1772 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1773 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1776 if (cpcm->pcm->streams[0].substream_opened ||
1777 cpcm->pcm->streams[1].substream_opened) {
1778 hda_unlock_devices(card);
1783 /* OK, let it free */
1785 #ifdef CONFIG_SND_HDA_POWER_SAVE
1786 cancel_delayed_work(&codec->power_work);
1787 flush_workqueue(codec->bus->workq);
1789 snd_hda_ctls_clear(codec);
1791 for (i = 0; i < codec->num_pcms; i++) {
1792 if (codec->pcm_info[i].pcm) {
1793 snd_device_free(card, codec->pcm_info[i].pcm);
1794 clear_bit(codec->pcm_info[i].device,
1795 codec->bus->pcm_dev_bits);
1798 if (codec->patch_ops.free)
1799 codec->patch_ops.free(codec);
1800 codec->proc_widget_hook = NULL;
1802 free_hda_cache(&codec->amp_cache);
1803 free_hda_cache(&codec->cmd_cache);
1804 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1805 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1806 /* free only driver_pins so that init_pins + user_pins are restored */
1807 snd_array_free(&codec->driver_pins);
1808 restore_pincfgs(codec);
1809 codec->num_pcms = 0;
1810 codec->pcm_info = NULL;
1811 codec->preset = NULL;
1812 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1813 codec->slave_dig_outs = NULL;
1814 codec->spdif_status_reset = 0;
1815 module_put(codec->owner);
1816 codec->owner = NULL;
1818 /* allow device access again */
1819 hda_unlock_devices(card);
1824 * snd_hda_add_vmaster - create a virtual master control and add slaves
1825 * @codec: HD-audio codec
1826 * @name: vmaster control name
1827 * @tlv: TLV data (optional)
1828 * @slaves: slave control names (optional)
1830 * Create a virtual master control with the given name. The TLV data
1831 * must be either NULL or a valid data.
1833 * @slaves is a NULL-terminated array of strings, each of which is a
1834 * slave control name. All controls with these names are assigned to
1835 * the new virtual master control.
1837 * This function returns zero if successful or a negative error code.
1839 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1840 unsigned int *tlv, const char **slaves)
1842 struct snd_kcontrol *kctl;
1846 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1849 snd_printdd("No slave found for %s\n", name);
1852 kctl = snd_ctl_make_virtual_master(name, tlv);
1855 err = snd_hda_ctl_add(codec, 0, kctl);
1859 for (s = slaves; *s; s++) {
1860 struct snd_kcontrol *sctl;
1863 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1866 snd_printdd("Cannot find slave %s, "
1870 err = snd_ctl_add_slave(kctl, sctl);
1878 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1881 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
1883 * The control element is supposed to have the private_value field
1884 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1886 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1887 struct snd_ctl_elem_info *uinfo)
1889 int chs = get_amp_channels(kcontrol);
1891 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1892 uinfo->count = chs == 3 ? 2 : 1;
1893 uinfo->value.integer.min = 0;
1894 uinfo->value.integer.max = 1;
1897 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1900 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
1902 * The control element is supposed to have the private_value field
1903 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1905 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1906 struct snd_ctl_elem_value *ucontrol)
1908 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1909 hda_nid_t nid = get_amp_nid(kcontrol);
1910 int chs = get_amp_channels(kcontrol);
1911 int dir = get_amp_direction(kcontrol);
1912 int idx = get_amp_index(kcontrol);
1913 long *valp = ucontrol->value.integer.value;
1916 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1917 HDA_AMP_MUTE) ? 0 : 1;
1919 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1920 HDA_AMP_MUTE) ? 0 : 1;
1923 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1926 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
1928 * The control element is supposed to have the private_value field
1929 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1931 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1932 struct snd_ctl_elem_value *ucontrol)
1934 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1935 hda_nid_t nid = get_amp_nid(kcontrol);
1936 int chs = get_amp_channels(kcontrol);
1937 int dir = get_amp_direction(kcontrol);
1938 int idx = get_amp_index(kcontrol);
1939 long *valp = ucontrol->value.integer.value;
1942 snd_hda_power_up(codec);
1944 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1946 *valp ? 0 : HDA_AMP_MUTE);
1950 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1952 *valp ? 0 : HDA_AMP_MUTE);
1953 #ifdef CONFIG_SND_HDA_POWER_SAVE
1954 if (codec->patch_ops.check_power_status)
1955 codec->patch_ops.check_power_status(codec, nid);
1957 snd_hda_power_down(codec);
1960 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1963 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
1965 * This function calls snd_hda_enable_beep_device(), which behaves differently
1966 * depending on beep_mode option.
1968 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
1969 struct snd_ctl_elem_value *ucontrol)
1971 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1972 long *valp = ucontrol->value.integer.value;
1974 snd_hda_enable_beep_device(codec, *valp);
1975 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1977 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
1980 * bound volume controls
1982 * bind multiple volumes (# indices, from 0)
1985 #define AMP_VAL_IDX_SHIFT 19
1986 #define AMP_VAL_IDX_MASK (0x0f<<19)
1989 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
1991 * The control element is supposed to have the private_value field
1992 * set up via HDA_BIND_MUTE*() macros.
1994 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1995 struct snd_ctl_elem_value *ucontrol)
1997 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2001 mutex_lock(&codec->control_mutex);
2002 pval = kcontrol->private_value;
2003 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2004 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2005 kcontrol->private_value = pval;
2006 mutex_unlock(&codec->control_mutex);
2009 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2012 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2014 * The control element is supposed to have the private_value field
2015 * set up via HDA_BIND_MUTE*() macros.
2017 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2018 struct snd_ctl_elem_value *ucontrol)
2020 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2022 int i, indices, err = 0, change = 0;
2024 mutex_lock(&codec->control_mutex);
2025 pval = kcontrol->private_value;
2026 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2027 for (i = 0; i < indices; i++) {
2028 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2029 (i << AMP_VAL_IDX_SHIFT);
2030 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2035 kcontrol->private_value = pval;
2036 mutex_unlock(&codec->control_mutex);
2037 return err < 0 ? err : change;
2039 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2042 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2044 * The control element is supposed to have the private_value field
2045 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2047 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2048 struct snd_ctl_elem_info *uinfo)
2050 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2051 struct hda_bind_ctls *c;
2054 mutex_lock(&codec->control_mutex);
2055 c = (struct hda_bind_ctls *)kcontrol->private_value;
2056 kcontrol->private_value = *c->values;
2057 err = c->ops->info(kcontrol, uinfo);
2058 kcontrol->private_value = (long)c;
2059 mutex_unlock(&codec->control_mutex);
2062 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2065 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2067 * The control element is supposed to have the private_value field
2068 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2070 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2071 struct snd_ctl_elem_value *ucontrol)
2073 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2074 struct hda_bind_ctls *c;
2077 mutex_lock(&codec->control_mutex);
2078 c = (struct hda_bind_ctls *)kcontrol->private_value;
2079 kcontrol->private_value = *c->values;
2080 err = c->ops->get(kcontrol, ucontrol);
2081 kcontrol->private_value = (long)c;
2082 mutex_unlock(&codec->control_mutex);
2085 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2088 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2090 * The control element is supposed to have the private_value field
2091 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2093 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2094 struct snd_ctl_elem_value *ucontrol)
2096 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2097 struct hda_bind_ctls *c;
2098 unsigned long *vals;
2099 int err = 0, change = 0;
2101 mutex_lock(&codec->control_mutex);
2102 c = (struct hda_bind_ctls *)kcontrol->private_value;
2103 for (vals = c->values; *vals; vals++) {
2104 kcontrol->private_value = *vals;
2105 err = c->ops->put(kcontrol, ucontrol);
2110 kcontrol->private_value = (long)c;
2111 mutex_unlock(&codec->control_mutex);
2112 return err < 0 ? err : change;
2114 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2117 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2119 * The control element is supposed to have the private_value field
2120 * set up via HDA_BIND_VOL() macro.
2122 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2123 unsigned int size, unsigned int __user *tlv)
2125 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2126 struct hda_bind_ctls *c;
2129 mutex_lock(&codec->control_mutex);
2130 c = (struct hda_bind_ctls *)kcontrol->private_value;
2131 kcontrol->private_value = *c->values;
2132 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2133 kcontrol->private_value = (long)c;
2134 mutex_unlock(&codec->control_mutex);
2137 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2139 struct hda_ctl_ops snd_hda_bind_vol = {
2140 .info = snd_hda_mixer_amp_volume_info,
2141 .get = snd_hda_mixer_amp_volume_get,
2142 .put = snd_hda_mixer_amp_volume_put,
2143 .tlv = snd_hda_mixer_amp_tlv
2145 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2147 struct hda_ctl_ops snd_hda_bind_sw = {
2148 .info = snd_hda_mixer_amp_switch_info,
2149 .get = snd_hda_mixer_amp_switch_get,
2150 .put = snd_hda_mixer_amp_switch_put,
2151 .tlv = snd_hda_mixer_amp_tlv
2153 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2156 * SPDIF out controls
2159 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2160 struct snd_ctl_elem_info *uinfo)
2162 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2167 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2168 struct snd_ctl_elem_value *ucontrol)
2170 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2171 IEC958_AES0_NONAUDIO |
2172 IEC958_AES0_CON_EMPHASIS_5015 |
2173 IEC958_AES0_CON_NOT_COPYRIGHT;
2174 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2175 IEC958_AES1_CON_ORIGINAL;
2179 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2180 struct snd_ctl_elem_value *ucontrol)
2182 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2183 IEC958_AES0_NONAUDIO |
2184 IEC958_AES0_PRO_EMPHASIS_5015;
2188 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2189 struct snd_ctl_elem_value *ucontrol)
2191 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2193 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
2194 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
2195 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
2196 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
2201 /* convert from SPDIF status bits to HDA SPDIF bits
2202 * bit 0 (DigEn) is always set zero (to be filled later)
2204 static unsigned short convert_from_spdif_status(unsigned int sbits)
2206 unsigned short val = 0;
2208 if (sbits & IEC958_AES0_PROFESSIONAL)
2209 val |= AC_DIG1_PROFESSIONAL;
2210 if (sbits & IEC958_AES0_NONAUDIO)
2211 val |= AC_DIG1_NONAUDIO;
2212 if (sbits & IEC958_AES0_PROFESSIONAL) {
2213 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2214 IEC958_AES0_PRO_EMPHASIS_5015)
2215 val |= AC_DIG1_EMPHASIS;
2217 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2218 IEC958_AES0_CON_EMPHASIS_5015)
2219 val |= AC_DIG1_EMPHASIS;
2220 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2221 val |= AC_DIG1_COPYRIGHT;
2222 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2223 val |= AC_DIG1_LEVEL;
2224 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2229 /* convert to SPDIF status bits from HDA SPDIF bits
2231 static unsigned int convert_to_spdif_status(unsigned short val)
2233 unsigned int sbits = 0;
2235 if (val & AC_DIG1_NONAUDIO)
2236 sbits |= IEC958_AES0_NONAUDIO;
2237 if (val & AC_DIG1_PROFESSIONAL)
2238 sbits |= IEC958_AES0_PROFESSIONAL;
2239 if (sbits & IEC958_AES0_PROFESSIONAL) {
2240 if (sbits & AC_DIG1_EMPHASIS)
2241 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2243 if (val & AC_DIG1_EMPHASIS)
2244 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2245 if (!(val & AC_DIG1_COPYRIGHT))
2246 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2247 if (val & AC_DIG1_LEVEL)
2248 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2249 sbits |= val & (0x7f << 8);
2254 /* set digital convert verbs both for the given NID and its slaves */
2255 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2260 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2261 d = codec->slave_dig_outs;
2265 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2268 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2272 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2274 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2277 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2278 struct snd_ctl_elem_value *ucontrol)
2280 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2281 hda_nid_t nid = kcontrol->private_value;
2285 mutex_lock(&codec->spdif_mutex);
2286 codec->spdif_status = ucontrol->value.iec958.status[0] |
2287 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2288 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2289 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2290 val = convert_from_spdif_status(codec->spdif_status);
2291 val |= codec->spdif_ctls & 1;
2292 change = codec->spdif_ctls != val;
2293 codec->spdif_ctls = val;
2296 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2298 mutex_unlock(&codec->spdif_mutex);
2302 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2304 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2305 struct snd_ctl_elem_value *ucontrol)
2307 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2309 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
2313 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2314 struct snd_ctl_elem_value *ucontrol)
2316 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2317 hda_nid_t nid = kcontrol->private_value;
2321 mutex_lock(&codec->spdif_mutex);
2322 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2323 if (ucontrol->value.integer.value[0])
2324 val |= AC_DIG1_ENABLE;
2325 change = codec->spdif_ctls != val;
2327 codec->spdif_ctls = val;
2328 set_dig_out_convert(codec, nid, val & 0xff, -1);
2329 /* unmute amp switch (if any) */
2330 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2331 (val & AC_DIG1_ENABLE))
2332 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2335 mutex_unlock(&codec->spdif_mutex);
2339 static struct snd_kcontrol_new dig_mixes[] = {
2341 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2342 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2343 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2344 .info = snd_hda_spdif_mask_info,
2345 .get = snd_hda_spdif_cmask_get,
2348 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2349 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2350 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2351 .info = snd_hda_spdif_mask_info,
2352 .get = snd_hda_spdif_pmask_get,
2355 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2356 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2357 .info = snd_hda_spdif_mask_info,
2358 .get = snd_hda_spdif_default_get,
2359 .put = snd_hda_spdif_default_put,
2362 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2363 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2364 .info = snd_hda_spdif_out_switch_info,
2365 .get = snd_hda_spdif_out_switch_get,
2366 .put = snd_hda_spdif_out_switch_put,
2371 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2374 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2375 * @codec: the HDA codec
2376 * @nid: audio out widget NID
2378 * Creates controls related with the SPDIF output.
2379 * Called from each patch supporting the SPDIF out.
2381 * Returns 0 if successful, or a negative error code.
2383 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2386 struct snd_kcontrol *kctl;
2387 struct snd_kcontrol_new *dig_mix;
2390 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2391 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2395 if (idx >= SPDIF_MAX_IDX) {
2396 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2399 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2400 kctl = snd_ctl_new1(dig_mix, codec);
2403 kctl->id.index = idx;
2404 kctl->private_value = nid;
2405 err = snd_hda_ctl_add(codec, nid, kctl);
2410 snd_hda_codec_read(codec, nid, 0,
2411 AC_VERB_GET_DIGI_CONVERT_1, 0);
2412 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2415 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2418 * SPDIF sharing with analog output
2420 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2421 struct snd_ctl_elem_value *ucontrol)
2423 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2424 ucontrol->value.integer.value[0] = mout->share_spdif;
2428 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2429 struct snd_ctl_elem_value *ucontrol)
2431 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2432 mout->share_spdif = !!ucontrol->value.integer.value[0];
2436 static struct snd_kcontrol_new spdif_share_sw = {
2437 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2438 .name = "IEC958 Default PCM Playback Switch",
2439 .info = snd_ctl_boolean_mono_info,
2440 .get = spdif_share_sw_get,
2441 .put = spdif_share_sw_put,
2445 * snd_hda_create_spdif_share_sw - create Default PCM switch
2446 * @codec: the HDA codec
2447 * @mout: multi-out instance
2449 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2450 struct hda_multi_out *mout)
2452 if (!mout->dig_out_nid)
2454 /* ATTENTION: here mout is passed as private_data, instead of codec */
2455 return snd_hda_ctl_add(codec, mout->dig_out_nid,
2456 snd_ctl_new1(&spdif_share_sw, mout));
2458 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2464 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2466 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2467 struct snd_ctl_elem_value *ucontrol)
2469 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2471 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2475 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2476 struct snd_ctl_elem_value *ucontrol)
2478 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2479 hda_nid_t nid = kcontrol->private_value;
2480 unsigned int val = !!ucontrol->value.integer.value[0];
2483 mutex_lock(&codec->spdif_mutex);
2484 change = codec->spdif_in_enable != val;
2486 codec->spdif_in_enable = val;
2487 snd_hda_codec_write_cache(codec, nid, 0,
2488 AC_VERB_SET_DIGI_CONVERT_1, val);
2490 mutex_unlock(&codec->spdif_mutex);
2494 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2495 struct snd_ctl_elem_value *ucontrol)
2497 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2498 hda_nid_t nid = kcontrol->private_value;
2502 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2503 sbits = convert_to_spdif_status(val);
2504 ucontrol->value.iec958.status[0] = sbits;
2505 ucontrol->value.iec958.status[1] = sbits >> 8;
2506 ucontrol->value.iec958.status[2] = sbits >> 16;
2507 ucontrol->value.iec958.status[3] = sbits >> 24;
2511 static struct snd_kcontrol_new dig_in_ctls[] = {
2513 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2514 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2515 .info = snd_hda_spdif_in_switch_info,
2516 .get = snd_hda_spdif_in_switch_get,
2517 .put = snd_hda_spdif_in_switch_put,
2520 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2521 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2522 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2523 .info = snd_hda_spdif_mask_info,
2524 .get = snd_hda_spdif_in_status_get,
2530 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2531 * @codec: the HDA codec
2532 * @nid: audio in widget NID
2534 * Creates controls related with the SPDIF input.
2535 * Called from each patch supporting the SPDIF in.
2537 * Returns 0 if successful, or a negative error code.
2539 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2542 struct snd_kcontrol *kctl;
2543 struct snd_kcontrol_new *dig_mix;
2546 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2547 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2551 if (idx >= SPDIF_MAX_IDX) {
2552 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2555 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2556 kctl = snd_ctl_new1(dig_mix, codec);
2559 kctl->private_value = nid;
2560 err = snd_hda_ctl_add(codec, nid, kctl);
2564 codec->spdif_in_enable =
2565 snd_hda_codec_read(codec, nid, 0,
2566 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2570 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2572 #ifdef SND_HDA_NEEDS_RESUME
2577 /* build a 32bit cache key with the widget id and the command parameter */
2578 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2579 #define get_cmd_cache_nid(key) ((key) & 0xff)
2580 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2583 * snd_hda_codec_write_cache - send a single command with caching
2584 * @codec: the HDA codec
2585 * @nid: NID to send the command
2586 * @direct: direct flag
2587 * @verb: the verb to send
2588 * @parm: the parameter for the verb
2590 * Send a single command without waiting for response.
2592 * Returns 0 if successful, or a negative error code.
2594 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2595 int direct, unsigned int verb, unsigned int parm)
2597 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2598 struct hda_cache_head *c;
2603 /* parm may contain the verb stuff for get/set amp */
2604 verb = verb | (parm >> 8);
2606 key = build_cmd_cache_key(nid, verb);
2607 mutex_lock(&codec->bus->cmd_mutex);
2608 c = get_alloc_hash(&codec->cmd_cache, key);
2611 mutex_unlock(&codec->bus->cmd_mutex);
2614 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2617 * snd_hda_codec_resume_cache - Resume the all commands from the cache
2618 * @codec: HD-audio codec
2620 * Execute all verbs recorded in the command caches to resume.
2622 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2624 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2627 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2628 u32 key = buffer->key;
2631 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2632 get_cmd_cache_cmd(key), buffer->val);
2635 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2638 * snd_hda_sequence_write_cache - sequence writes with caching
2639 * @codec: the HDA codec
2640 * @seq: VERB array to send
2642 * Send the commands sequentially from the given array.
2643 * Thte commands are recorded on cache for power-save and resume.
2644 * The array must be terminated with NID=0.
2646 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2647 const struct hda_verb *seq)
2649 for (; seq->nid; seq++)
2650 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2653 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2654 #endif /* SND_HDA_NEEDS_RESUME */
2657 * set power state of the codec
2659 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2660 unsigned int power_state)
2665 /* this delay seems necessary to avoid click noise at power-down */
2666 if (power_state == AC_PWRST_D3)
2668 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2670 /* partial workaround for "azx_get_response timeout" */
2671 if (power_state == AC_PWRST_D0)
2674 nid = codec->start_nid;
2675 for (i = 0; i < codec->num_nodes; i++, nid++) {
2676 unsigned int wcaps = get_wcaps(codec, nid);
2677 if (wcaps & AC_WCAP_POWER) {
2678 unsigned int wid_type = get_wcaps_type(wcaps);
2679 if (power_state == AC_PWRST_D3 &&
2680 wid_type == AC_WID_PIN) {
2681 unsigned int pincap;
2683 * don't power down the widget if it controls
2684 * eapd and EAPD_BTLENABLE is set.
2686 pincap = snd_hda_query_pin_caps(codec, nid);
2687 if (pincap & AC_PINCAP_EAPD) {
2688 int eapd = snd_hda_codec_read(codec,
2690 AC_VERB_GET_EAPD_BTLENABLE, 0);
2696 snd_hda_codec_write(codec, nid, 0,
2697 AC_VERB_SET_POWER_STATE,
2702 if (power_state == AC_PWRST_D0) {
2703 unsigned long end_time;
2706 /* wait until the codec reachs to D0 */
2707 end_time = jiffies + msecs_to_jiffies(500);
2709 state = snd_hda_codec_read(codec, fg, 0,
2710 AC_VERB_GET_POWER_STATE, 0);
2711 if (state == power_state)
2714 } while (time_after_eq(end_time, jiffies));
2718 #ifdef CONFIG_SND_HDA_HWDEP
2719 /* execute additional init verbs */
2720 static void hda_exec_init_verbs(struct hda_codec *codec)
2722 if (codec->init_verbs.list)
2723 snd_hda_sequence_write(codec, codec->init_verbs.list);
2726 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2729 #ifdef SND_HDA_NEEDS_RESUME
2731 * call suspend and power-down; used both from PM and power-save
2733 static void hda_call_codec_suspend(struct hda_codec *codec)
2735 if (codec->patch_ops.suspend)
2736 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2737 hda_set_power_state(codec,
2738 codec->afg ? codec->afg : codec->mfg,
2740 #ifdef CONFIG_SND_HDA_POWER_SAVE
2741 snd_hda_update_power_acct(codec);
2742 cancel_delayed_work(&codec->power_work);
2743 codec->power_on = 0;
2744 codec->power_transition = 0;
2745 codec->power_jiffies = jiffies;
2750 * kick up codec; used both from PM and power-save
2752 static void hda_call_codec_resume(struct hda_codec *codec)
2754 hda_set_power_state(codec,
2755 codec->afg ? codec->afg : codec->mfg,
2757 restore_pincfgs(codec); /* restore all current pin configs */
2758 hda_exec_init_verbs(codec);
2759 if (codec->patch_ops.resume)
2760 codec->patch_ops.resume(codec);
2762 if (codec->patch_ops.init)
2763 codec->patch_ops.init(codec);
2764 snd_hda_codec_resume_amp(codec);
2765 snd_hda_codec_resume_cache(codec);
2768 #endif /* SND_HDA_NEEDS_RESUME */
2772 * snd_hda_build_controls - build mixer controls
2775 * Creates mixer controls for each codec included in the bus.
2777 * Returns 0 if successful, otherwise a negative error code.
2779 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2781 struct hda_codec *codec;
2783 list_for_each_entry(codec, &bus->codec_list, list) {
2784 int err = snd_hda_codec_build_controls(codec);
2786 printk(KERN_ERR "hda_codec: cannot build controls"
2787 "for #%d (error %d)\n", codec->addr, err);
2788 err = snd_hda_codec_reset(codec);
2791 "hda_codec: cannot revert codec\n");
2798 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2800 int snd_hda_codec_build_controls(struct hda_codec *codec)
2803 hda_exec_init_verbs(codec);
2804 /* continue to initialize... */
2805 if (codec->patch_ops.init)
2806 err = codec->patch_ops.init(codec);
2807 if (!err && codec->patch_ops.build_controls)
2808 err = codec->patch_ops.build_controls(codec);
2817 struct hda_rate_tbl {
2819 unsigned int alsa_bits;
2820 unsigned int hda_fmt;
2823 static struct hda_rate_tbl rate_bits[] = {
2824 /* rate in Hz, ALSA rate bitmask, HDA format value */
2826 /* autodetected value used in snd_hda_query_supported_pcm */
2827 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2828 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2829 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2830 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2831 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2832 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2833 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2834 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2835 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2836 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2837 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2838 #define AC_PAR_PCM_RATE_BITS 11
2839 /* up to bits 10, 384kHZ isn't supported properly */
2841 /* not autodetected value */
2842 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2844 { 0 } /* terminator */
2848 * snd_hda_calc_stream_format - calculate format bitset
2849 * @rate: the sample rate
2850 * @channels: the number of channels
2851 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2852 * @maxbps: the max. bps
2854 * Calculate the format bitset from the given rate, channels and th PCM format.
2856 * Return zero if invalid.
2858 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2859 unsigned int channels,
2860 unsigned int format,
2861 unsigned int maxbps)
2864 unsigned int val = 0;
2866 for (i = 0; rate_bits[i].hz; i++)
2867 if (rate_bits[i].hz == rate) {
2868 val = rate_bits[i].hda_fmt;
2871 if (!rate_bits[i].hz) {
2872 snd_printdd("invalid rate %d\n", rate);
2876 if (channels == 0 || channels > 8) {
2877 snd_printdd("invalid channels %d\n", channels);
2880 val |= channels - 1;
2882 switch (snd_pcm_format_width(format)) {
2883 case 8: val |= 0x00; break;
2884 case 16: val |= 0x10; break;
2888 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
2890 else if (maxbps >= 24)
2896 snd_printdd("invalid format width %d\n",
2897 snd_pcm_format_width(format));
2903 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2905 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2907 unsigned int val = 0;
2908 if (nid != codec->afg &&
2909 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2910 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2911 if (!val || val == -1)
2912 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2913 if (!val || val == -1)
2918 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2920 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2924 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2926 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2927 if (!streams || streams == -1)
2928 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2929 if (!streams || streams == -1)
2934 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2936 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2941 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2942 * @codec: the HDA codec
2943 * @nid: NID to query
2944 * @ratesp: the pointer to store the detected rate bitflags
2945 * @formatsp: the pointer to store the detected formats
2946 * @bpsp: the pointer to store the detected format widths
2948 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2949 * or @bsps argument is ignored.
2951 * Returns 0 if successful, otherwise a negative error code.
2953 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2954 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2956 unsigned int i, val, wcaps;
2958 wcaps = get_wcaps(codec, nid);
2959 val = query_pcm_param(codec, nid);
2963 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2965 rates |= rate_bits[i].alsa_bits;
2968 snd_printk(KERN_ERR "hda_codec: rates == 0 "
2969 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2971 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2977 if (formatsp || bpsp) {
2979 unsigned int streams, bps;
2981 streams = query_stream_param(codec, nid);
2986 if (streams & AC_SUPFMT_PCM) {
2987 if (val & AC_SUPPCM_BITS_8) {
2988 formats |= SNDRV_PCM_FMTBIT_U8;
2991 if (val & AC_SUPPCM_BITS_16) {
2992 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2995 if (wcaps & AC_WCAP_DIGITAL) {
2996 if (val & AC_SUPPCM_BITS_32)
2997 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2998 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2999 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3000 if (val & AC_SUPPCM_BITS_24)
3002 else if (val & AC_SUPPCM_BITS_20)
3004 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3005 AC_SUPPCM_BITS_32)) {
3006 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3007 if (val & AC_SUPPCM_BITS_32)
3009 else if (val & AC_SUPPCM_BITS_24)
3011 else if (val & AC_SUPPCM_BITS_20)
3015 if (streams & AC_SUPFMT_FLOAT32) {
3016 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3020 if (streams == AC_SUPFMT_AC3) {
3021 /* should be exclusive */
3022 /* temporary hack: we have still no proper support
3023 * for the direct AC3 stream...
3025 formats |= SNDRV_PCM_FMTBIT_U8;
3029 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3030 "(nid=0x%x, val=0x%x, ovrd=%i, "
3033 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3038 *formatsp = formats;
3047 * snd_hda_is_supported_format - Check the validity of the format
3048 * @codec: HD-audio codec
3049 * @nid: NID to check
3050 * @format: the HD-audio format value to check
3052 * Check whether the given node supports the format value.
3054 * Returns 1 if supported, 0 if not.
3056 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3057 unsigned int format)
3060 unsigned int val = 0, rate, stream;
3062 val = query_pcm_param(codec, nid);
3066 rate = format & 0xff00;
3067 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3068 if (rate_bits[i].hda_fmt == rate) {
3073 if (i >= AC_PAR_PCM_RATE_BITS)
3076 stream = query_stream_param(codec, nid);
3080 if (stream & AC_SUPFMT_PCM) {
3081 switch (format & 0xf0) {
3083 if (!(val & AC_SUPPCM_BITS_8))
3087 if (!(val & AC_SUPPCM_BITS_16))
3091 if (!(val & AC_SUPPCM_BITS_20))
3095 if (!(val & AC_SUPPCM_BITS_24))
3099 if (!(val & AC_SUPPCM_BITS_32))
3106 /* FIXME: check for float32 and AC3? */
3111 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3116 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3117 struct hda_codec *codec,
3118 struct snd_pcm_substream *substream)
3123 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3124 struct hda_codec *codec,
3125 unsigned int stream_tag,
3126 unsigned int format,
3127 struct snd_pcm_substream *substream)
3129 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3133 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3134 struct hda_codec *codec,
3135 struct snd_pcm_substream *substream)
3137 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3141 static int set_pcm_default_values(struct hda_codec *codec,
3142 struct hda_pcm_stream *info)
3146 /* query support PCM information from the given NID */
3147 if (info->nid && (!info->rates || !info->formats)) {
3148 err = snd_hda_query_supported_pcm(codec, info->nid,
3149 info->rates ? NULL : &info->rates,
3150 info->formats ? NULL : &info->formats,
3151 info->maxbps ? NULL : &info->maxbps);
3155 if (info->ops.open == NULL)
3156 info->ops.open = hda_pcm_default_open_close;
3157 if (info->ops.close == NULL)
3158 info->ops.close = hda_pcm_default_open_close;
3159 if (info->ops.prepare == NULL) {
3160 if (snd_BUG_ON(!info->nid))
3162 info->ops.prepare = hda_pcm_default_prepare;
3164 if (info->ops.cleanup == NULL) {
3165 if (snd_BUG_ON(!info->nid))
3167 info->ops.cleanup = hda_pcm_default_cleanup;
3173 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3174 "Audio", "SPDIF", "HDMI", "Modem"
3178 * get the empty PCM device number to assign
3180 static int get_empty_pcm_device(struct hda_bus *bus, int type)
3182 /* audio device indices; not linear to keep compatibility */
3183 static int audio_idx[HDA_PCM_NTYPES][5] = {
3184 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3185 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3186 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
3187 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
3191 if (type >= HDA_PCM_NTYPES) {
3192 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3196 for (i = 0; audio_idx[type][i] >= 0 ; i++)
3197 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3198 return audio_idx[type][i];
3200 snd_printk(KERN_WARNING "Too many %s devices\n", snd_hda_pcm_type_name[type]);
3205 * attach a new PCM stream
3207 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
3209 struct hda_bus *bus = codec->bus;
3210 struct hda_pcm_stream *info;
3213 if (snd_BUG_ON(!pcm->name))
3215 for (stream = 0; stream < 2; stream++) {
3216 info = &pcm->stream[stream];
3217 if (info->substreams) {
3218 err = set_pcm_default_values(codec, info);
3223 return bus->ops.attach_pcm(bus, codec, pcm);
3226 /* assign all PCMs of the given codec */
3227 int snd_hda_codec_build_pcms(struct hda_codec *codec)
3232 if (!codec->num_pcms) {
3233 if (!codec->patch_ops.build_pcms)
3235 err = codec->patch_ops.build_pcms(codec);
3237 printk(KERN_ERR "hda_codec: cannot build PCMs"
3238 "for #%d (error %d)\n", codec->addr, err);
3239 err = snd_hda_codec_reset(codec);
3242 "hda_codec: cannot revert codec\n");
3247 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
3248 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
3251 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
3252 continue; /* no substreams assigned */
3255 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
3257 continue; /* no fatal error */
3259 err = snd_hda_attach_pcm(codec, cpcm);
3261 printk(KERN_ERR "hda_codec: cannot attach "
3262 "PCM stream %d for codec #%d\n",
3264 continue; /* no fatal error */
3272 * snd_hda_build_pcms - build PCM information
3275 * Create PCM information for each codec included in the bus.
3277 * The build_pcms codec patch is requested to set up codec->num_pcms and
3278 * codec->pcm_info properly. The array is referred by the top-level driver
3279 * to create its PCM instances.
3280 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3283 * At least, substreams, channels_min and channels_max must be filled for
3284 * each stream. substreams = 0 indicates that the stream doesn't exist.
3285 * When rates and/or formats are zero, the supported values are queried
3286 * from the given nid. The nid is used also by the default ops.prepare
3287 * and ops.cleanup callbacks.
3289 * The driver needs to call ops.open in its open callback. Similarly,
3290 * ops.close is supposed to be called in the close callback.
3291 * ops.prepare should be called in the prepare or hw_params callback
3292 * with the proper parameters for set up.
3293 * ops.cleanup should be called in hw_free for clean up of streams.
3295 * This function returns 0 if successfull, or a negative error code.
3297 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
3299 struct hda_codec *codec;
3301 list_for_each_entry(codec, &bus->codec_list, list) {
3302 int err = snd_hda_codec_build_pcms(codec);
3308 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
3311 * snd_hda_check_board_config - compare the current codec with the config table
3312 * @codec: the HDA codec
3313 * @num_configs: number of config enums
3314 * @models: array of model name strings
3315 * @tbl: configuration table, terminated by null entries
3317 * Compares the modelname or PCI subsystem id of the current codec with the
3318 * given configuration table. If a matching entry is found, returns its
3319 * config value (supposed to be 0 or positive).
3321 * If no entries are matching, the function returns a negative value.
3323 int snd_hda_check_board_config(struct hda_codec *codec,
3324 int num_configs, const char **models,
3325 const struct snd_pci_quirk *tbl)
3327 if (codec->modelname && models) {
3329 for (i = 0; i < num_configs; i++) {
3331 !strcmp(codec->modelname, models[i])) {
3332 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3333 "selected\n", models[i]);
3339 if (!codec->bus->pci || !tbl)
3342 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3345 if (tbl->value >= 0 && tbl->value < num_configs) {
3346 #ifdef CONFIG_SND_DEBUG_VERBOSE
3348 const char *model = NULL;
3350 model = models[tbl->value];
3352 sprintf(tmp, "#%d", tbl->value);
3355 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3356 "for config %x:%x (%s)\n",
3357 model, tbl->subvendor, tbl->subdevice,
3358 (tbl->name ? tbl->name : "Unknown device"));
3364 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3367 * snd_hda_check_board_codec_sid_config - compare the current codec
3368 subsystem ID with the
3371 This is important for Gateway notebooks with SB450 HDA Audio
3372 where the vendor ID of the PCI device is:
3373 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3374 and the vendor/subvendor are found only at the codec.
3376 * @codec: the HDA codec
3377 * @num_configs: number of config enums
3378 * @models: array of model name strings
3379 * @tbl: configuration table, terminated by null entries
3381 * Compares the modelname or PCI subsystem id of the current codec with the
3382 * given configuration table. If a matching entry is found, returns its
3383 * config value (supposed to be 0 or positive).
3385 * If no entries are matching, the function returns a negative value.
3387 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3388 int num_configs, const char **models,
3389 const struct snd_pci_quirk *tbl)
3391 const struct snd_pci_quirk *q;
3393 /* Search for codec ID */
3394 for (q = tbl; q->subvendor; q++) {
3395 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3397 if (vendorid == codec->subsystem_id)
3406 if (tbl->value >= 0 && tbl->value < num_configs) {
3407 #ifdef CONFIG_SND_DEBUG_VERBOSE
3409 const char *model = NULL;
3411 model = models[tbl->value];
3413 sprintf(tmp, "#%d", tbl->value);
3416 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3417 "for config %x:%x (%s)\n",
3418 model, tbl->subvendor, tbl->subdevice,
3419 (tbl->name ? tbl->name : "Unknown device"));
3425 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3428 * snd_hda_add_new_ctls - create controls from the array
3429 * @codec: the HDA codec
3430 * @knew: the array of struct snd_kcontrol_new
3432 * This helper function creates and add new controls in the given array.
3433 * The array must be terminated with an empty entry as terminator.
3435 * Returns 0 if successful, or a negative error code.
3437 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3441 for (; knew->name; knew++) {
3442 struct snd_kcontrol *kctl;
3443 kctl = snd_ctl_new1(knew, codec);
3446 err = snd_hda_ctl_add(codec, 0, kctl);
3450 kctl = snd_ctl_new1(knew, codec);
3453 kctl->id.device = codec->addr;
3454 err = snd_hda_ctl_add(codec, 0, kctl);
3461 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3463 #ifdef CONFIG_SND_HDA_POWER_SAVE
3464 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3465 unsigned int power_state);
3467 static void hda_power_work(struct work_struct *work)
3469 struct hda_codec *codec =
3470 container_of(work, struct hda_codec, power_work.work);
3471 struct hda_bus *bus = codec->bus;
3473 if (!codec->power_on || codec->power_count) {
3474 codec->power_transition = 0;
3478 hda_call_codec_suspend(codec);
3479 if (bus->ops.pm_notify)
3480 bus->ops.pm_notify(bus);
3483 static void hda_keep_power_on(struct hda_codec *codec)
3485 codec->power_count++;
3486 codec->power_on = 1;
3487 codec->power_jiffies = jiffies;
3490 /* update the power on/off account with the current jiffies */
3491 void snd_hda_update_power_acct(struct hda_codec *codec)
3493 unsigned long delta = jiffies - codec->power_jiffies;
3494 if (codec->power_on)
3495 codec->power_on_acct += delta;
3497 codec->power_off_acct += delta;
3498 codec->power_jiffies += delta;
3502 * snd_hda_power_up - Power-up the codec
3503 * @codec: HD-audio codec
3505 * Increment the power-up counter and power up the hardware really when
3506 * not turned on yet.
3508 void snd_hda_power_up(struct hda_codec *codec)
3510 struct hda_bus *bus = codec->bus;
3512 codec->power_count++;
3513 if (codec->power_on || codec->power_transition)
3516 snd_hda_update_power_acct(codec);
3517 codec->power_on = 1;
3518 codec->power_jiffies = jiffies;
3519 if (bus->ops.pm_notify)
3520 bus->ops.pm_notify(bus);
3521 hda_call_codec_resume(codec);
3522 cancel_delayed_work(&codec->power_work);
3523 codec->power_transition = 0;
3525 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3527 #define power_save(codec) \
3528 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3531 * snd_hda_power_down - Power-down the codec
3532 * @codec: HD-audio codec
3534 * Decrement the power-up counter and schedules the power-off work if
3535 * the counter rearches to zero.
3537 void snd_hda_power_down(struct hda_codec *codec)
3539 --codec->power_count;
3540 if (!codec->power_on || codec->power_count || codec->power_transition)
3542 if (power_save(codec)) {
3543 codec->power_transition = 1; /* avoid reentrance */
3544 queue_delayed_work(codec->bus->workq, &codec->power_work,
3545 msecs_to_jiffies(power_save(codec) * 1000));
3548 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3551 * snd_hda_check_amp_list_power - Check the amp list and update the power
3552 * @codec: HD-audio codec
3553 * @check: the object containing an AMP list and the status
3554 * @nid: NID to check / update
3556 * Check whether the given NID is in the amp list. If it's in the list,
3557 * check the current AMP status, and update the the power-status according
3558 * to the mute status.
3560 * This function is supposed to be set or called from the check_power_status
3563 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3564 struct hda_loopback_check *check,
3567 struct hda_amp_list *p;
3570 if (!check->amplist)
3572 for (p = check->amplist; p->nid; p++) {
3577 return 0; /* nothing changed */
3579 for (p = check->amplist; p->nid; p++) {
3580 for (ch = 0; ch < 2; ch++) {
3581 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3583 if (!(v & HDA_AMP_MUTE) && v > 0) {
3584 if (!check->power_on) {
3585 check->power_on = 1;
3586 snd_hda_power_up(codec);
3592 if (check->power_on) {
3593 check->power_on = 0;
3594 snd_hda_power_down(codec);
3598 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3602 * Channel mode helper
3606 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
3608 int snd_hda_ch_mode_info(struct hda_codec *codec,
3609 struct snd_ctl_elem_info *uinfo,
3610 const struct hda_channel_mode *chmode,
3613 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3615 uinfo->value.enumerated.items = num_chmodes;
3616 if (uinfo->value.enumerated.item >= num_chmodes)
3617 uinfo->value.enumerated.item = num_chmodes - 1;
3618 sprintf(uinfo->value.enumerated.name, "%dch",
3619 chmode[uinfo->value.enumerated.item].channels);
3622 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3625 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
3627 int snd_hda_ch_mode_get(struct hda_codec *codec,
3628 struct snd_ctl_elem_value *ucontrol,
3629 const struct hda_channel_mode *chmode,
3635 for (i = 0; i < num_chmodes; i++) {
3636 if (max_channels == chmode[i].channels) {
3637 ucontrol->value.enumerated.item[0] = i;
3643 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3646 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
3648 int snd_hda_ch_mode_put(struct hda_codec *codec,
3649 struct snd_ctl_elem_value *ucontrol,
3650 const struct hda_channel_mode *chmode,
3656 mode = ucontrol->value.enumerated.item[0];
3657 if (mode >= num_chmodes)
3659 if (*max_channelsp == chmode[mode].channels)
3661 /* change the current channel setting */
3662 *max_channelsp = chmode[mode].channels;
3663 if (chmode[mode].sequence)
3664 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3667 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3674 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
3676 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3677 struct snd_ctl_elem_info *uinfo)
3681 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3683 uinfo->value.enumerated.items = imux->num_items;
3684 if (!imux->num_items)
3686 index = uinfo->value.enumerated.item;
3687 if (index >= imux->num_items)
3688 index = imux->num_items - 1;
3689 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3692 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3695 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
3697 int snd_hda_input_mux_put(struct hda_codec *codec,
3698 const struct hda_input_mux *imux,
3699 struct snd_ctl_elem_value *ucontrol,
3701 unsigned int *cur_val)
3705 if (!imux->num_items)
3707 idx = ucontrol->value.enumerated.item[0];
3708 if (idx >= imux->num_items)
3709 idx = imux->num_items - 1;
3710 if (*cur_val == idx)
3712 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3713 imux->items[idx].index);
3717 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3721 * Multi-channel / digital-out PCM helper functions
3724 /* setup SPDIF output stream */
3725 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3726 unsigned int stream_tag, unsigned int format)
3728 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3729 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3730 set_dig_out_convert(codec, nid,
3731 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3733 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3734 if (codec->slave_dig_outs) {
3736 for (d = codec->slave_dig_outs; *d; d++)
3737 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3740 /* turn on again (if needed) */
3741 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3742 set_dig_out_convert(codec, nid,
3743 codec->spdif_ctls & 0xff, -1);
3746 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3748 snd_hda_codec_cleanup_stream(codec, nid);
3749 if (codec->slave_dig_outs) {
3751 for (d = codec->slave_dig_outs; *d; d++)
3752 snd_hda_codec_cleanup_stream(codec, *d);
3757 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
3758 * @bus: HD-audio bus
3760 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
3762 struct hda_codec *codec;
3766 list_for_each_entry(codec, &bus->codec_list, list) {
3767 #ifdef CONFIG_SND_HDA_POWER_SAVE
3768 if (!codec->power_on)
3771 if (codec->patch_ops.reboot_notify)
3772 codec->patch_ops.reboot_notify(codec);
3775 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
3778 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
3780 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3781 struct hda_multi_out *mout)
3783 mutex_lock(&codec->spdif_mutex);
3784 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3785 /* already opened as analog dup; reset it once */
3786 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3787 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3788 mutex_unlock(&codec->spdif_mutex);
3791 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3794 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
3796 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3797 struct hda_multi_out *mout,
3798 unsigned int stream_tag,
3799 unsigned int format,
3800 struct snd_pcm_substream *substream)
3802 mutex_lock(&codec->spdif_mutex);
3803 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3804 mutex_unlock(&codec->spdif_mutex);
3807 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3810 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
3812 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3813 struct hda_multi_out *mout)
3815 mutex_lock(&codec->spdif_mutex);
3816 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3817 mutex_unlock(&codec->spdif_mutex);
3820 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3823 * snd_hda_multi_out_dig_close - release the digital out stream
3825 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3826 struct hda_multi_out *mout)
3828 mutex_lock(&codec->spdif_mutex);
3829 mout->dig_out_used = 0;
3830 mutex_unlock(&codec->spdif_mutex);
3833 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3836 * snd_hda_multi_out_analog_open - open analog outputs
3838 * Open analog outputs and set up the hw-constraints.
3839 * If the digital outputs can be opened as slave, open the digital
3842 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3843 struct hda_multi_out *mout,
3844 struct snd_pcm_substream *substream,
3845 struct hda_pcm_stream *hinfo)
3847 struct snd_pcm_runtime *runtime = substream->runtime;
3848 runtime->hw.channels_max = mout->max_channels;
3849 if (mout->dig_out_nid) {
3850 if (!mout->analog_rates) {
3851 mout->analog_rates = hinfo->rates;
3852 mout->analog_formats = hinfo->formats;
3853 mout->analog_maxbps = hinfo->maxbps;
3855 runtime->hw.rates = mout->analog_rates;
3856 runtime->hw.formats = mout->analog_formats;
3857 hinfo->maxbps = mout->analog_maxbps;
3859 if (!mout->spdif_rates) {
3860 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3862 &mout->spdif_formats,
3863 &mout->spdif_maxbps);
3865 mutex_lock(&codec->spdif_mutex);
3866 if (mout->share_spdif) {
3867 if ((runtime->hw.rates & mout->spdif_rates) &&
3868 (runtime->hw.formats & mout->spdif_formats)) {
3869 runtime->hw.rates &= mout->spdif_rates;
3870 runtime->hw.formats &= mout->spdif_formats;
3871 if (mout->spdif_maxbps < hinfo->maxbps)
3872 hinfo->maxbps = mout->spdif_maxbps;
3874 mout->share_spdif = 0;
3875 /* FIXME: need notify? */
3878 mutex_unlock(&codec->spdif_mutex);
3880 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3881 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3883 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3886 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
3888 * Set up the i/o for analog out.
3889 * When the digital out is available, copy the front out to digital out, too.
3891 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3892 struct hda_multi_out *mout,
3893 unsigned int stream_tag,
3894 unsigned int format,
3895 struct snd_pcm_substream *substream)
3897 hda_nid_t *nids = mout->dac_nids;
3898 int chs = substream->runtime->channels;
3901 mutex_lock(&codec->spdif_mutex);
3902 if (mout->dig_out_nid && mout->share_spdif &&
3903 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3905 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3907 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3908 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3909 setup_dig_out_stream(codec, mout->dig_out_nid,
3910 stream_tag, format);
3912 mout->dig_out_used = 0;
3913 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3916 mutex_unlock(&codec->spdif_mutex);
3919 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3921 if (!mout->no_share_stream &&
3922 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3923 /* headphone out will just decode front left/right (stereo) */
3924 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3926 /* extra outputs copied from front */
3927 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3928 if (!mout->no_share_stream && mout->extra_out_nid[i])
3929 snd_hda_codec_setup_stream(codec,
3930 mout->extra_out_nid[i],
3931 stream_tag, 0, format);
3934 for (i = 1; i < mout->num_dacs; i++) {
3935 if (chs >= (i + 1) * 2) /* independent out */
3936 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3938 else if (!mout->no_share_stream) /* copy front */
3939 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3944 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3947 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
3949 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3950 struct hda_multi_out *mout)
3952 hda_nid_t *nids = mout->dac_nids;
3955 for (i = 0; i < mout->num_dacs; i++)
3956 snd_hda_codec_cleanup_stream(codec, nids[i]);
3958 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3959 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3960 if (mout->extra_out_nid[i])
3961 snd_hda_codec_cleanup_stream(codec,
3962 mout->extra_out_nid[i]);
3963 mutex_lock(&codec->spdif_mutex);
3964 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3965 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3966 mout->dig_out_used = 0;
3968 mutex_unlock(&codec->spdif_mutex);
3971 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3974 * Helper for automatic pin configuration
3977 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3979 for (; *list; list++)
3987 * Sort an associated group of pins according to their sequence numbers.
3989 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3996 for (i = 0; i < num_pins; i++) {
3997 for (j = i + 1; j < num_pins; j++) {
3998 if (sequences[i] > sequences[j]) {
4000 sequences[i] = sequences[j];
4012 * Parse all pin widgets and store the useful pin nids to cfg
4014 * The number of line-outs or any primary output is stored in line_outs,
4015 * and the corresponding output pins are assigned to line_out_pins[],
4016 * in the order of front, rear, CLFE, side, ...
4018 * If more extra outputs (speaker and headphone) are found, the pins are
4019 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
4020 * is detected, one of speaker of HP pins is assigned as the primary
4021 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4022 * if any analog output exists.
4024 * The analog input pins are assigned to input_pins array.
4025 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4028 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
4029 struct auto_pin_cfg *cfg,
4030 hda_nid_t *ignore_nids)
4032 hda_nid_t nid, end_nid;
4033 short seq, assoc_line_out, assoc_speaker;
4034 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4035 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
4036 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
4038 memset(cfg, 0, sizeof(*cfg));
4040 memset(sequences_line_out, 0, sizeof(sequences_line_out));
4041 memset(sequences_speaker, 0, sizeof(sequences_speaker));
4042 memset(sequences_hp, 0, sizeof(sequences_hp));
4043 assoc_line_out = assoc_speaker = 0;
4045 end_nid = codec->start_nid + codec->num_nodes;
4046 for (nid = codec->start_nid; nid < end_nid; nid++) {
4047 unsigned int wid_caps = get_wcaps(codec, nid);
4048 unsigned int wid_type = get_wcaps_type(wid_caps);
4049 unsigned int def_conf;
4052 /* read all default configuration for pin complex */
4053 if (wid_type != AC_WID_PIN)
4055 /* ignore the given nids (e.g. pc-beep returns error) */
4056 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4059 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4060 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
4062 loc = get_defcfg_location(def_conf);
4063 switch (get_defcfg_device(def_conf)) {
4064 case AC_JACK_LINE_OUT:
4065 seq = get_defcfg_sequence(def_conf);
4066 assoc = get_defcfg_association(def_conf);
4068 if (!(wid_caps & AC_WCAP_STEREO))
4069 if (!cfg->mono_out_pin)
4070 cfg->mono_out_pin = nid;
4073 if (!assoc_line_out)
4074 assoc_line_out = assoc;
4075 else if (assoc_line_out != assoc)
4077 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4079 cfg->line_out_pins[cfg->line_outs] = nid;
4080 sequences_line_out[cfg->line_outs] = seq;
4083 case AC_JACK_SPEAKER:
4084 seq = get_defcfg_sequence(def_conf);
4085 assoc = get_defcfg_association(def_conf);
4088 if (! assoc_speaker)
4089 assoc_speaker = assoc;
4090 else if (assoc_speaker != assoc)
4092 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4094 cfg->speaker_pins[cfg->speaker_outs] = nid;
4095 sequences_speaker[cfg->speaker_outs] = seq;
4096 cfg->speaker_outs++;
4098 case AC_JACK_HP_OUT:
4099 seq = get_defcfg_sequence(def_conf);
4100 assoc = get_defcfg_association(def_conf);
4101 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4103 cfg->hp_pins[cfg->hp_outs] = nid;
4104 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
4107 case AC_JACK_MIC_IN: {
4109 if (loc == AC_JACK_LOC_FRONT) {
4110 preferred = AUTO_PIN_FRONT_MIC;
4113 preferred = AUTO_PIN_MIC;
4114 alt = AUTO_PIN_FRONT_MIC;
4116 if (!cfg->input_pins[preferred])
4117 cfg->input_pins[preferred] = nid;
4118 else if (!cfg->input_pins[alt])
4119 cfg->input_pins[alt] = nid;
4122 case AC_JACK_LINE_IN:
4123 if (loc == AC_JACK_LOC_FRONT)
4124 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
4126 cfg->input_pins[AUTO_PIN_LINE] = nid;
4129 cfg->input_pins[AUTO_PIN_CD] = nid;
4132 cfg->input_pins[AUTO_PIN_AUX] = nid;
4134 case AC_JACK_SPDIF_OUT:
4135 case AC_JACK_DIG_OTHER_OUT:
4136 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
4138 cfg->dig_out_pins[cfg->dig_outs] = nid;
4139 cfg->dig_out_type[cfg->dig_outs] =
4140 (loc == AC_JACK_LOC_HDMI) ?
4141 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
4144 case AC_JACK_SPDIF_IN:
4145 case AC_JACK_DIG_OTHER_IN:
4146 cfg->dig_in_pin = nid;
4147 if (loc == AC_JACK_LOC_HDMI)
4148 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
4150 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
4156 * If no line-out is defined but multiple HPs are found,
4157 * some of them might be the real line-outs.
4159 if (!cfg->line_outs && cfg->hp_outs > 1) {
4161 while (i < cfg->hp_outs) {
4162 /* The real HPs should have the sequence 0x0f */
4163 if ((sequences_hp[i] & 0x0f) == 0x0f) {
4167 /* Move it to the line-out table */
4168 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
4169 sequences_line_out[cfg->line_outs] = sequences_hp[i];
4172 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
4173 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
4174 memmove(sequences_hp + i - 1, sequences_hp + i,
4175 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
4179 /* sort by sequence */
4180 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
4182 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
4184 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
4187 /* if we have only one mic, make it AUTO_PIN_MIC */
4188 if (!cfg->input_pins[AUTO_PIN_MIC] &&
4189 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
4190 cfg->input_pins[AUTO_PIN_MIC] =
4191 cfg->input_pins[AUTO_PIN_FRONT_MIC];
4192 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
4194 /* ditto for line-in */
4195 if (!cfg->input_pins[AUTO_PIN_LINE] &&
4196 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
4197 cfg->input_pins[AUTO_PIN_LINE] =
4198 cfg->input_pins[AUTO_PIN_FRONT_LINE];
4199 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
4203 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4204 * as a primary output
4206 if (!cfg->line_outs) {
4207 if (cfg->speaker_outs) {
4208 cfg->line_outs = cfg->speaker_outs;
4209 memcpy(cfg->line_out_pins, cfg->speaker_pins,
4210 sizeof(cfg->speaker_pins));
4211 cfg->speaker_outs = 0;
4212 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
4213 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
4214 } else if (cfg->hp_outs) {
4215 cfg->line_outs = cfg->hp_outs;
4216 memcpy(cfg->line_out_pins, cfg->hp_pins,
4217 sizeof(cfg->hp_pins));
4219 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4220 cfg->line_out_type = AUTO_PIN_HP_OUT;
4224 /* Reorder the surround channels
4225 * ALSA sequence is front/surr/clfe/side
4227 * 4-ch: front/surr => OK as it is
4228 * 6-ch: front/clfe/surr
4229 * 8-ch: front/clfe/rear/side|fc
4231 switch (cfg->line_outs) {
4234 nid = cfg->line_out_pins[1];
4235 cfg->line_out_pins[1] = cfg->line_out_pins[2];
4236 cfg->line_out_pins[2] = nid;
4241 * debug prints of the parsed results
4243 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4244 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
4245 cfg->line_out_pins[2], cfg->line_out_pins[3],
4246 cfg->line_out_pins[4]);
4247 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4248 cfg->speaker_outs, cfg->speaker_pins[0],
4249 cfg->speaker_pins[1], cfg->speaker_pins[2],
4250 cfg->speaker_pins[3], cfg->speaker_pins[4]);
4251 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4252 cfg->hp_outs, cfg->hp_pins[0],
4253 cfg->hp_pins[1], cfg->hp_pins[2],
4254 cfg->hp_pins[3], cfg->hp_pins[4]);
4255 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
4257 snd_printd(" dig-out=0x%x/0x%x\n",
4258 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
4259 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
4260 " cd=0x%x, aux=0x%x\n",
4261 cfg->input_pins[AUTO_PIN_MIC],
4262 cfg->input_pins[AUTO_PIN_FRONT_MIC],
4263 cfg->input_pins[AUTO_PIN_LINE],
4264 cfg->input_pins[AUTO_PIN_FRONT_LINE],
4265 cfg->input_pins[AUTO_PIN_CD],
4266 cfg->input_pins[AUTO_PIN_AUX]);
4267 if (cfg->dig_in_pin)
4268 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
4272 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
4274 /* labels for input pins */
4275 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
4276 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
4278 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
4287 * snd_hda_suspend - suspend the codecs
4290 * Returns 0 if successful.
4292 int snd_hda_suspend(struct hda_bus *bus)
4294 struct hda_codec *codec;
4296 list_for_each_entry(codec, &bus->codec_list, list) {
4297 #ifdef CONFIG_SND_HDA_POWER_SAVE
4298 if (!codec->power_on)
4301 hda_call_codec_suspend(codec);
4305 EXPORT_SYMBOL_HDA(snd_hda_suspend);
4308 * snd_hda_resume - resume the codecs
4311 * Returns 0 if successful.
4313 * This fucntion is defined only when POWER_SAVE isn't set.
4314 * In the power-save mode, the codec is resumed dynamically.
4316 int snd_hda_resume(struct hda_bus *bus)
4318 struct hda_codec *codec;
4320 list_for_each_entry(codec, &bus->codec_list, list) {
4321 if (snd_hda_codec_needs_resume(codec))
4322 hda_call_codec_resume(codec);
4326 EXPORT_SYMBOL_HDA(snd_hda_resume);
4327 #endif /* CONFIG_PM */
4334 * snd_array_new - get a new element from the given array
4335 * @array: the array object
4337 * Get a new element from the given array. If it exceeds the
4338 * pre-allocated array size, re-allocate the array.
4340 * Returns NULL if allocation failed.
4342 void *snd_array_new(struct snd_array *array)
4344 if (array->used >= array->alloced) {
4345 int num = array->alloced + array->alloc_align;
4347 if (snd_BUG_ON(num >= 4096))
4349 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
4353 memcpy(nlist, array->list,
4354 array->elem_size * array->alloced);
4357 array->list = nlist;
4358 array->alloced = num;
4360 return snd_array_elem(array, array->used++);
4362 EXPORT_SYMBOL_HDA(snd_array_new);
4365 * snd_array_free - free the given array elements
4366 * @array: the array object
4368 void snd_array_free(struct snd_array *array)
4375 EXPORT_SYMBOL_HDA(snd_array_free);
4378 * snd_print_pcm_rates - Print the supported PCM rates to the string buffer
4379 * @pcm: PCM caps bits
4380 * @buf: the string buffer to write
4381 * @buflen: the max buffer length
4383 * used by hda_proc.c and hda_eld.c
4385 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
4387 static unsigned int rates[] = {
4388 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
4389 96000, 176400, 192000, 384000
4393 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
4395 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
4397 buf[j] = '\0'; /* necessary when j == 0 */
4399 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
4402 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4403 * @pcm: PCM caps bits
4404 * @buf: the string buffer to write
4405 * @buflen: the max buffer length
4407 * used by hda_proc.c and hda_eld.c
4409 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4411 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
4414 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4415 if (pcm & (AC_SUPPCM_BITS_8 << i))
4416 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
4418 buf[j] = '\0'; /* necessary when j == 0 */
4420 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
4422 MODULE_DESCRIPTION("HDA codec core");
4423 MODULE_LICENSE("GPL");