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);
1090 if (is_generic_config(codec)) {
1091 err = snd_hda_parse_generic_codec(codec);
1094 if (codec->preset && codec->preset->patch) {
1095 err = codec->preset->patch(codec);
1099 /* call the default parser */
1100 err = snd_hda_parse_generic_codec(codec);
1102 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1105 if (!err && codec->patch_ops.unsol_event)
1106 err = init_unsol_queue(codec->bus);
1107 /* audio codec should override the mixer name */
1108 if (!err && (codec->afg || !*codec->bus->card->mixername))
1109 snprintf(codec->bus->card->mixername,
1110 sizeof(codec->bus->card->mixername),
1111 "%s %s", codec->vendor_name, codec->chip_name);
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 * snd_hda_pin_sense - execute pin sense measurement
1322 * @codec: the CODEC to sense
1323 * @nid: the pin NID to sense
1325 * Execute necessary pin sense measurement and return its Presence Detect,
1326 * Impedance, ELD Valid etc. status bits.
1328 u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
1332 if (!codec->no_trigger_sense) {
1333 pincap = snd_hda_query_pin_caps(codec, nid);
1334 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
1335 snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0);
1337 return snd_hda_codec_read(codec, nid, 0,
1338 AC_VERB_GET_PIN_SENSE, 0);
1340 EXPORT_SYMBOL_HDA(snd_hda_pin_sense);
1343 * snd_hda_jack_detect - query pin Presence Detect status
1344 * @codec: the CODEC to sense
1345 * @nid: the pin NID to sense
1347 * Query and return the pin's Presence Detect status.
1349 int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
1351 u32 sense = snd_hda_pin_sense(codec, nid);
1352 return !!(sense & AC_PINSENSE_PRESENCE);
1354 EXPORT_SYMBOL_HDA(snd_hda_jack_detect);
1357 * read the current volume to info
1358 * if the cache exists, read the cache value.
1360 static unsigned int get_vol_mute(struct hda_codec *codec,
1361 struct hda_amp_info *info, hda_nid_t nid,
1362 int ch, int direction, int index)
1366 if (info->head.val & INFO_AMP_VOL(ch))
1367 return info->vol[ch];
1369 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1370 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1372 val = snd_hda_codec_read(codec, nid, 0,
1373 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1374 info->vol[ch] = val & 0xff;
1375 info->head.val |= INFO_AMP_VOL(ch);
1376 return info->vol[ch];
1380 * write the current volume in info to the h/w and update the cache
1382 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1383 hda_nid_t nid, int ch, int direction, int index,
1388 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1389 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1390 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1392 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1393 info->vol[ch] = val;
1397 * snd_hda_codec_amp_read - Read AMP value
1398 * @codec: HD-audio codec
1399 * @nid: NID to read the AMP value
1400 * @ch: channel (left=0 or right=1)
1401 * @direction: #HDA_INPUT or #HDA_OUTPUT
1402 * @index: the index value (only for input direction)
1404 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1406 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1407 int direction, int index)
1409 struct hda_amp_info *info;
1410 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1413 return get_vol_mute(codec, info, nid, ch, direction, index);
1415 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1418 * snd_hda_codec_amp_update - update the AMP value
1419 * @codec: HD-audio codec
1420 * @nid: NID to read the AMP value
1421 * @ch: channel (left=0 or right=1)
1422 * @direction: #HDA_INPUT or #HDA_OUTPUT
1423 * @idx: the index value (only for input direction)
1424 * @mask: bit mask to set
1425 * @val: the bits value to set
1427 * Update the AMP value with a bit mask.
1428 * Returns 0 if the value is unchanged, 1 if changed.
1430 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1431 int direction, int idx, int mask, int val)
1433 struct hda_amp_info *info;
1435 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1439 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1440 if (info->vol[ch] == val)
1442 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1445 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1448 * snd_hda_codec_amp_stereo - update the AMP stereo values
1449 * @codec: HD-audio codec
1450 * @nid: NID to read the AMP value
1451 * @direction: #HDA_INPUT or #HDA_OUTPUT
1452 * @idx: the index value (only for input direction)
1453 * @mask: bit mask to set
1454 * @val: the bits value to set
1456 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1457 * stereo widget with the same mask and value.
1459 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1460 int direction, int idx, int mask, int val)
1463 for (ch = 0; ch < 2; ch++)
1464 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1468 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1470 #ifdef SND_HDA_NEEDS_RESUME
1472 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1473 * @codec: HD-audio codec
1475 * Resume the all amp commands from the cache.
1477 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1479 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1482 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1483 u32 key = buffer->head.key;
1485 unsigned int idx, dir, ch;
1489 idx = (key >> 16) & 0xff;
1490 dir = (key >> 24) & 0xff;
1491 for (ch = 0; ch < 2; ch++) {
1492 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1494 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1499 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1500 #endif /* SND_HDA_NEEDS_RESUME */
1503 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1505 * The control element is supposed to have the private_value field
1506 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1508 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1509 struct snd_ctl_elem_info *uinfo)
1511 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1512 u16 nid = get_amp_nid(kcontrol);
1513 u8 chs = get_amp_channels(kcontrol);
1514 int dir = get_amp_direction(kcontrol);
1515 unsigned int ofs = get_amp_offset(kcontrol);
1518 caps = query_amp_caps(codec, nid, dir);
1520 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1522 printk(KERN_WARNING "hda_codec: "
1523 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1529 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1530 uinfo->count = chs == 3 ? 2 : 1;
1531 uinfo->value.integer.min = 0;
1532 uinfo->value.integer.max = caps;
1535 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1538 static inline unsigned int
1539 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1540 int ch, int dir, int idx, unsigned int ofs)
1543 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1544 val &= HDA_AMP_VOLMASK;
1553 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1554 int ch, int dir, int idx, unsigned int ofs,
1559 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1560 HDA_AMP_VOLMASK, val);
1564 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1566 * The control element is supposed to have the private_value field
1567 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1569 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1570 struct snd_ctl_elem_value *ucontrol)
1572 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1573 hda_nid_t nid = get_amp_nid(kcontrol);
1574 int chs = get_amp_channels(kcontrol);
1575 int dir = get_amp_direction(kcontrol);
1576 int idx = get_amp_index(kcontrol);
1577 unsigned int ofs = get_amp_offset(kcontrol);
1578 long *valp = ucontrol->value.integer.value;
1581 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1583 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1586 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1589 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1591 * The control element is supposed to have the private_value field
1592 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1594 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1595 struct snd_ctl_elem_value *ucontrol)
1597 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1598 hda_nid_t nid = get_amp_nid(kcontrol);
1599 int chs = get_amp_channels(kcontrol);
1600 int dir = get_amp_direction(kcontrol);
1601 int idx = get_amp_index(kcontrol);
1602 unsigned int ofs = get_amp_offset(kcontrol);
1603 long *valp = ucontrol->value.integer.value;
1606 snd_hda_power_up(codec);
1608 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1612 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1613 snd_hda_power_down(codec);
1616 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1619 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
1621 * The control element is supposed to have the private_value field
1622 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1624 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1625 unsigned int size, unsigned int __user *_tlv)
1627 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1628 hda_nid_t nid = get_amp_nid(kcontrol);
1629 int dir = get_amp_direction(kcontrol);
1630 unsigned int ofs = get_amp_offset(kcontrol);
1631 u32 caps, val1, val2;
1633 if (size < 4 * sizeof(unsigned int))
1635 caps = query_amp_caps(codec, nid, dir);
1636 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1637 val2 = (val2 + 1) * 25;
1638 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1640 val1 = ((int)val1) * ((int)val2);
1641 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1643 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1645 if (put_user(val1, _tlv + 2))
1647 if (put_user(val2, _tlv + 3))
1651 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1654 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1655 * @codec: HD-audio codec
1656 * @nid: NID of a reference widget
1657 * @dir: #HDA_INPUT or #HDA_OUTPUT
1658 * @tlv: TLV data to be stored, at least 4 elements
1660 * Set (static) TLV data for a virtual master volume using the AMP caps
1661 * obtained from the reference NID.
1662 * The volume range is recalculated as if the max volume is 0dB.
1664 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1670 caps = query_amp_caps(codec, nid, dir);
1671 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1672 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1673 step = (step + 1) * 25;
1674 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1675 tlv[1] = 2 * sizeof(unsigned int);
1676 tlv[2] = -nums * step;
1679 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1681 /* find a mixer control element with the given name */
1682 static struct snd_kcontrol *
1683 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1684 const char *name, int idx)
1686 struct snd_ctl_elem_id id;
1687 memset(&id, 0, sizeof(id));
1688 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1690 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1692 strcpy(id.name, name);
1693 return snd_ctl_find_id(codec->bus->card, &id);
1697 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1698 * @codec: HD-audio codec
1699 * @name: ctl id name string
1701 * Get the control element with the given id string and IFACE_MIXER.
1703 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1706 return _snd_hda_find_mixer_ctl(codec, name, 0);
1708 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1711 * snd_hda_ctl-add - Add a control element and assign to the codec
1712 * @codec: HD-audio codec
1713 * @nid: corresponding NID (optional)
1714 * @kctl: the control element to assign
1716 * Add the given control element to an array inside the codec instance.
1717 * All control elements belonging to a codec are supposed to be added
1718 * by this function so that a proper clean-up works at the free or
1719 * reconfiguration time.
1721 * If non-zero @nid is passed, the NID is assigned to the control element.
1722 * The assignment is shown in the codec proc file.
1724 * snd_hda_ctl_add() checks the control subdev id field whether
1725 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
1726 * bits value is taken as the NID to assign.
1728 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
1729 struct snd_kcontrol *kctl)
1732 struct hda_nid_item *item;
1734 if (kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) {
1736 nid = kctl->id.subdevice & 0xffff;
1737 kctl->id.subdevice = 0;
1739 err = snd_ctl_add(codec->bus->card, kctl);
1742 item = snd_array_new(&codec->mixers);
1749 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1752 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
1753 * @codec: HD-audio codec
1755 void snd_hda_ctls_clear(struct hda_codec *codec)
1758 struct hda_nid_item *items = codec->mixers.list;
1759 for (i = 0; i < codec->mixers.used; i++)
1760 snd_ctl_remove(codec->bus->card, items[i].kctl);
1761 snd_array_free(&codec->mixers);
1764 /* pseudo device locking
1765 * toggle card->shutdown to allow/disallow the device access (as a hack)
1767 static int hda_lock_devices(struct snd_card *card)
1769 spin_lock(&card->files_lock);
1770 if (card->shutdown) {
1771 spin_unlock(&card->files_lock);
1775 spin_unlock(&card->files_lock);
1779 static void hda_unlock_devices(struct snd_card *card)
1781 spin_lock(&card->files_lock);
1783 spin_unlock(&card->files_lock);
1787 * snd_hda_codec_reset - Clear all objects assigned to the codec
1788 * @codec: HD-audio codec
1790 * This frees the all PCM and control elements assigned to the codec, and
1791 * clears the caches and restores the pin default configurations.
1793 * When a device is being used, it returns -EBSY. If successfully freed,
1796 int snd_hda_codec_reset(struct hda_codec *codec)
1798 struct snd_card *card = codec->bus->card;
1801 if (hda_lock_devices(card) < 0)
1803 /* check whether the codec isn't used by any mixer or PCM streams */
1804 if (!list_empty(&card->ctl_files)) {
1805 hda_unlock_devices(card);
1808 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1809 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1812 if (cpcm->pcm->streams[0].substream_opened ||
1813 cpcm->pcm->streams[1].substream_opened) {
1814 hda_unlock_devices(card);
1819 /* OK, let it free */
1821 #ifdef CONFIG_SND_HDA_POWER_SAVE
1822 cancel_delayed_work(&codec->power_work);
1823 flush_workqueue(codec->bus->workq);
1825 snd_hda_ctls_clear(codec);
1827 for (i = 0; i < codec->num_pcms; i++) {
1828 if (codec->pcm_info[i].pcm) {
1829 snd_device_free(card, codec->pcm_info[i].pcm);
1830 clear_bit(codec->pcm_info[i].device,
1831 codec->bus->pcm_dev_bits);
1834 if (codec->patch_ops.free)
1835 codec->patch_ops.free(codec);
1836 codec->proc_widget_hook = NULL;
1838 free_hda_cache(&codec->amp_cache);
1839 free_hda_cache(&codec->cmd_cache);
1840 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1841 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1842 /* free only driver_pins so that init_pins + user_pins are restored */
1843 snd_array_free(&codec->driver_pins);
1844 restore_pincfgs(codec);
1845 codec->num_pcms = 0;
1846 codec->pcm_info = NULL;
1847 codec->preset = NULL;
1848 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1849 codec->slave_dig_outs = NULL;
1850 codec->spdif_status_reset = 0;
1851 module_put(codec->owner);
1852 codec->owner = NULL;
1854 /* allow device access again */
1855 hda_unlock_devices(card);
1860 * snd_hda_add_vmaster - create a virtual master control and add slaves
1861 * @codec: HD-audio codec
1862 * @name: vmaster control name
1863 * @tlv: TLV data (optional)
1864 * @slaves: slave control names (optional)
1866 * Create a virtual master control with the given name. The TLV data
1867 * must be either NULL or a valid data.
1869 * @slaves is a NULL-terminated array of strings, each of which is a
1870 * slave control name. All controls with these names are assigned to
1871 * the new virtual master control.
1873 * This function returns zero if successful or a negative error code.
1875 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1876 unsigned int *tlv, const char **slaves)
1878 struct snd_kcontrol *kctl;
1882 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1885 snd_printdd("No slave found for %s\n", name);
1888 kctl = snd_ctl_make_virtual_master(name, tlv);
1891 err = snd_hda_ctl_add(codec, 0, kctl);
1895 for (s = slaves; *s; s++) {
1896 struct snd_kcontrol *sctl;
1899 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1902 snd_printdd("Cannot find slave %s, "
1906 err = snd_ctl_add_slave(kctl, sctl);
1914 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1917 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
1919 * The control element is supposed to have the private_value field
1920 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1922 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1923 struct snd_ctl_elem_info *uinfo)
1925 int chs = get_amp_channels(kcontrol);
1927 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1928 uinfo->count = chs == 3 ? 2 : 1;
1929 uinfo->value.integer.min = 0;
1930 uinfo->value.integer.max = 1;
1933 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1936 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
1938 * The control element is supposed to have the private_value field
1939 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1941 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1942 struct snd_ctl_elem_value *ucontrol)
1944 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1945 hda_nid_t nid = get_amp_nid(kcontrol);
1946 int chs = get_amp_channels(kcontrol);
1947 int dir = get_amp_direction(kcontrol);
1948 int idx = get_amp_index(kcontrol);
1949 long *valp = ucontrol->value.integer.value;
1952 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1953 HDA_AMP_MUTE) ? 0 : 1;
1955 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1956 HDA_AMP_MUTE) ? 0 : 1;
1959 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1962 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
1964 * The control element is supposed to have the private_value field
1965 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1967 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1968 struct snd_ctl_elem_value *ucontrol)
1970 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1971 hda_nid_t nid = get_amp_nid(kcontrol);
1972 int chs = get_amp_channels(kcontrol);
1973 int dir = get_amp_direction(kcontrol);
1974 int idx = get_amp_index(kcontrol);
1975 long *valp = ucontrol->value.integer.value;
1978 snd_hda_power_up(codec);
1980 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1982 *valp ? 0 : HDA_AMP_MUTE);
1986 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1988 *valp ? 0 : HDA_AMP_MUTE);
1989 #ifdef CONFIG_SND_HDA_POWER_SAVE
1990 if (codec->patch_ops.check_power_status)
1991 codec->patch_ops.check_power_status(codec, nid);
1993 snd_hda_power_down(codec);
1996 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1998 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2000 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2002 * This function calls snd_hda_enable_beep_device(), which behaves differently
2003 * depending on beep_mode option.
2005 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2006 struct snd_ctl_elem_value *ucontrol)
2008 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2009 long *valp = ucontrol->value.integer.value;
2011 snd_hda_enable_beep_device(codec, *valp);
2012 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2014 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
2015 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2018 * bound volume controls
2020 * bind multiple volumes (# indices, from 0)
2023 #define AMP_VAL_IDX_SHIFT 19
2024 #define AMP_VAL_IDX_MASK (0x0f<<19)
2027 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2029 * The control element is supposed to have the private_value field
2030 * set up via HDA_BIND_MUTE*() macros.
2032 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2033 struct snd_ctl_elem_value *ucontrol)
2035 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2039 mutex_lock(&codec->control_mutex);
2040 pval = kcontrol->private_value;
2041 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2042 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2043 kcontrol->private_value = pval;
2044 mutex_unlock(&codec->control_mutex);
2047 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2050 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2052 * The control element is supposed to have the private_value field
2053 * set up via HDA_BIND_MUTE*() macros.
2055 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2056 struct snd_ctl_elem_value *ucontrol)
2058 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2060 int i, indices, err = 0, change = 0;
2062 mutex_lock(&codec->control_mutex);
2063 pval = kcontrol->private_value;
2064 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2065 for (i = 0; i < indices; i++) {
2066 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2067 (i << AMP_VAL_IDX_SHIFT);
2068 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2073 kcontrol->private_value = pval;
2074 mutex_unlock(&codec->control_mutex);
2075 return err < 0 ? err : change;
2077 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2080 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2082 * The control element is supposed to have the private_value field
2083 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2085 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2086 struct snd_ctl_elem_info *uinfo)
2088 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2089 struct hda_bind_ctls *c;
2092 mutex_lock(&codec->control_mutex);
2093 c = (struct hda_bind_ctls *)kcontrol->private_value;
2094 kcontrol->private_value = *c->values;
2095 err = c->ops->info(kcontrol, uinfo);
2096 kcontrol->private_value = (long)c;
2097 mutex_unlock(&codec->control_mutex);
2100 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2103 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2105 * The control element is supposed to have the private_value field
2106 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2108 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2109 struct snd_ctl_elem_value *ucontrol)
2111 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2112 struct hda_bind_ctls *c;
2115 mutex_lock(&codec->control_mutex);
2116 c = (struct hda_bind_ctls *)kcontrol->private_value;
2117 kcontrol->private_value = *c->values;
2118 err = c->ops->get(kcontrol, ucontrol);
2119 kcontrol->private_value = (long)c;
2120 mutex_unlock(&codec->control_mutex);
2123 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2126 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2128 * The control element is supposed to have the private_value field
2129 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2131 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2132 struct snd_ctl_elem_value *ucontrol)
2134 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2135 struct hda_bind_ctls *c;
2136 unsigned long *vals;
2137 int err = 0, change = 0;
2139 mutex_lock(&codec->control_mutex);
2140 c = (struct hda_bind_ctls *)kcontrol->private_value;
2141 for (vals = c->values; *vals; vals++) {
2142 kcontrol->private_value = *vals;
2143 err = c->ops->put(kcontrol, ucontrol);
2148 kcontrol->private_value = (long)c;
2149 mutex_unlock(&codec->control_mutex);
2150 return err < 0 ? err : change;
2152 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2155 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2157 * The control element is supposed to have the private_value field
2158 * set up via HDA_BIND_VOL() macro.
2160 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2161 unsigned int size, unsigned int __user *tlv)
2163 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2164 struct hda_bind_ctls *c;
2167 mutex_lock(&codec->control_mutex);
2168 c = (struct hda_bind_ctls *)kcontrol->private_value;
2169 kcontrol->private_value = *c->values;
2170 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2171 kcontrol->private_value = (long)c;
2172 mutex_unlock(&codec->control_mutex);
2175 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2177 struct hda_ctl_ops snd_hda_bind_vol = {
2178 .info = snd_hda_mixer_amp_volume_info,
2179 .get = snd_hda_mixer_amp_volume_get,
2180 .put = snd_hda_mixer_amp_volume_put,
2181 .tlv = snd_hda_mixer_amp_tlv
2183 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2185 struct hda_ctl_ops snd_hda_bind_sw = {
2186 .info = snd_hda_mixer_amp_switch_info,
2187 .get = snd_hda_mixer_amp_switch_get,
2188 .put = snd_hda_mixer_amp_switch_put,
2189 .tlv = snd_hda_mixer_amp_tlv
2191 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2194 * SPDIF out controls
2197 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2198 struct snd_ctl_elem_info *uinfo)
2200 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2205 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2206 struct snd_ctl_elem_value *ucontrol)
2208 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2209 IEC958_AES0_NONAUDIO |
2210 IEC958_AES0_CON_EMPHASIS_5015 |
2211 IEC958_AES0_CON_NOT_COPYRIGHT;
2212 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2213 IEC958_AES1_CON_ORIGINAL;
2217 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2218 struct snd_ctl_elem_value *ucontrol)
2220 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2221 IEC958_AES0_NONAUDIO |
2222 IEC958_AES0_PRO_EMPHASIS_5015;
2226 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2227 struct snd_ctl_elem_value *ucontrol)
2229 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2231 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
2232 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
2233 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
2234 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
2239 /* convert from SPDIF status bits to HDA SPDIF bits
2240 * bit 0 (DigEn) is always set zero (to be filled later)
2242 static unsigned short convert_from_spdif_status(unsigned int sbits)
2244 unsigned short val = 0;
2246 if (sbits & IEC958_AES0_PROFESSIONAL)
2247 val |= AC_DIG1_PROFESSIONAL;
2248 if (sbits & IEC958_AES0_NONAUDIO)
2249 val |= AC_DIG1_NONAUDIO;
2250 if (sbits & IEC958_AES0_PROFESSIONAL) {
2251 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2252 IEC958_AES0_PRO_EMPHASIS_5015)
2253 val |= AC_DIG1_EMPHASIS;
2255 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2256 IEC958_AES0_CON_EMPHASIS_5015)
2257 val |= AC_DIG1_EMPHASIS;
2258 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2259 val |= AC_DIG1_COPYRIGHT;
2260 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2261 val |= AC_DIG1_LEVEL;
2262 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2267 /* convert to SPDIF status bits from HDA SPDIF bits
2269 static unsigned int convert_to_spdif_status(unsigned short val)
2271 unsigned int sbits = 0;
2273 if (val & AC_DIG1_NONAUDIO)
2274 sbits |= IEC958_AES0_NONAUDIO;
2275 if (val & AC_DIG1_PROFESSIONAL)
2276 sbits |= IEC958_AES0_PROFESSIONAL;
2277 if (sbits & IEC958_AES0_PROFESSIONAL) {
2278 if (sbits & AC_DIG1_EMPHASIS)
2279 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2281 if (val & AC_DIG1_EMPHASIS)
2282 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2283 if (!(val & AC_DIG1_COPYRIGHT))
2284 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2285 if (val & AC_DIG1_LEVEL)
2286 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2287 sbits |= val & (0x7f << 8);
2292 /* set digital convert verbs both for the given NID and its slaves */
2293 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2298 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2299 d = codec->slave_dig_outs;
2303 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2306 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2310 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2312 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2315 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2316 struct snd_ctl_elem_value *ucontrol)
2318 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2319 hda_nid_t nid = kcontrol->private_value;
2323 mutex_lock(&codec->spdif_mutex);
2324 codec->spdif_status = ucontrol->value.iec958.status[0] |
2325 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2326 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2327 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2328 val = convert_from_spdif_status(codec->spdif_status);
2329 val |= codec->spdif_ctls & 1;
2330 change = codec->spdif_ctls != val;
2331 codec->spdif_ctls = val;
2334 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2336 mutex_unlock(&codec->spdif_mutex);
2340 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2342 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2343 struct snd_ctl_elem_value *ucontrol)
2345 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2347 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
2351 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2352 struct snd_ctl_elem_value *ucontrol)
2354 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2355 hda_nid_t nid = kcontrol->private_value;
2359 mutex_lock(&codec->spdif_mutex);
2360 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2361 if (ucontrol->value.integer.value[0])
2362 val |= AC_DIG1_ENABLE;
2363 change = codec->spdif_ctls != val;
2365 codec->spdif_ctls = val;
2366 set_dig_out_convert(codec, nid, val & 0xff, -1);
2367 /* unmute amp switch (if any) */
2368 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2369 (val & AC_DIG1_ENABLE))
2370 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2373 mutex_unlock(&codec->spdif_mutex);
2377 static struct snd_kcontrol_new dig_mixes[] = {
2379 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2380 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2381 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2382 .info = snd_hda_spdif_mask_info,
2383 .get = snd_hda_spdif_cmask_get,
2386 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2387 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2388 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2389 .info = snd_hda_spdif_mask_info,
2390 .get = snd_hda_spdif_pmask_get,
2393 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2394 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2395 .info = snd_hda_spdif_mask_info,
2396 .get = snd_hda_spdif_default_get,
2397 .put = snd_hda_spdif_default_put,
2400 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2401 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2402 .info = snd_hda_spdif_out_switch_info,
2403 .get = snd_hda_spdif_out_switch_get,
2404 .put = snd_hda_spdif_out_switch_put,
2409 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2412 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2413 * @codec: the HDA codec
2414 * @nid: audio out widget NID
2416 * Creates controls related with the SPDIF output.
2417 * Called from each patch supporting the SPDIF out.
2419 * Returns 0 if successful, or a negative error code.
2421 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2424 struct snd_kcontrol *kctl;
2425 struct snd_kcontrol_new *dig_mix;
2428 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2429 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2433 if (idx >= SPDIF_MAX_IDX) {
2434 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2437 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2438 kctl = snd_ctl_new1(dig_mix, codec);
2441 kctl->id.index = idx;
2442 kctl->private_value = nid;
2443 err = snd_hda_ctl_add(codec, nid, kctl);
2448 snd_hda_codec_read(codec, nid, 0,
2449 AC_VERB_GET_DIGI_CONVERT_1, 0);
2450 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2453 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2456 * SPDIF sharing with analog output
2458 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2459 struct snd_ctl_elem_value *ucontrol)
2461 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2462 ucontrol->value.integer.value[0] = mout->share_spdif;
2466 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2467 struct snd_ctl_elem_value *ucontrol)
2469 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2470 mout->share_spdif = !!ucontrol->value.integer.value[0];
2474 static struct snd_kcontrol_new spdif_share_sw = {
2475 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2476 .name = "IEC958 Default PCM Playback Switch",
2477 .info = snd_ctl_boolean_mono_info,
2478 .get = spdif_share_sw_get,
2479 .put = spdif_share_sw_put,
2483 * snd_hda_create_spdif_share_sw - create Default PCM switch
2484 * @codec: the HDA codec
2485 * @mout: multi-out instance
2487 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2488 struct hda_multi_out *mout)
2490 if (!mout->dig_out_nid)
2492 /* ATTENTION: here mout is passed as private_data, instead of codec */
2493 return snd_hda_ctl_add(codec, mout->dig_out_nid,
2494 snd_ctl_new1(&spdif_share_sw, mout));
2496 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2502 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2504 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2505 struct snd_ctl_elem_value *ucontrol)
2507 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2509 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2513 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2514 struct snd_ctl_elem_value *ucontrol)
2516 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2517 hda_nid_t nid = kcontrol->private_value;
2518 unsigned int val = !!ucontrol->value.integer.value[0];
2521 mutex_lock(&codec->spdif_mutex);
2522 change = codec->spdif_in_enable != val;
2524 codec->spdif_in_enable = val;
2525 snd_hda_codec_write_cache(codec, nid, 0,
2526 AC_VERB_SET_DIGI_CONVERT_1, val);
2528 mutex_unlock(&codec->spdif_mutex);
2532 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2533 struct snd_ctl_elem_value *ucontrol)
2535 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2536 hda_nid_t nid = kcontrol->private_value;
2540 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2541 sbits = convert_to_spdif_status(val);
2542 ucontrol->value.iec958.status[0] = sbits;
2543 ucontrol->value.iec958.status[1] = sbits >> 8;
2544 ucontrol->value.iec958.status[2] = sbits >> 16;
2545 ucontrol->value.iec958.status[3] = sbits >> 24;
2549 static struct snd_kcontrol_new dig_in_ctls[] = {
2551 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2552 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2553 .info = snd_hda_spdif_in_switch_info,
2554 .get = snd_hda_spdif_in_switch_get,
2555 .put = snd_hda_spdif_in_switch_put,
2558 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2559 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2560 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2561 .info = snd_hda_spdif_mask_info,
2562 .get = snd_hda_spdif_in_status_get,
2568 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2569 * @codec: the HDA codec
2570 * @nid: audio in widget NID
2572 * Creates controls related with the SPDIF input.
2573 * Called from each patch supporting the SPDIF in.
2575 * Returns 0 if successful, or a negative error code.
2577 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2580 struct snd_kcontrol *kctl;
2581 struct snd_kcontrol_new *dig_mix;
2584 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2585 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2589 if (idx >= SPDIF_MAX_IDX) {
2590 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2593 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2594 kctl = snd_ctl_new1(dig_mix, codec);
2597 kctl->private_value = nid;
2598 err = snd_hda_ctl_add(codec, nid, kctl);
2602 codec->spdif_in_enable =
2603 snd_hda_codec_read(codec, nid, 0,
2604 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2608 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2610 #ifdef SND_HDA_NEEDS_RESUME
2615 /* build a 32bit cache key with the widget id and the command parameter */
2616 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2617 #define get_cmd_cache_nid(key) ((key) & 0xff)
2618 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2621 * snd_hda_codec_write_cache - send a single command with caching
2622 * @codec: the HDA codec
2623 * @nid: NID to send the command
2624 * @direct: direct flag
2625 * @verb: the verb to send
2626 * @parm: the parameter for the verb
2628 * Send a single command without waiting for response.
2630 * Returns 0 if successful, or a negative error code.
2632 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2633 int direct, unsigned int verb, unsigned int parm)
2635 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2636 struct hda_cache_head *c;
2641 /* parm may contain the verb stuff for get/set amp */
2642 verb = verb | (parm >> 8);
2644 key = build_cmd_cache_key(nid, verb);
2645 mutex_lock(&codec->bus->cmd_mutex);
2646 c = get_alloc_hash(&codec->cmd_cache, key);
2649 mutex_unlock(&codec->bus->cmd_mutex);
2652 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2655 * snd_hda_codec_resume_cache - Resume the all commands from the cache
2656 * @codec: HD-audio codec
2658 * Execute all verbs recorded in the command caches to resume.
2660 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2662 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2665 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2666 u32 key = buffer->key;
2669 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2670 get_cmd_cache_cmd(key), buffer->val);
2673 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2676 * snd_hda_sequence_write_cache - sequence writes with caching
2677 * @codec: the HDA codec
2678 * @seq: VERB array to send
2680 * Send the commands sequentially from the given array.
2681 * Thte commands are recorded on cache for power-save and resume.
2682 * The array must be terminated with NID=0.
2684 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2685 const struct hda_verb *seq)
2687 for (; seq->nid; seq++)
2688 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2691 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2692 #endif /* SND_HDA_NEEDS_RESUME */
2695 * set power state of the codec
2697 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2698 unsigned int power_state)
2703 /* this delay seems necessary to avoid click noise at power-down */
2704 if (power_state == AC_PWRST_D3)
2706 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2708 /* partial workaround for "azx_get_response timeout" */
2709 if (power_state == AC_PWRST_D0)
2712 nid = codec->start_nid;
2713 for (i = 0; i < codec->num_nodes; i++, nid++) {
2714 unsigned int wcaps = get_wcaps(codec, nid);
2715 if (wcaps & AC_WCAP_POWER) {
2716 unsigned int wid_type = get_wcaps_type(wcaps);
2717 if (power_state == AC_PWRST_D3 &&
2718 wid_type == AC_WID_PIN) {
2719 unsigned int pincap;
2721 * don't power down the widget if it controls
2722 * eapd and EAPD_BTLENABLE is set.
2724 pincap = snd_hda_query_pin_caps(codec, nid);
2725 if (pincap & AC_PINCAP_EAPD) {
2726 int eapd = snd_hda_codec_read(codec,
2728 AC_VERB_GET_EAPD_BTLENABLE, 0);
2734 snd_hda_codec_write(codec, nid, 0,
2735 AC_VERB_SET_POWER_STATE,
2740 if (power_state == AC_PWRST_D0) {
2741 unsigned long end_time;
2744 /* wait until the codec reachs to D0 */
2745 end_time = jiffies + msecs_to_jiffies(500);
2747 state = snd_hda_codec_read(codec, fg, 0,
2748 AC_VERB_GET_POWER_STATE, 0);
2749 if (state == power_state)
2752 } while (time_after_eq(end_time, jiffies));
2756 #ifdef CONFIG_SND_HDA_HWDEP
2757 /* execute additional init verbs */
2758 static void hda_exec_init_verbs(struct hda_codec *codec)
2760 if (codec->init_verbs.list)
2761 snd_hda_sequence_write(codec, codec->init_verbs.list);
2764 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2767 #ifdef SND_HDA_NEEDS_RESUME
2769 * call suspend and power-down; used both from PM and power-save
2771 static void hda_call_codec_suspend(struct hda_codec *codec)
2773 if (codec->patch_ops.suspend)
2774 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2775 hda_set_power_state(codec,
2776 codec->afg ? codec->afg : codec->mfg,
2778 #ifdef CONFIG_SND_HDA_POWER_SAVE
2779 snd_hda_update_power_acct(codec);
2780 cancel_delayed_work(&codec->power_work);
2781 codec->power_on = 0;
2782 codec->power_transition = 0;
2783 codec->power_jiffies = jiffies;
2788 * kick up codec; used both from PM and power-save
2790 static void hda_call_codec_resume(struct hda_codec *codec)
2792 hda_set_power_state(codec,
2793 codec->afg ? codec->afg : codec->mfg,
2795 restore_pincfgs(codec); /* restore all current pin configs */
2796 hda_exec_init_verbs(codec);
2797 if (codec->patch_ops.resume)
2798 codec->patch_ops.resume(codec);
2800 if (codec->patch_ops.init)
2801 codec->patch_ops.init(codec);
2802 snd_hda_codec_resume_amp(codec);
2803 snd_hda_codec_resume_cache(codec);
2806 #endif /* SND_HDA_NEEDS_RESUME */
2810 * snd_hda_build_controls - build mixer controls
2813 * Creates mixer controls for each codec included in the bus.
2815 * Returns 0 if successful, otherwise a negative error code.
2817 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2819 struct hda_codec *codec;
2821 list_for_each_entry(codec, &bus->codec_list, list) {
2822 int err = snd_hda_codec_build_controls(codec);
2824 printk(KERN_ERR "hda_codec: cannot build controls"
2825 "for #%d (error %d)\n", codec->addr, err);
2826 err = snd_hda_codec_reset(codec);
2829 "hda_codec: cannot revert codec\n");
2836 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2838 int snd_hda_codec_build_controls(struct hda_codec *codec)
2841 hda_exec_init_verbs(codec);
2842 /* continue to initialize... */
2843 if (codec->patch_ops.init)
2844 err = codec->patch_ops.init(codec);
2845 if (!err && codec->patch_ops.build_controls)
2846 err = codec->patch_ops.build_controls(codec);
2855 struct hda_rate_tbl {
2857 unsigned int alsa_bits;
2858 unsigned int hda_fmt;
2861 static struct hda_rate_tbl rate_bits[] = {
2862 /* rate in Hz, ALSA rate bitmask, HDA format value */
2864 /* autodetected value used in snd_hda_query_supported_pcm */
2865 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2866 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2867 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2868 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2869 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2870 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2871 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2872 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2873 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2874 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2875 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2876 #define AC_PAR_PCM_RATE_BITS 11
2877 /* up to bits 10, 384kHZ isn't supported properly */
2879 /* not autodetected value */
2880 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2882 { 0 } /* terminator */
2886 * snd_hda_calc_stream_format - calculate format bitset
2887 * @rate: the sample rate
2888 * @channels: the number of channels
2889 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2890 * @maxbps: the max. bps
2892 * Calculate the format bitset from the given rate, channels and th PCM format.
2894 * Return zero if invalid.
2896 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2897 unsigned int channels,
2898 unsigned int format,
2899 unsigned int maxbps)
2902 unsigned int val = 0;
2904 for (i = 0; rate_bits[i].hz; i++)
2905 if (rate_bits[i].hz == rate) {
2906 val = rate_bits[i].hda_fmt;
2909 if (!rate_bits[i].hz) {
2910 snd_printdd("invalid rate %d\n", rate);
2914 if (channels == 0 || channels > 8) {
2915 snd_printdd("invalid channels %d\n", channels);
2918 val |= channels - 1;
2920 switch (snd_pcm_format_width(format)) {
2921 case 8: val |= 0x00; break;
2922 case 16: val |= 0x10; break;
2926 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
2928 else if (maxbps >= 24)
2934 snd_printdd("invalid format width %d\n",
2935 snd_pcm_format_width(format));
2941 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2943 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2945 unsigned int val = 0;
2946 if (nid != codec->afg &&
2947 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2948 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2949 if (!val || val == -1)
2950 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2951 if (!val || val == -1)
2956 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2958 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2962 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2964 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2965 if (!streams || streams == -1)
2966 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2967 if (!streams || streams == -1)
2972 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2974 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2979 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2980 * @codec: the HDA codec
2981 * @nid: NID to query
2982 * @ratesp: the pointer to store the detected rate bitflags
2983 * @formatsp: the pointer to store the detected formats
2984 * @bpsp: the pointer to store the detected format widths
2986 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2987 * or @bsps argument is ignored.
2989 * Returns 0 if successful, otherwise a negative error code.
2991 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2992 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2994 unsigned int i, val, wcaps;
2996 wcaps = get_wcaps(codec, nid);
2997 val = query_pcm_param(codec, nid);
3001 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3003 rates |= rate_bits[i].alsa_bits;
3006 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3007 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3009 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3015 if (formatsp || bpsp) {
3017 unsigned int streams, bps;
3019 streams = query_stream_param(codec, nid);
3024 if (streams & AC_SUPFMT_PCM) {
3025 if (val & AC_SUPPCM_BITS_8) {
3026 formats |= SNDRV_PCM_FMTBIT_U8;
3029 if (val & AC_SUPPCM_BITS_16) {
3030 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3033 if (wcaps & AC_WCAP_DIGITAL) {
3034 if (val & AC_SUPPCM_BITS_32)
3035 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3036 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3037 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3038 if (val & AC_SUPPCM_BITS_24)
3040 else if (val & AC_SUPPCM_BITS_20)
3042 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3043 AC_SUPPCM_BITS_32)) {
3044 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3045 if (val & AC_SUPPCM_BITS_32)
3047 else if (val & AC_SUPPCM_BITS_24)
3049 else if (val & AC_SUPPCM_BITS_20)
3053 if (streams & AC_SUPFMT_FLOAT32) {
3054 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3058 if (streams == AC_SUPFMT_AC3) {
3059 /* should be exclusive */
3060 /* temporary hack: we have still no proper support
3061 * for the direct AC3 stream...
3063 formats |= SNDRV_PCM_FMTBIT_U8;
3067 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3068 "(nid=0x%x, val=0x%x, ovrd=%i, "
3071 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3076 *formatsp = formats;
3085 * snd_hda_is_supported_format - Check the validity of the format
3086 * @codec: HD-audio codec
3087 * @nid: NID to check
3088 * @format: the HD-audio format value to check
3090 * Check whether the given node supports the format value.
3092 * Returns 1 if supported, 0 if not.
3094 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3095 unsigned int format)
3098 unsigned int val = 0, rate, stream;
3100 val = query_pcm_param(codec, nid);
3104 rate = format & 0xff00;
3105 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3106 if (rate_bits[i].hda_fmt == rate) {
3111 if (i >= AC_PAR_PCM_RATE_BITS)
3114 stream = query_stream_param(codec, nid);
3118 if (stream & AC_SUPFMT_PCM) {
3119 switch (format & 0xf0) {
3121 if (!(val & AC_SUPPCM_BITS_8))
3125 if (!(val & AC_SUPPCM_BITS_16))
3129 if (!(val & AC_SUPPCM_BITS_20))
3133 if (!(val & AC_SUPPCM_BITS_24))
3137 if (!(val & AC_SUPPCM_BITS_32))
3144 /* FIXME: check for float32 and AC3? */
3149 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3154 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3155 struct hda_codec *codec,
3156 struct snd_pcm_substream *substream)
3161 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3162 struct hda_codec *codec,
3163 unsigned int stream_tag,
3164 unsigned int format,
3165 struct snd_pcm_substream *substream)
3167 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3171 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3172 struct hda_codec *codec,
3173 struct snd_pcm_substream *substream)
3175 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3179 static int set_pcm_default_values(struct hda_codec *codec,
3180 struct hda_pcm_stream *info)
3184 /* query support PCM information from the given NID */
3185 if (info->nid && (!info->rates || !info->formats)) {
3186 err = snd_hda_query_supported_pcm(codec, info->nid,
3187 info->rates ? NULL : &info->rates,
3188 info->formats ? NULL : &info->formats,
3189 info->maxbps ? NULL : &info->maxbps);
3193 if (info->ops.open == NULL)
3194 info->ops.open = hda_pcm_default_open_close;
3195 if (info->ops.close == NULL)
3196 info->ops.close = hda_pcm_default_open_close;
3197 if (info->ops.prepare == NULL) {
3198 if (snd_BUG_ON(!info->nid))
3200 info->ops.prepare = hda_pcm_default_prepare;
3202 if (info->ops.cleanup == NULL) {
3203 if (snd_BUG_ON(!info->nid))
3205 info->ops.cleanup = hda_pcm_default_cleanup;
3211 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3212 "Audio", "SPDIF", "HDMI", "Modem"
3216 * get the empty PCM device number to assign
3218 static int get_empty_pcm_device(struct hda_bus *bus, int type)
3220 /* audio device indices; not linear to keep compatibility */
3221 static int audio_idx[HDA_PCM_NTYPES][5] = {
3222 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3223 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3224 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
3225 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
3229 if (type >= HDA_PCM_NTYPES) {
3230 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3234 for (i = 0; audio_idx[type][i] >= 0 ; i++)
3235 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3236 return audio_idx[type][i];
3238 snd_printk(KERN_WARNING "Too many %s devices\n", snd_hda_pcm_type_name[type]);
3243 * attach a new PCM stream
3245 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
3247 struct hda_bus *bus = codec->bus;
3248 struct hda_pcm_stream *info;
3251 if (snd_BUG_ON(!pcm->name))
3253 for (stream = 0; stream < 2; stream++) {
3254 info = &pcm->stream[stream];
3255 if (info->substreams) {
3256 err = set_pcm_default_values(codec, info);
3261 return bus->ops.attach_pcm(bus, codec, pcm);
3264 /* assign all PCMs of the given codec */
3265 int snd_hda_codec_build_pcms(struct hda_codec *codec)
3270 if (!codec->num_pcms) {
3271 if (!codec->patch_ops.build_pcms)
3273 err = codec->patch_ops.build_pcms(codec);
3275 printk(KERN_ERR "hda_codec: cannot build PCMs"
3276 "for #%d (error %d)\n", codec->addr, err);
3277 err = snd_hda_codec_reset(codec);
3280 "hda_codec: cannot revert codec\n");
3285 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
3286 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
3289 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
3290 continue; /* no substreams assigned */
3293 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
3295 continue; /* no fatal error */
3297 err = snd_hda_attach_pcm(codec, cpcm);
3299 printk(KERN_ERR "hda_codec: cannot attach "
3300 "PCM stream %d for codec #%d\n",
3302 continue; /* no fatal error */
3310 * snd_hda_build_pcms - build PCM information
3313 * Create PCM information for each codec included in the bus.
3315 * The build_pcms codec patch is requested to set up codec->num_pcms and
3316 * codec->pcm_info properly. The array is referred by the top-level driver
3317 * to create its PCM instances.
3318 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3321 * At least, substreams, channels_min and channels_max must be filled for
3322 * each stream. substreams = 0 indicates that the stream doesn't exist.
3323 * When rates and/or formats are zero, the supported values are queried
3324 * from the given nid. The nid is used also by the default ops.prepare
3325 * and ops.cleanup callbacks.
3327 * The driver needs to call ops.open in its open callback. Similarly,
3328 * ops.close is supposed to be called in the close callback.
3329 * ops.prepare should be called in the prepare or hw_params callback
3330 * with the proper parameters for set up.
3331 * ops.cleanup should be called in hw_free for clean up of streams.
3333 * This function returns 0 if successfull, or a negative error code.
3335 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
3337 struct hda_codec *codec;
3339 list_for_each_entry(codec, &bus->codec_list, list) {
3340 int err = snd_hda_codec_build_pcms(codec);
3346 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
3349 * snd_hda_check_board_config - compare the current codec with the config table
3350 * @codec: the HDA codec
3351 * @num_configs: number of config enums
3352 * @models: array of model name strings
3353 * @tbl: configuration table, terminated by null entries
3355 * Compares the modelname or PCI subsystem id of the current codec with the
3356 * given configuration table. If a matching entry is found, returns its
3357 * config value (supposed to be 0 or positive).
3359 * If no entries are matching, the function returns a negative value.
3361 int snd_hda_check_board_config(struct hda_codec *codec,
3362 int num_configs, const char **models,
3363 const struct snd_pci_quirk *tbl)
3365 if (codec->modelname && models) {
3367 for (i = 0; i < num_configs; i++) {
3369 !strcmp(codec->modelname, models[i])) {
3370 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3371 "selected\n", models[i]);
3377 if (!codec->bus->pci || !tbl)
3380 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3383 if (tbl->value >= 0 && tbl->value < num_configs) {
3384 #ifdef CONFIG_SND_DEBUG_VERBOSE
3386 const char *model = NULL;
3388 model = models[tbl->value];
3390 sprintf(tmp, "#%d", tbl->value);
3393 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3394 "for config %x:%x (%s)\n",
3395 model, tbl->subvendor, tbl->subdevice,
3396 (tbl->name ? tbl->name : "Unknown device"));
3402 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3405 * snd_hda_check_board_codec_sid_config - compare the current codec
3406 subsystem ID with the
3409 This is important for Gateway notebooks with SB450 HDA Audio
3410 where the vendor ID of the PCI device is:
3411 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3412 and the vendor/subvendor are found only at the codec.
3414 * @codec: the HDA codec
3415 * @num_configs: number of config enums
3416 * @models: array of model name strings
3417 * @tbl: configuration table, terminated by null entries
3419 * Compares the modelname or PCI subsystem id of the current codec with the
3420 * given configuration table. If a matching entry is found, returns its
3421 * config value (supposed to be 0 or positive).
3423 * If no entries are matching, the function returns a negative value.
3425 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3426 int num_configs, const char **models,
3427 const struct snd_pci_quirk *tbl)
3429 const struct snd_pci_quirk *q;
3431 /* Search for codec ID */
3432 for (q = tbl; q->subvendor; q++) {
3433 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3435 if (vendorid == codec->subsystem_id)
3444 if (tbl->value >= 0 && tbl->value < num_configs) {
3445 #ifdef CONFIG_SND_DEBUG_VERBOSE
3447 const char *model = NULL;
3449 model = models[tbl->value];
3451 sprintf(tmp, "#%d", tbl->value);
3454 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3455 "for config %x:%x (%s)\n",
3456 model, tbl->subvendor, tbl->subdevice,
3457 (tbl->name ? tbl->name : "Unknown device"));
3463 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3466 * snd_hda_add_new_ctls - create controls from the array
3467 * @codec: the HDA codec
3468 * @knew: the array of struct snd_kcontrol_new
3470 * This helper function creates and add new controls in the given array.
3471 * The array must be terminated with an empty entry as terminator.
3473 * Returns 0 if successful, or a negative error code.
3475 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3479 for (; knew->name; knew++) {
3480 struct snd_kcontrol *kctl;
3481 kctl = snd_ctl_new1(knew, codec);
3484 err = snd_hda_ctl_add(codec, 0, kctl);
3488 kctl = snd_ctl_new1(knew, codec);
3491 kctl->id.device = codec->addr;
3492 err = snd_hda_ctl_add(codec, 0, kctl);
3499 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3501 #ifdef CONFIG_SND_HDA_POWER_SAVE
3502 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3503 unsigned int power_state);
3505 static void hda_power_work(struct work_struct *work)
3507 struct hda_codec *codec =
3508 container_of(work, struct hda_codec, power_work.work);
3509 struct hda_bus *bus = codec->bus;
3511 if (!codec->power_on || codec->power_count) {
3512 codec->power_transition = 0;
3516 hda_call_codec_suspend(codec);
3517 if (bus->ops.pm_notify)
3518 bus->ops.pm_notify(bus);
3521 static void hda_keep_power_on(struct hda_codec *codec)
3523 codec->power_count++;
3524 codec->power_on = 1;
3525 codec->power_jiffies = jiffies;
3528 /* update the power on/off account with the current jiffies */
3529 void snd_hda_update_power_acct(struct hda_codec *codec)
3531 unsigned long delta = jiffies - codec->power_jiffies;
3532 if (codec->power_on)
3533 codec->power_on_acct += delta;
3535 codec->power_off_acct += delta;
3536 codec->power_jiffies += delta;
3540 * snd_hda_power_up - Power-up the codec
3541 * @codec: HD-audio codec
3543 * Increment the power-up counter and power up the hardware really when
3544 * not turned on yet.
3546 void snd_hda_power_up(struct hda_codec *codec)
3548 struct hda_bus *bus = codec->bus;
3550 codec->power_count++;
3551 if (codec->power_on || codec->power_transition)
3554 snd_hda_update_power_acct(codec);
3555 codec->power_on = 1;
3556 codec->power_jiffies = jiffies;
3557 if (bus->ops.pm_notify)
3558 bus->ops.pm_notify(bus);
3559 hda_call_codec_resume(codec);
3560 cancel_delayed_work(&codec->power_work);
3561 codec->power_transition = 0;
3563 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3565 #define power_save(codec) \
3566 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3569 * snd_hda_power_down - Power-down the codec
3570 * @codec: HD-audio codec
3572 * Decrement the power-up counter and schedules the power-off work if
3573 * the counter rearches to zero.
3575 void snd_hda_power_down(struct hda_codec *codec)
3577 --codec->power_count;
3578 if (!codec->power_on || codec->power_count || codec->power_transition)
3580 if (power_save(codec)) {
3581 codec->power_transition = 1; /* avoid reentrance */
3582 queue_delayed_work(codec->bus->workq, &codec->power_work,
3583 msecs_to_jiffies(power_save(codec) * 1000));
3586 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3589 * snd_hda_check_amp_list_power - Check the amp list and update the power
3590 * @codec: HD-audio codec
3591 * @check: the object containing an AMP list and the status
3592 * @nid: NID to check / update
3594 * Check whether the given NID is in the amp list. If it's in the list,
3595 * check the current AMP status, and update the the power-status according
3596 * to the mute status.
3598 * This function is supposed to be set or called from the check_power_status
3601 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3602 struct hda_loopback_check *check,
3605 struct hda_amp_list *p;
3608 if (!check->amplist)
3610 for (p = check->amplist; p->nid; p++) {
3615 return 0; /* nothing changed */
3617 for (p = check->amplist; p->nid; p++) {
3618 for (ch = 0; ch < 2; ch++) {
3619 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3621 if (!(v & HDA_AMP_MUTE) && v > 0) {
3622 if (!check->power_on) {
3623 check->power_on = 1;
3624 snd_hda_power_up(codec);
3630 if (check->power_on) {
3631 check->power_on = 0;
3632 snd_hda_power_down(codec);
3636 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3640 * Channel mode helper
3644 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
3646 int snd_hda_ch_mode_info(struct hda_codec *codec,
3647 struct snd_ctl_elem_info *uinfo,
3648 const struct hda_channel_mode *chmode,
3651 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3653 uinfo->value.enumerated.items = num_chmodes;
3654 if (uinfo->value.enumerated.item >= num_chmodes)
3655 uinfo->value.enumerated.item = num_chmodes - 1;
3656 sprintf(uinfo->value.enumerated.name, "%dch",
3657 chmode[uinfo->value.enumerated.item].channels);
3660 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3663 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
3665 int snd_hda_ch_mode_get(struct hda_codec *codec,
3666 struct snd_ctl_elem_value *ucontrol,
3667 const struct hda_channel_mode *chmode,
3673 for (i = 0; i < num_chmodes; i++) {
3674 if (max_channels == chmode[i].channels) {
3675 ucontrol->value.enumerated.item[0] = i;
3681 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3684 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
3686 int snd_hda_ch_mode_put(struct hda_codec *codec,
3687 struct snd_ctl_elem_value *ucontrol,
3688 const struct hda_channel_mode *chmode,
3694 mode = ucontrol->value.enumerated.item[0];
3695 if (mode >= num_chmodes)
3697 if (*max_channelsp == chmode[mode].channels)
3699 /* change the current channel setting */
3700 *max_channelsp = chmode[mode].channels;
3701 if (chmode[mode].sequence)
3702 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3705 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3712 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
3714 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3715 struct snd_ctl_elem_info *uinfo)
3719 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3721 uinfo->value.enumerated.items = imux->num_items;
3722 if (!imux->num_items)
3724 index = uinfo->value.enumerated.item;
3725 if (index >= imux->num_items)
3726 index = imux->num_items - 1;
3727 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3730 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3733 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
3735 int snd_hda_input_mux_put(struct hda_codec *codec,
3736 const struct hda_input_mux *imux,
3737 struct snd_ctl_elem_value *ucontrol,
3739 unsigned int *cur_val)
3743 if (!imux->num_items)
3745 idx = ucontrol->value.enumerated.item[0];
3746 if (idx >= imux->num_items)
3747 idx = imux->num_items - 1;
3748 if (*cur_val == idx)
3750 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3751 imux->items[idx].index);
3755 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3759 * Multi-channel / digital-out PCM helper functions
3762 /* setup SPDIF output stream */
3763 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3764 unsigned int stream_tag, unsigned int format)
3766 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3767 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3768 set_dig_out_convert(codec, nid,
3769 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3771 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3772 if (codec->slave_dig_outs) {
3774 for (d = codec->slave_dig_outs; *d; d++)
3775 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3778 /* turn on again (if needed) */
3779 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3780 set_dig_out_convert(codec, nid,
3781 codec->spdif_ctls & 0xff, -1);
3784 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3786 snd_hda_codec_cleanup_stream(codec, nid);
3787 if (codec->slave_dig_outs) {
3789 for (d = codec->slave_dig_outs; *d; d++)
3790 snd_hda_codec_cleanup_stream(codec, *d);
3795 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
3796 * @bus: HD-audio bus
3798 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
3800 struct hda_codec *codec;
3804 list_for_each_entry(codec, &bus->codec_list, list) {
3805 #ifdef CONFIG_SND_HDA_POWER_SAVE
3806 if (!codec->power_on)
3809 if (codec->patch_ops.reboot_notify)
3810 codec->patch_ops.reboot_notify(codec);
3813 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
3816 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
3818 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3819 struct hda_multi_out *mout)
3821 mutex_lock(&codec->spdif_mutex);
3822 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3823 /* already opened as analog dup; reset it once */
3824 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3825 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3826 mutex_unlock(&codec->spdif_mutex);
3829 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3832 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
3834 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3835 struct hda_multi_out *mout,
3836 unsigned int stream_tag,
3837 unsigned int format,
3838 struct snd_pcm_substream *substream)
3840 mutex_lock(&codec->spdif_mutex);
3841 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3842 mutex_unlock(&codec->spdif_mutex);
3845 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3848 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
3850 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3851 struct hda_multi_out *mout)
3853 mutex_lock(&codec->spdif_mutex);
3854 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3855 mutex_unlock(&codec->spdif_mutex);
3858 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3861 * snd_hda_multi_out_dig_close - release the digital out stream
3863 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3864 struct hda_multi_out *mout)
3866 mutex_lock(&codec->spdif_mutex);
3867 mout->dig_out_used = 0;
3868 mutex_unlock(&codec->spdif_mutex);
3871 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3874 * snd_hda_multi_out_analog_open - open analog outputs
3876 * Open analog outputs and set up the hw-constraints.
3877 * If the digital outputs can be opened as slave, open the digital
3880 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3881 struct hda_multi_out *mout,
3882 struct snd_pcm_substream *substream,
3883 struct hda_pcm_stream *hinfo)
3885 struct snd_pcm_runtime *runtime = substream->runtime;
3886 runtime->hw.channels_max = mout->max_channels;
3887 if (mout->dig_out_nid) {
3888 if (!mout->analog_rates) {
3889 mout->analog_rates = hinfo->rates;
3890 mout->analog_formats = hinfo->formats;
3891 mout->analog_maxbps = hinfo->maxbps;
3893 runtime->hw.rates = mout->analog_rates;
3894 runtime->hw.formats = mout->analog_formats;
3895 hinfo->maxbps = mout->analog_maxbps;
3897 if (!mout->spdif_rates) {
3898 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3900 &mout->spdif_formats,
3901 &mout->spdif_maxbps);
3903 mutex_lock(&codec->spdif_mutex);
3904 if (mout->share_spdif) {
3905 if ((runtime->hw.rates & mout->spdif_rates) &&
3906 (runtime->hw.formats & mout->spdif_formats)) {
3907 runtime->hw.rates &= mout->spdif_rates;
3908 runtime->hw.formats &= mout->spdif_formats;
3909 if (mout->spdif_maxbps < hinfo->maxbps)
3910 hinfo->maxbps = mout->spdif_maxbps;
3912 mout->share_spdif = 0;
3913 /* FIXME: need notify? */
3916 mutex_unlock(&codec->spdif_mutex);
3918 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3919 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3921 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3924 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
3926 * Set up the i/o for analog out.
3927 * When the digital out is available, copy the front out to digital out, too.
3929 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3930 struct hda_multi_out *mout,
3931 unsigned int stream_tag,
3932 unsigned int format,
3933 struct snd_pcm_substream *substream)
3935 hda_nid_t *nids = mout->dac_nids;
3936 int chs = substream->runtime->channels;
3939 mutex_lock(&codec->spdif_mutex);
3940 if (mout->dig_out_nid && mout->share_spdif &&
3941 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3943 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3945 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3946 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3947 setup_dig_out_stream(codec, mout->dig_out_nid,
3948 stream_tag, format);
3950 mout->dig_out_used = 0;
3951 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3954 mutex_unlock(&codec->spdif_mutex);
3957 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3959 if (!mout->no_share_stream &&
3960 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3961 /* headphone out will just decode front left/right (stereo) */
3962 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3964 /* extra outputs copied from front */
3965 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3966 if (!mout->no_share_stream && mout->extra_out_nid[i])
3967 snd_hda_codec_setup_stream(codec,
3968 mout->extra_out_nid[i],
3969 stream_tag, 0, format);
3972 for (i = 1; i < mout->num_dacs; i++) {
3973 if (chs >= (i + 1) * 2) /* independent out */
3974 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3976 else if (!mout->no_share_stream) /* copy front */
3977 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3982 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3985 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
3987 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3988 struct hda_multi_out *mout)
3990 hda_nid_t *nids = mout->dac_nids;
3993 for (i = 0; i < mout->num_dacs; i++)
3994 snd_hda_codec_cleanup_stream(codec, nids[i]);
3996 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3997 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3998 if (mout->extra_out_nid[i])
3999 snd_hda_codec_cleanup_stream(codec,
4000 mout->extra_out_nid[i]);
4001 mutex_lock(&codec->spdif_mutex);
4002 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4003 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4004 mout->dig_out_used = 0;
4006 mutex_unlock(&codec->spdif_mutex);
4009 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4012 * Helper for automatic pin configuration
4015 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
4017 for (; *list; list++)
4025 * Sort an associated group of pins according to their sequence numbers.
4027 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
4034 for (i = 0; i < num_pins; i++) {
4035 for (j = i + 1; j < num_pins; j++) {
4036 if (sequences[i] > sequences[j]) {
4038 sequences[i] = sequences[j];
4050 * Parse all pin widgets and store the useful pin nids to cfg
4052 * The number of line-outs or any primary output is stored in line_outs,
4053 * and the corresponding output pins are assigned to line_out_pins[],
4054 * in the order of front, rear, CLFE, side, ...
4056 * If more extra outputs (speaker and headphone) are found, the pins are
4057 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
4058 * is detected, one of speaker of HP pins is assigned as the primary
4059 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4060 * if any analog output exists.
4062 * The analog input pins are assigned to input_pins array.
4063 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4066 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
4067 struct auto_pin_cfg *cfg,
4068 hda_nid_t *ignore_nids)
4070 hda_nid_t nid, end_nid;
4071 short seq, assoc_line_out, assoc_speaker;
4072 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4073 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
4074 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
4076 memset(cfg, 0, sizeof(*cfg));
4078 memset(sequences_line_out, 0, sizeof(sequences_line_out));
4079 memset(sequences_speaker, 0, sizeof(sequences_speaker));
4080 memset(sequences_hp, 0, sizeof(sequences_hp));
4081 assoc_line_out = assoc_speaker = 0;
4083 end_nid = codec->start_nid + codec->num_nodes;
4084 for (nid = codec->start_nid; nid < end_nid; nid++) {
4085 unsigned int wid_caps = get_wcaps(codec, nid);
4086 unsigned int wid_type = get_wcaps_type(wid_caps);
4087 unsigned int def_conf;
4090 /* read all default configuration for pin complex */
4091 if (wid_type != AC_WID_PIN)
4093 /* ignore the given nids (e.g. pc-beep returns error) */
4094 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4097 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4098 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
4100 loc = get_defcfg_location(def_conf);
4101 switch (get_defcfg_device(def_conf)) {
4102 case AC_JACK_LINE_OUT:
4103 seq = get_defcfg_sequence(def_conf);
4104 assoc = get_defcfg_association(def_conf);
4106 if (!(wid_caps & AC_WCAP_STEREO))
4107 if (!cfg->mono_out_pin)
4108 cfg->mono_out_pin = nid;
4111 if (!assoc_line_out)
4112 assoc_line_out = assoc;
4113 else if (assoc_line_out != assoc)
4115 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4117 cfg->line_out_pins[cfg->line_outs] = nid;
4118 sequences_line_out[cfg->line_outs] = seq;
4121 case AC_JACK_SPEAKER:
4122 seq = get_defcfg_sequence(def_conf);
4123 assoc = get_defcfg_association(def_conf);
4126 if (! assoc_speaker)
4127 assoc_speaker = assoc;
4128 else if (assoc_speaker != assoc)
4130 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4132 cfg->speaker_pins[cfg->speaker_outs] = nid;
4133 sequences_speaker[cfg->speaker_outs] = seq;
4134 cfg->speaker_outs++;
4136 case AC_JACK_HP_OUT:
4137 seq = get_defcfg_sequence(def_conf);
4138 assoc = get_defcfg_association(def_conf);
4139 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4141 cfg->hp_pins[cfg->hp_outs] = nid;
4142 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
4145 case AC_JACK_MIC_IN: {
4147 if (loc == AC_JACK_LOC_FRONT) {
4148 preferred = AUTO_PIN_FRONT_MIC;
4151 preferred = AUTO_PIN_MIC;
4152 alt = AUTO_PIN_FRONT_MIC;
4154 if (!cfg->input_pins[preferred])
4155 cfg->input_pins[preferred] = nid;
4156 else if (!cfg->input_pins[alt])
4157 cfg->input_pins[alt] = nid;
4160 case AC_JACK_LINE_IN:
4161 if (loc == AC_JACK_LOC_FRONT)
4162 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
4164 cfg->input_pins[AUTO_PIN_LINE] = nid;
4167 cfg->input_pins[AUTO_PIN_CD] = nid;
4170 cfg->input_pins[AUTO_PIN_AUX] = nid;
4172 case AC_JACK_SPDIF_OUT:
4173 case AC_JACK_DIG_OTHER_OUT:
4174 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
4176 cfg->dig_out_pins[cfg->dig_outs] = nid;
4177 cfg->dig_out_type[cfg->dig_outs] =
4178 (loc == AC_JACK_LOC_HDMI) ?
4179 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
4182 case AC_JACK_SPDIF_IN:
4183 case AC_JACK_DIG_OTHER_IN:
4184 cfg->dig_in_pin = nid;
4185 if (loc == AC_JACK_LOC_HDMI)
4186 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
4188 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
4194 * If no line-out is defined but multiple HPs are found,
4195 * some of them might be the real line-outs.
4197 if (!cfg->line_outs && cfg->hp_outs > 1) {
4199 while (i < cfg->hp_outs) {
4200 /* The real HPs should have the sequence 0x0f */
4201 if ((sequences_hp[i] & 0x0f) == 0x0f) {
4205 /* Move it to the line-out table */
4206 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
4207 sequences_line_out[cfg->line_outs] = sequences_hp[i];
4210 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
4211 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
4212 memmove(sequences_hp + i - 1, sequences_hp + i,
4213 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
4217 /* sort by sequence */
4218 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
4220 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
4222 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
4225 /* if we have only one mic, make it AUTO_PIN_MIC */
4226 if (!cfg->input_pins[AUTO_PIN_MIC] &&
4227 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
4228 cfg->input_pins[AUTO_PIN_MIC] =
4229 cfg->input_pins[AUTO_PIN_FRONT_MIC];
4230 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
4232 /* ditto for line-in */
4233 if (!cfg->input_pins[AUTO_PIN_LINE] &&
4234 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
4235 cfg->input_pins[AUTO_PIN_LINE] =
4236 cfg->input_pins[AUTO_PIN_FRONT_LINE];
4237 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
4241 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4242 * as a primary output
4244 if (!cfg->line_outs) {
4245 if (cfg->speaker_outs) {
4246 cfg->line_outs = cfg->speaker_outs;
4247 memcpy(cfg->line_out_pins, cfg->speaker_pins,
4248 sizeof(cfg->speaker_pins));
4249 cfg->speaker_outs = 0;
4250 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
4251 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
4252 } else if (cfg->hp_outs) {
4253 cfg->line_outs = cfg->hp_outs;
4254 memcpy(cfg->line_out_pins, cfg->hp_pins,
4255 sizeof(cfg->hp_pins));
4257 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4258 cfg->line_out_type = AUTO_PIN_HP_OUT;
4262 /* Reorder the surround channels
4263 * ALSA sequence is front/surr/clfe/side
4265 * 4-ch: front/surr => OK as it is
4266 * 6-ch: front/clfe/surr
4267 * 8-ch: front/clfe/rear/side|fc
4269 switch (cfg->line_outs) {
4272 nid = cfg->line_out_pins[1];
4273 cfg->line_out_pins[1] = cfg->line_out_pins[2];
4274 cfg->line_out_pins[2] = nid;
4279 * debug prints of the parsed results
4281 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4282 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
4283 cfg->line_out_pins[2], cfg->line_out_pins[3],
4284 cfg->line_out_pins[4]);
4285 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4286 cfg->speaker_outs, cfg->speaker_pins[0],
4287 cfg->speaker_pins[1], cfg->speaker_pins[2],
4288 cfg->speaker_pins[3], cfg->speaker_pins[4]);
4289 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4290 cfg->hp_outs, cfg->hp_pins[0],
4291 cfg->hp_pins[1], cfg->hp_pins[2],
4292 cfg->hp_pins[3], cfg->hp_pins[4]);
4293 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
4295 snd_printd(" dig-out=0x%x/0x%x\n",
4296 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
4297 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
4298 " cd=0x%x, aux=0x%x\n",
4299 cfg->input_pins[AUTO_PIN_MIC],
4300 cfg->input_pins[AUTO_PIN_FRONT_MIC],
4301 cfg->input_pins[AUTO_PIN_LINE],
4302 cfg->input_pins[AUTO_PIN_FRONT_LINE],
4303 cfg->input_pins[AUTO_PIN_CD],
4304 cfg->input_pins[AUTO_PIN_AUX]);
4305 if (cfg->dig_in_pin)
4306 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
4310 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
4312 /* labels for input pins */
4313 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
4314 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
4316 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
4325 * snd_hda_suspend - suspend the codecs
4328 * Returns 0 if successful.
4330 int snd_hda_suspend(struct hda_bus *bus)
4332 struct hda_codec *codec;
4334 list_for_each_entry(codec, &bus->codec_list, list) {
4335 #ifdef CONFIG_SND_HDA_POWER_SAVE
4336 if (!codec->power_on)
4339 hda_call_codec_suspend(codec);
4343 EXPORT_SYMBOL_HDA(snd_hda_suspend);
4346 * snd_hda_resume - resume the codecs
4349 * Returns 0 if successful.
4351 * This fucntion is defined only when POWER_SAVE isn't set.
4352 * In the power-save mode, the codec is resumed dynamically.
4354 int snd_hda_resume(struct hda_bus *bus)
4356 struct hda_codec *codec;
4358 list_for_each_entry(codec, &bus->codec_list, list) {
4359 if (snd_hda_codec_needs_resume(codec))
4360 hda_call_codec_resume(codec);
4364 EXPORT_SYMBOL_HDA(snd_hda_resume);
4365 #endif /* CONFIG_PM */
4372 * snd_array_new - get a new element from the given array
4373 * @array: the array object
4375 * Get a new element from the given array. If it exceeds the
4376 * pre-allocated array size, re-allocate the array.
4378 * Returns NULL if allocation failed.
4380 void *snd_array_new(struct snd_array *array)
4382 if (array->used >= array->alloced) {
4383 int num = array->alloced + array->alloc_align;
4385 if (snd_BUG_ON(num >= 4096))
4387 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
4391 memcpy(nlist, array->list,
4392 array->elem_size * array->alloced);
4395 array->list = nlist;
4396 array->alloced = num;
4398 return snd_array_elem(array, array->used++);
4400 EXPORT_SYMBOL_HDA(snd_array_new);
4403 * snd_array_free - free the given array elements
4404 * @array: the array object
4406 void snd_array_free(struct snd_array *array)
4413 EXPORT_SYMBOL_HDA(snd_array_free);
4416 * snd_print_pcm_rates - Print the supported PCM rates to the string buffer
4417 * @pcm: PCM caps bits
4418 * @buf: the string buffer to write
4419 * @buflen: the max buffer length
4421 * used by hda_proc.c and hda_eld.c
4423 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
4425 static unsigned int rates[] = {
4426 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
4427 96000, 176400, 192000, 384000
4431 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
4433 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
4435 buf[j] = '\0'; /* necessary when j == 0 */
4437 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
4440 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4441 * @pcm: PCM caps bits
4442 * @buf: the string buffer to write
4443 * @buflen: the max buffer length
4445 * used by hda_proc.c and hda_eld.c
4447 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4449 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
4452 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4453 if (pcm & (AC_SUPPCM_BITS_8 << i))
4454 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
4456 buf[j] = '\0'; /* necessary when j == 0 */
4458 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
4460 MODULE_DESCRIPTION("HDA codec core");
4461 MODULE_LICENSE("GPL");