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 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
830 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
831 pin = look_up_pincfg(codec, list, nid);
833 pin = snd_array_new(list);
840 /* change only when needed; e.g. if the pincfg is already present
841 * in user_pins[], don't write it
843 cfg = snd_hda_codec_get_pincfg(codec, nid);
845 set_pincfg(codec, nid, cfg);
850 * snd_hda_codec_set_pincfg - Override a pin default configuration
851 * @codec: the HDA codec
852 * @nid: NID to set the pin config
853 * @cfg: the pin default config value
855 * Override a pin default configuration value in the cache.
856 * This value can be read by snd_hda_codec_get_pincfg() in a higher
857 * priority than the real hardware value.
859 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
860 hda_nid_t nid, unsigned int cfg)
862 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
864 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
867 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
868 * @codec: the HDA codec
869 * @nid: NID to get the pin config
871 * Get the current pin config value of the given pin NID.
872 * If the pincfg value is cached or overridden via sysfs or driver,
873 * returns the cached value.
875 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
877 struct hda_pincfg *pin;
879 #ifdef CONFIG_SND_HDA_HWDEP
880 pin = look_up_pincfg(codec, &codec->user_pins, nid);
884 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
887 pin = look_up_pincfg(codec, &codec->init_pins, nid);
892 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
894 /* restore all current pin configs */
895 static void restore_pincfgs(struct hda_codec *codec)
898 for (i = 0; i < codec->init_pins.used; i++) {
899 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
900 set_pincfg(codec, pin->nid,
901 snd_hda_codec_get_pincfg(codec, pin->nid));
906 * snd_hda_shutup_pins - Shut up all pins
907 * @codec: the HDA codec
909 * Clear all pin controls to shup up before suspend for avoiding click noise.
910 * The controls aren't cached so that they can be resumed properly.
912 void snd_hda_shutup_pins(struct hda_codec *codec)
915 for (i = 0; i < codec->init_pins.used; i++) {
916 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
917 /* use read here for syncing after issuing each verb */
918 snd_hda_codec_read(codec, pin->nid, 0,
919 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
922 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
924 static void init_hda_cache(struct hda_cache_rec *cache,
925 unsigned int record_size);
926 static void free_hda_cache(struct hda_cache_rec *cache);
928 /* restore the initial pin cfgs and release all pincfg lists */
929 static void restore_init_pincfgs(struct hda_codec *codec)
931 /* first free driver_pins and user_pins, then call restore_pincfg
932 * so that only the values in init_pins are restored
934 snd_array_free(&codec->driver_pins);
935 #ifdef CONFIG_SND_HDA_HWDEP
936 snd_array_free(&codec->user_pins);
938 restore_pincfgs(codec);
939 snd_array_free(&codec->init_pins);
945 static void snd_hda_codec_free(struct hda_codec *codec)
949 restore_init_pincfgs(codec);
950 #ifdef CONFIG_SND_HDA_POWER_SAVE
951 cancel_delayed_work(&codec->power_work);
952 flush_workqueue(codec->bus->workq);
954 list_del(&codec->list);
955 snd_array_free(&codec->mixers);
956 snd_array_free(&codec->nids);
957 codec->bus->caddr_tbl[codec->addr] = NULL;
958 if (codec->patch_ops.free)
959 codec->patch_ops.free(codec);
960 module_put(codec->owner);
961 free_hda_cache(&codec->amp_cache);
962 free_hda_cache(&codec->cmd_cache);
963 kfree(codec->vendor_name);
964 kfree(codec->chip_name);
965 kfree(codec->modelname);
970 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
971 unsigned int power_state);
974 * snd_hda_codec_new - create a HDA codec
975 * @bus: the bus to assign
976 * @codec_addr: the codec address
977 * @codecp: the pointer to store the generated codec
979 * Returns 0 if successful, or a negative error code.
981 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
982 struct hda_codec **codecp)
984 struct hda_codec *codec;
988 if (snd_BUG_ON(!bus))
990 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
993 if (bus->caddr_tbl[codec_addr]) {
994 snd_printk(KERN_ERR "hda_codec: "
995 "address 0x%x is already occupied\n", codec_addr);
999 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1000 if (codec == NULL) {
1001 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1006 codec->addr = codec_addr;
1007 mutex_init(&codec->spdif_mutex);
1008 mutex_init(&codec->control_mutex);
1009 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1010 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1011 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1012 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1013 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1014 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1015 if (codec->bus->modelname) {
1016 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1017 if (!codec->modelname) {
1018 snd_hda_codec_free(codec);
1023 #ifdef CONFIG_SND_HDA_POWER_SAVE
1024 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1025 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1026 * the caller has to power down appropriatley after initialization
1029 hda_keep_power_on(codec);
1032 list_add_tail(&codec->list, &bus->codec_list);
1033 bus->caddr_tbl[codec_addr] = codec;
1035 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1037 if (codec->vendor_id == -1)
1038 /* read again, hopefully the access method was corrected
1039 * in the last read...
1041 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1043 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1044 AC_PAR_SUBSYSTEM_ID);
1045 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1048 setup_fg_nodes(codec);
1049 if (!codec->afg && !codec->mfg) {
1050 snd_printdd("hda_codec: no AFG or MFG node found\n");
1055 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1057 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1060 err = read_pin_defaults(codec);
1064 if (!codec->subsystem_id) {
1065 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
1066 codec->subsystem_id =
1067 snd_hda_codec_read(codec, nid, 0,
1068 AC_VERB_GET_SUBSYSTEM_ID, 0);
1071 /* power-up all before initialization */
1072 hda_set_power_state(codec,
1073 codec->afg ? codec->afg : codec->mfg,
1076 snd_hda_codec_proc_new(codec);
1078 snd_hda_create_hwdep(codec);
1080 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1081 codec->subsystem_id, codec->revision_id);
1082 snd_component_add(codec->bus->card, component);
1089 snd_hda_codec_free(codec);
1092 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1095 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1096 * @codec: the HDA codec
1098 * Start parsing of the given codec tree and (re-)initialize the whole
1101 * Returns 0 if successful or a negative error code.
1103 int snd_hda_codec_configure(struct hda_codec *codec)
1107 codec->preset = find_codec_preset(codec);
1108 if (!codec->vendor_name || !codec->chip_name) {
1109 err = get_codec_name(codec);
1114 if (is_generic_config(codec)) {
1115 err = snd_hda_parse_generic_codec(codec);
1118 if (codec->preset && codec->preset->patch) {
1119 err = codec->preset->patch(codec);
1123 /* call the default parser */
1124 err = snd_hda_parse_generic_codec(codec);
1126 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1129 if (!err && codec->patch_ops.unsol_event)
1130 err = init_unsol_queue(codec->bus);
1131 /* audio codec should override the mixer name */
1132 if (!err && (codec->afg || !*codec->bus->card->mixername))
1133 snprintf(codec->bus->card->mixername,
1134 sizeof(codec->bus->card->mixername),
1135 "%s %s", codec->vendor_name, codec->chip_name);
1138 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1141 * snd_hda_codec_setup_stream - set up the codec for streaming
1142 * @codec: the CODEC to set up
1143 * @nid: the NID to set up
1144 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1145 * @channel_id: channel id to pass, zero based.
1146 * @format: stream format.
1148 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1150 int channel_id, int format)
1155 snd_printdd("hda_codec_setup_stream: "
1156 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1157 nid, stream_tag, channel_id, format);
1158 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1159 (stream_tag << 4) | channel_id);
1161 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1163 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1166 * snd_hda_codec_cleanup_stream - clean up the codec for closing
1167 * @codec: the CODEC to clean up
1168 * @nid: the NID to clean up
1170 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1175 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1176 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1177 #if 0 /* keep the format */
1179 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1182 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
1185 * amp access functions
1188 /* FIXME: more better hash key? */
1189 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1190 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1191 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1192 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1193 #define INFO_AMP_CAPS (1<<0)
1194 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1196 /* initialize the hash table */
1197 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1198 unsigned int record_size)
1200 memset(cache, 0, sizeof(*cache));
1201 memset(cache->hash, 0xff, sizeof(cache->hash));
1202 snd_array_init(&cache->buf, record_size, 64);
1205 static void free_hda_cache(struct hda_cache_rec *cache)
1207 snd_array_free(&cache->buf);
1210 /* query the hash. allocate an entry if not found. */
1211 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1214 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1215 u16 cur = cache->hash[idx];
1216 struct hda_cache_head *info;
1218 while (cur != 0xffff) {
1219 info = snd_array_elem(&cache->buf, cur);
1220 if (info->key == key)
1225 /* add a new hash entry */
1226 info = snd_array_new(&cache->buf);
1229 cur = snd_array_index(&cache->buf, info);
1232 info->next = cache->hash[idx];
1233 cache->hash[idx] = cur;
1238 /* query and allocate an amp hash entry */
1239 static inline struct hda_amp_info *
1240 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1242 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1246 * query_amp_caps - query AMP capabilities
1247 * @codec: the HD-auio codec
1248 * @nid: the NID to query
1249 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1251 * Query AMP capabilities for the given widget and direction.
1252 * Returns the obtained capability bits.
1254 * When cap bits have been already read, this doesn't read again but
1255 * returns the cached value.
1257 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1259 struct hda_amp_info *info;
1261 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1264 if (!(info->head.val & INFO_AMP_CAPS)) {
1265 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1267 info->amp_caps = snd_hda_param_read(codec, nid,
1268 direction == HDA_OUTPUT ?
1269 AC_PAR_AMP_OUT_CAP :
1272 info->head.val |= INFO_AMP_CAPS;
1274 return info->amp_caps;
1276 EXPORT_SYMBOL_HDA(query_amp_caps);
1279 * snd_hda_override_amp_caps - Override the AMP capabilities
1280 * @codec: the CODEC to clean up
1281 * @nid: the NID to clean up
1282 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1283 * @caps: the capability bits to set
1285 * Override the cached AMP caps bits value by the given one.
1286 * This function is useful if the driver needs to adjust the AMP ranges,
1287 * e.g. limit to 0dB, etc.
1289 * Returns zero if successful or a negative error code.
1291 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1294 struct hda_amp_info *info;
1296 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1299 info->amp_caps = caps;
1300 info->head.val |= INFO_AMP_CAPS;
1303 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1306 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1307 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1309 struct hda_amp_info *info;
1311 info = get_alloc_amp_hash(codec, key);
1314 if (!info->head.val) {
1315 info->head.val |= INFO_AMP_CAPS;
1316 info->amp_caps = func(codec, nid);
1318 return info->amp_caps;
1321 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1323 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1327 * snd_hda_query_pin_caps - Query PIN capabilities
1328 * @codec: the HD-auio codec
1329 * @nid: the NID to query
1331 * Query PIN capabilities for the given widget.
1332 * Returns the obtained capability bits.
1334 * When cap bits have been already read, this doesn't read again but
1335 * returns the cached value.
1337 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1339 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1342 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1345 * snd_hda_pin_sense - execute pin sense measurement
1346 * @codec: the CODEC to sense
1347 * @nid: the pin NID to sense
1349 * Execute necessary pin sense measurement and return its Presence Detect,
1350 * Impedance, ELD Valid etc. status bits.
1352 u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
1356 if (!codec->no_trigger_sense) {
1357 pincap = snd_hda_query_pin_caps(codec, nid);
1358 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
1359 snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0);
1361 return snd_hda_codec_read(codec, nid, 0,
1362 AC_VERB_GET_PIN_SENSE, 0);
1364 EXPORT_SYMBOL_HDA(snd_hda_pin_sense);
1367 * snd_hda_jack_detect - query pin Presence Detect status
1368 * @codec: the CODEC to sense
1369 * @nid: the pin NID to sense
1371 * Query and return the pin's Presence Detect status.
1373 int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
1375 u32 sense = snd_hda_pin_sense(codec, nid);
1376 return !!(sense & AC_PINSENSE_PRESENCE);
1378 EXPORT_SYMBOL_HDA(snd_hda_jack_detect);
1381 * read the current volume to info
1382 * if the cache exists, read the cache value.
1384 static unsigned int get_vol_mute(struct hda_codec *codec,
1385 struct hda_amp_info *info, hda_nid_t nid,
1386 int ch, int direction, int index)
1390 if (info->head.val & INFO_AMP_VOL(ch))
1391 return info->vol[ch];
1393 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1394 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1396 val = snd_hda_codec_read(codec, nid, 0,
1397 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1398 info->vol[ch] = val & 0xff;
1399 info->head.val |= INFO_AMP_VOL(ch);
1400 return info->vol[ch];
1404 * write the current volume in info to the h/w and update the cache
1406 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1407 hda_nid_t nid, int ch, int direction, int index,
1412 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1413 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1414 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1416 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1417 info->vol[ch] = val;
1421 * snd_hda_codec_amp_read - Read AMP value
1422 * @codec: HD-audio codec
1423 * @nid: NID to read the AMP value
1424 * @ch: channel (left=0 or right=1)
1425 * @direction: #HDA_INPUT or #HDA_OUTPUT
1426 * @index: the index value (only for input direction)
1428 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1430 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1431 int direction, int index)
1433 struct hda_amp_info *info;
1434 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1437 return get_vol_mute(codec, info, nid, ch, direction, index);
1439 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1442 * snd_hda_codec_amp_update - update the AMP value
1443 * @codec: HD-audio codec
1444 * @nid: NID to read the AMP value
1445 * @ch: channel (left=0 or right=1)
1446 * @direction: #HDA_INPUT or #HDA_OUTPUT
1447 * @idx: the index value (only for input direction)
1448 * @mask: bit mask to set
1449 * @val: the bits value to set
1451 * Update the AMP value with a bit mask.
1452 * Returns 0 if the value is unchanged, 1 if changed.
1454 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1455 int direction, int idx, int mask, int val)
1457 struct hda_amp_info *info;
1459 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1463 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1464 if (info->vol[ch] == val)
1466 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1469 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1472 * snd_hda_codec_amp_stereo - update the AMP stereo values
1473 * @codec: HD-audio codec
1474 * @nid: NID to read the AMP value
1475 * @direction: #HDA_INPUT or #HDA_OUTPUT
1476 * @idx: the index value (only for input direction)
1477 * @mask: bit mask to set
1478 * @val: the bits value to set
1480 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1481 * stereo widget with the same mask and value.
1483 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1484 int direction, int idx, int mask, int val)
1487 for (ch = 0; ch < 2; ch++)
1488 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1492 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1494 #ifdef SND_HDA_NEEDS_RESUME
1496 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1497 * @codec: HD-audio codec
1499 * Resume the all amp commands from the cache.
1501 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1503 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1506 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1507 u32 key = buffer->head.key;
1509 unsigned int idx, dir, ch;
1513 idx = (key >> 16) & 0xff;
1514 dir = (key >> 24) & 0xff;
1515 for (ch = 0; ch < 2; ch++) {
1516 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1518 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1523 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1524 #endif /* SND_HDA_NEEDS_RESUME */
1527 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1529 * The control element is supposed to have the private_value field
1530 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1532 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1533 struct snd_ctl_elem_info *uinfo)
1535 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1536 u16 nid = get_amp_nid(kcontrol);
1537 u8 chs = get_amp_channels(kcontrol);
1538 int dir = get_amp_direction(kcontrol);
1539 unsigned int ofs = get_amp_offset(kcontrol);
1542 caps = query_amp_caps(codec, nid, dir);
1544 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1546 printk(KERN_WARNING "hda_codec: "
1547 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1553 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1554 uinfo->count = chs == 3 ? 2 : 1;
1555 uinfo->value.integer.min = 0;
1556 uinfo->value.integer.max = caps;
1559 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1562 static inline unsigned int
1563 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1564 int ch, int dir, int idx, unsigned int ofs)
1567 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1568 val &= HDA_AMP_VOLMASK;
1577 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1578 int ch, int dir, int idx, unsigned int ofs,
1583 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1584 HDA_AMP_VOLMASK, val);
1588 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1590 * The control element is supposed to have the private_value field
1591 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1593 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1594 struct snd_ctl_elem_value *ucontrol)
1596 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1597 hda_nid_t nid = get_amp_nid(kcontrol);
1598 int chs = get_amp_channels(kcontrol);
1599 int dir = get_amp_direction(kcontrol);
1600 int idx = get_amp_index(kcontrol);
1601 unsigned int ofs = get_amp_offset(kcontrol);
1602 long *valp = ucontrol->value.integer.value;
1605 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1607 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1610 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1613 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1615 * The control element is supposed to have the private_value field
1616 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1618 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1619 struct snd_ctl_elem_value *ucontrol)
1621 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1622 hda_nid_t nid = get_amp_nid(kcontrol);
1623 int chs = get_amp_channels(kcontrol);
1624 int dir = get_amp_direction(kcontrol);
1625 int idx = get_amp_index(kcontrol);
1626 unsigned int ofs = get_amp_offset(kcontrol);
1627 long *valp = ucontrol->value.integer.value;
1630 snd_hda_power_up(codec);
1632 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1636 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1637 snd_hda_power_down(codec);
1640 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1643 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
1645 * The control element is supposed to have the private_value field
1646 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1648 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1649 unsigned int size, unsigned int __user *_tlv)
1651 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1652 hda_nid_t nid = get_amp_nid(kcontrol);
1653 int dir = get_amp_direction(kcontrol);
1654 unsigned int ofs = get_amp_offset(kcontrol);
1655 u32 caps, val1, val2;
1657 if (size < 4 * sizeof(unsigned int))
1659 caps = query_amp_caps(codec, nid, dir);
1660 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1661 val2 = (val2 + 1) * 25;
1662 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1664 val1 = ((int)val1) * ((int)val2);
1665 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1667 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1669 if (put_user(val1, _tlv + 2))
1671 if (put_user(val2, _tlv + 3))
1675 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1678 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1679 * @codec: HD-audio codec
1680 * @nid: NID of a reference widget
1681 * @dir: #HDA_INPUT or #HDA_OUTPUT
1682 * @tlv: TLV data to be stored, at least 4 elements
1684 * Set (static) TLV data for a virtual master volume using the AMP caps
1685 * obtained from the reference NID.
1686 * The volume range is recalculated as if the max volume is 0dB.
1688 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1694 caps = query_amp_caps(codec, nid, dir);
1695 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1696 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1697 step = (step + 1) * 25;
1698 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1699 tlv[1] = 2 * sizeof(unsigned int);
1700 tlv[2] = -nums * step;
1703 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1705 /* find a mixer control element with the given name */
1706 static struct snd_kcontrol *
1707 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1708 const char *name, int idx)
1710 struct snd_ctl_elem_id id;
1711 memset(&id, 0, sizeof(id));
1712 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1714 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1716 strcpy(id.name, name);
1717 return snd_ctl_find_id(codec->bus->card, &id);
1721 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1722 * @codec: HD-audio codec
1723 * @name: ctl id name string
1725 * Get the control element with the given id string and IFACE_MIXER.
1727 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1730 return _snd_hda_find_mixer_ctl(codec, name, 0);
1732 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1735 * snd_hda_ctl_add - Add a control element and assign to the codec
1736 * @codec: HD-audio codec
1737 * @nid: corresponding NID (optional)
1738 * @kctl: the control element to assign
1740 * Add the given control element to an array inside the codec instance.
1741 * All control elements belonging to a codec are supposed to be added
1742 * by this function so that a proper clean-up works at the free or
1743 * reconfiguration time.
1745 * If non-zero @nid is passed, the NID is assigned to the control element.
1746 * The assignment is shown in the codec proc file.
1748 * snd_hda_ctl_add() checks the control subdev id field whether
1749 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
1750 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
1751 * specifies if kctl->private_value is a HDA amplifier value.
1753 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
1754 struct snd_kcontrol *kctl)
1757 unsigned short flags = 0;
1758 struct hda_nid_item *item;
1760 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
1761 flags |= HDA_NID_ITEM_AMP;
1763 nid = get_amp_nid_(kctl->private_value);
1765 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
1766 nid = kctl->id.subdevice & 0xffff;
1767 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
1768 kctl->id.subdevice = 0;
1769 err = snd_ctl_add(codec->bus->card, kctl);
1772 item = snd_array_new(&codec->mixers);
1777 item->flags = flags;
1780 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1783 * snd_hda_add_nid - Assign a NID to a control element
1784 * @codec: HD-audio codec
1785 * @nid: corresponding NID (optional)
1786 * @kctl: the control element to assign
1787 * @index: index to kctl
1789 * Add the given control element to an array inside the codec instance.
1790 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
1791 * NID:KCTL mapping - for example "Capture Source" selector.
1793 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
1794 unsigned int index, hda_nid_t nid)
1796 struct hda_nid_item *item;
1799 item = snd_array_new(&codec->nids);
1803 item->index = index;
1809 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
1812 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
1813 * @codec: HD-audio codec
1815 void snd_hda_ctls_clear(struct hda_codec *codec)
1818 struct hda_nid_item *items = codec->mixers.list;
1819 for (i = 0; i < codec->mixers.used; i++)
1820 snd_ctl_remove(codec->bus->card, items[i].kctl);
1821 snd_array_free(&codec->mixers);
1822 snd_array_free(&codec->nids);
1825 /* pseudo device locking
1826 * toggle card->shutdown to allow/disallow the device access (as a hack)
1828 static int hda_lock_devices(struct snd_card *card)
1830 spin_lock(&card->files_lock);
1831 if (card->shutdown) {
1832 spin_unlock(&card->files_lock);
1836 spin_unlock(&card->files_lock);
1840 static void hda_unlock_devices(struct snd_card *card)
1842 spin_lock(&card->files_lock);
1844 spin_unlock(&card->files_lock);
1848 * snd_hda_codec_reset - Clear all objects assigned to the codec
1849 * @codec: HD-audio codec
1851 * This frees the all PCM and control elements assigned to the codec, and
1852 * clears the caches and restores the pin default configurations.
1854 * When a device is being used, it returns -EBSY. If successfully freed,
1857 int snd_hda_codec_reset(struct hda_codec *codec)
1859 struct snd_card *card = codec->bus->card;
1862 if (hda_lock_devices(card) < 0)
1864 /* check whether the codec isn't used by any mixer or PCM streams */
1865 if (!list_empty(&card->ctl_files)) {
1866 hda_unlock_devices(card);
1869 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1870 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1873 if (cpcm->pcm->streams[0].substream_opened ||
1874 cpcm->pcm->streams[1].substream_opened) {
1875 hda_unlock_devices(card);
1880 /* OK, let it free */
1882 #ifdef CONFIG_SND_HDA_POWER_SAVE
1883 cancel_delayed_work(&codec->power_work);
1884 flush_workqueue(codec->bus->workq);
1886 snd_hda_ctls_clear(codec);
1888 for (i = 0; i < codec->num_pcms; i++) {
1889 if (codec->pcm_info[i].pcm) {
1890 snd_device_free(card, codec->pcm_info[i].pcm);
1891 clear_bit(codec->pcm_info[i].device,
1892 codec->bus->pcm_dev_bits);
1895 if (codec->patch_ops.free)
1896 codec->patch_ops.free(codec);
1897 codec->proc_widget_hook = NULL;
1899 free_hda_cache(&codec->amp_cache);
1900 free_hda_cache(&codec->cmd_cache);
1901 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1902 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1903 /* free only driver_pins so that init_pins + user_pins are restored */
1904 snd_array_free(&codec->driver_pins);
1905 restore_pincfgs(codec);
1906 codec->num_pcms = 0;
1907 codec->pcm_info = NULL;
1908 codec->preset = NULL;
1909 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1910 codec->slave_dig_outs = NULL;
1911 codec->spdif_status_reset = 0;
1912 module_put(codec->owner);
1913 codec->owner = NULL;
1915 /* allow device access again */
1916 hda_unlock_devices(card);
1921 * snd_hda_add_vmaster - create a virtual master control and add slaves
1922 * @codec: HD-audio codec
1923 * @name: vmaster control name
1924 * @tlv: TLV data (optional)
1925 * @slaves: slave control names (optional)
1927 * Create a virtual master control with the given name. The TLV data
1928 * must be either NULL or a valid data.
1930 * @slaves is a NULL-terminated array of strings, each of which is a
1931 * slave control name. All controls with these names are assigned to
1932 * the new virtual master control.
1934 * This function returns zero if successful or a negative error code.
1936 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1937 unsigned int *tlv, const char **slaves)
1939 struct snd_kcontrol *kctl;
1943 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1946 snd_printdd("No slave found for %s\n", name);
1949 kctl = snd_ctl_make_virtual_master(name, tlv);
1952 err = snd_hda_ctl_add(codec, 0, kctl);
1956 for (s = slaves; *s; s++) {
1957 struct snd_kcontrol *sctl;
1960 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1963 snd_printdd("Cannot find slave %s, "
1967 err = snd_ctl_add_slave(kctl, sctl);
1975 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1978 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
1980 * The control element is supposed to have the private_value field
1981 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1983 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1984 struct snd_ctl_elem_info *uinfo)
1986 int chs = get_amp_channels(kcontrol);
1988 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1989 uinfo->count = chs == 3 ? 2 : 1;
1990 uinfo->value.integer.min = 0;
1991 uinfo->value.integer.max = 1;
1994 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1997 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
1999 * The control element is supposed to have the private_value field
2000 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2002 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2003 struct snd_ctl_elem_value *ucontrol)
2005 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2006 hda_nid_t nid = get_amp_nid(kcontrol);
2007 int chs = get_amp_channels(kcontrol);
2008 int dir = get_amp_direction(kcontrol);
2009 int idx = get_amp_index(kcontrol);
2010 long *valp = ucontrol->value.integer.value;
2013 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2014 HDA_AMP_MUTE) ? 0 : 1;
2016 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2017 HDA_AMP_MUTE) ? 0 : 1;
2020 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2023 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2025 * The control element is supposed to have the private_value field
2026 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2028 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2029 struct snd_ctl_elem_value *ucontrol)
2031 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2032 hda_nid_t nid = get_amp_nid(kcontrol);
2033 int chs = get_amp_channels(kcontrol);
2034 int dir = get_amp_direction(kcontrol);
2035 int idx = get_amp_index(kcontrol);
2036 long *valp = ucontrol->value.integer.value;
2039 snd_hda_power_up(codec);
2041 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2043 *valp ? 0 : HDA_AMP_MUTE);
2047 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2049 *valp ? 0 : HDA_AMP_MUTE);
2050 #ifdef CONFIG_SND_HDA_POWER_SAVE
2051 if (codec->patch_ops.check_power_status)
2052 codec->patch_ops.check_power_status(codec, nid);
2054 snd_hda_power_down(codec);
2057 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2059 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2061 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2063 * This function calls snd_hda_enable_beep_device(), which behaves differently
2064 * depending on beep_mode option.
2066 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2067 struct snd_ctl_elem_value *ucontrol)
2069 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2070 long *valp = ucontrol->value.integer.value;
2072 snd_hda_enable_beep_device(codec, *valp);
2073 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2075 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
2076 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2079 * bound volume controls
2081 * bind multiple volumes (# indices, from 0)
2084 #define AMP_VAL_IDX_SHIFT 19
2085 #define AMP_VAL_IDX_MASK (0x0f<<19)
2088 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2090 * The control element is supposed to have the private_value field
2091 * set up via HDA_BIND_MUTE*() macros.
2093 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2094 struct snd_ctl_elem_value *ucontrol)
2096 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2100 mutex_lock(&codec->control_mutex);
2101 pval = kcontrol->private_value;
2102 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2103 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2104 kcontrol->private_value = pval;
2105 mutex_unlock(&codec->control_mutex);
2108 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2111 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2113 * The control element is supposed to have the private_value field
2114 * set up via HDA_BIND_MUTE*() macros.
2116 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2117 struct snd_ctl_elem_value *ucontrol)
2119 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2121 int i, indices, err = 0, change = 0;
2123 mutex_lock(&codec->control_mutex);
2124 pval = kcontrol->private_value;
2125 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2126 for (i = 0; i < indices; i++) {
2127 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2128 (i << AMP_VAL_IDX_SHIFT);
2129 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2134 kcontrol->private_value = pval;
2135 mutex_unlock(&codec->control_mutex);
2136 return err < 0 ? err : change;
2138 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2141 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2143 * The control element is supposed to have the private_value field
2144 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2146 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2147 struct snd_ctl_elem_info *uinfo)
2149 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2150 struct hda_bind_ctls *c;
2153 mutex_lock(&codec->control_mutex);
2154 c = (struct hda_bind_ctls *)kcontrol->private_value;
2155 kcontrol->private_value = *c->values;
2156 err = c->ops->info(kcontrol, uinfo);
2157 kcontrol->private_value = (long)c;
2158 mutex_unlock(&codec->control_mutex);
2161 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2164 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2166 * The control element is supposed to have the private_value field
2167 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2169 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2170 struct snd_ctl_elem_value *ucontrol)
2172 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2173 struct hda_bind_ctls *c;
2176 mutex_lock(&codec->control_mutex);
2177 c = (struct hda_bind_ctls *)kcontrol->private_value;
2178 kcontrol->private_value = *c->values;
2179 err = c->ops->get(kcontrol, ucontrol);
2180 kcontrol->private_value = (long)c;
2181 mutex_unlock(&codec->control_mutex);
2184 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2187 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2189 * The control element is supposed to have the private_value field
2190 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2192 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2193 struct snd_ctl_elem_value *ucontrol)
2195 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2196 struct hda_bind_ctls *c;
2197 unsigned long *vals;
2198 int err = 0, change = 0;
2200 mutex_lock(&codec->control_mutex);
2201 c = (struct hda_bind_ctls *)kcontrol->private_value;
2202 for (vals = c->values; *vals; vals++) {
2203 kcontrol->private_value = *vals;
2204 err = c->ops->put(kcontrol, ucontrol);
2209 kcontrol->private_value = (long)c;
2210 mutex_unlock(&codec->control_mutex);
2211 return err < 0 ? err : change;
2213 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2216 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2218 * The control element is supposed to have the private_value field
2219 * set up via HDA_BIND_VOL() macro.
2221 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2222 unsigned int size, unsigned int __user *tlv)
2224 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2225 struct hda_bind_ctls *c;
2228 mutex_lock(&codec->control_mutex);
2229 c = (struct hda_bind_ctls *)kcontrol->private_value;
2230 kcontrol->private_value = *c->values;
2231 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2232 kcontrol->private_value = (long)c;
2233 mutex_unlock(&codec->control_mutex);
2236 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2238 struct hda_ctl_ops snd_hda_bind_vol = {
2239 .info = snd_hda_mixer_amp_volume_info,
2240 .get = snd_hda_mixer_amp_volume_get,
2241 .put = snd_hda_mixer_amp_volume_put,
2242 .tlv = snd_hda_mixer_amp_tlv
2244 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2246 struct hda_ctl_ops snd_hda_bind_sw = {
2247 .info = snd_hda_mixer_amp_switch_info,
2248 .get = snd_hda_mixer_amp_switch_get,
2249 .put = snd_hda_mixer_amp_switch_put,
2250 .tlv = snd_hda_mixer_amp_tlv
2252 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2255 * SPDIF out controls
2258 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2259 struct snd_ctl_elem_info *uinfo)
2261 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2266 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2267 struct snd_ctl_elem_value *ucontrol)
2269 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2270 IEC958_AES0_NONAUDIO |
2271 IEC958_AES0_CON_EMPHASIS_5015 |
2272 IEC958_AES0_CON_NOT_COPYRIGHT;
2273 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2274 IEC958_AES1_CON_ORIGINAL;
2278 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2279 struct snd_ctl_elem_value *ucontrol)
2281 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2282 IEC958_AES0_NONAUDIO |
2283 IEC958_AES0_PRO_EMPHASIS_5015;
2287 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2288 struct snd_ctl_elem_value *ucontrol)
2290 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2292 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
2293 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
2294 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
2295 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
2300 /* convert from SPDIF status bits to HDA SPDIF bits
2301 * bit 0 (DigEn) is always set zero (to be filled later)
2303 static unsigned short convert_from_spdif_status(unsigned int sbits)
2305 unsigned short val = 0;
2307 if (sbits & IEC958_AES0_PROFESSIONAL)
2308 val |= AC_DIG1_PROFESSIONAL;
2309 if (sbits & IEC958_AES0_NONAUDIO)
2310 val |= AC_DIG1_NONAUDIO;
2311 if (sbits & IEC958_AES0_PROFESSIONAL) {
2312 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2313 IEC958_AES0_PRO_EMPHASIS_5015)
2314 val |= AC_DIG1_EMPHASIS;
2316 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2317 IEC958_AES0_CON_EMPHASIS_5015)
2318 val |= AC_DIG1_EMPHASIS;
2319 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2320 val |= AC_DIG1_COPYRIGHT;
2321 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2322 val |= AC_DIG1_LEVEL;
2323 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2328 /* convert to SPDIF status bits from HDA SPDIF bits
2330 static unsigned int convert_to_spdif_status(unsigned short val)
2332 unsigned int sbits = 0;
2334 if (val & AC_DIG1_NONAUDIO)
2335 sbits |= IEC958_AES0_NONAUDIO;
2336 if (val & AC_DIG1_PROFESSIONAL)
2337 sbits |= IEC958_AES0_PROFESSIONAL;
2338 if (sbits & IEC958_AES0_PROFESSIONAL) {
2339 if (sbits & AC_DIG1_EMPHASIS)
2340 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2342 if (val & AC_DIG1_EMPHASIS)
2343 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2344 if (!(val & AC_DIG1_COPYRIGHT))
2345 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2346 if (val & AC_DIG1_LEVEL)
2347 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2348 sbits |= val & (0x7f << 8);
2353 /* set digital convert verbs both for the given NID and its slaves */
2354 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2359 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2360 d = codec->slave_dig_outs;
2364 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2367 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2371 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2373 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2376 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2377 struct snd_ctl_elem_value *ucontrol)
2379 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2380 hda_nid_t nid = kcontrol->private_value;
2384 mutex_lock(&codec->spdif_mutex);
2385 codec->spdif_status = ucontrol->value.iec958.status[0] |
2386 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2387 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2388 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2389 val = convert_from_spdif_status(codec->spdif_status);
2390 val |= codec->spdif_ctls & 1;
2391 change = codec->spdif_ctls != val;
2392 codec->spdif_ctls = val;
2395 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2397 mutex_unlock(&codec->spdif_mutex);
2401 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2403 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2404 struct snd_ctl_elem_value *ucontrol)
2406 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2408 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
2412 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2413 struct snd_ctl_elem_value *ucontrol)
2415 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2416 hda_nid_t nid = kcontrol->private_value;
2420 mutex_lock(&codec->spdif_mutex);
2421 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2422 if (ucontrol->value.integer.value[0])
2423 val |= AC_DIG1_ENABLE;
2424 change = codec->spdif_ctls != val;
2426 codec->spdif_ctls = val;
2427 set_dig_out_convert(codec, nid, val & 0xff, -1);
2428 /* unmute amp switch (if any) */
2429 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2430 (val & AC_DIG1_ENABLE))
2431 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2434 mutex_unlock(&codec->spdif_mutex);
2438 static struct snd_kcontrol_new dig_mixes[] = {
2440 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2441 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2442 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2443 .info = snd_hda_spdif_mask_info,
2444 .get = snd_hda_spdif_cmask_get,
2447 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2448 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2449 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2450 .info = snd_hda_spdif_mask_info,
2451 .get = snd_hda_spdif_pmask_get,
2454 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2455 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2456 .info = snd_hda_spdif_mask_info,
2457 .get = snd_hda_spdif_default_get,
2458 .put = snd_hda_spdif_default_put,
2461 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2462 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2463 .info = snd_hda_spdif_out_switch_info,
2464 .get = snd_hda_spdif_out_switch_get,
2465 .put = snd_hda_spdif_out_switch_put,
2470 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2473 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2474 * @codec: the HDA codec
2475 * @nid: audio out widget NID
2477 * Creates controls related with the SPDIF output.
2478 * Called from each patch supporting the SPDIF out.
2480 * Returns 0 if successful, or a negative error code.
2482 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2485 struct snd_kcontrol *kctl;
2486 struct snd_kcontrol_new *dig_mix;
2489 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2490 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2494 if (idx >= SPDIF_MAX_IDX) {
2495 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2498 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2499 kctl = snd_ctl_new1(dig_mix, codec);
2502 kctl->id.index = idx;
2503 kctl->private_value = nid;
2504 err = snd_hda_ctl_add(codec, nid, kctl);
2509 snd_hda_codec_read(codec, nid, 0,
2510 AC_VERB_GET_DIGI_CONVERT_1, 0);
2511 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2514 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2517 * SPDIF sharing with analog output
2519 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2520 struct snd_ctl_elem_value *ucontrol)
2522 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2523 ucontrol->value.integer.value[0] = mout->share_spdif;
2527 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2528 struct snd_ctl_elem_value *ucontrol)
2530 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2531 mout->share_spdif = !!ucontrol->value.integer.value[0];
2535 static struct snd_kcontrol_new spdif_share_sw = {
2536 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2537 .name = "IEC958 Default PCM Playback Switch",
2538 .info = snd_ctl_boolean_mono_info,
2539 .get = spdif_share_sw_get,
2540 .put = spdif_share_sw_put,
2544 * snd_hda_create_spdif_share_sw - create Default PCM switch
2545 * @codec: the HDA codec
2546 * @mout: multi-out instance
2548 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2549 struct hda_multi_out *mout)
2551 if (!mout->dig_out_nid)
2553 /* ATTENTION: here mout is passed as private_data, instead of codec */
2554 return snd_hda_ctl_add(codec, mout->dig_out_nid,
2555 snd_ctl_new1(&spdif_share_sw, mout));
2557 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2563 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2565 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2566 struct snd_ctl_elem_value *ucontrol)
2568 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2570 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2574 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2575 struct snd_ctl_elem_value *ucontrol)
2577 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2578 hda_nid_t nid = kcontrol->private_value;
2579 unsigned int val = !!ucontrol->value.integer.value[0];
2582 mutex_lock(&codec->spdif_mutex);
2583 change = codec->spdif_in_enable != val;
2585 codec->spdif_in_enable = val;
2586 snd_hda_codec_write_cache(codec, nid, 0,
2587 AC_VERB_SET_DIGI_CONVERT_1, val);
2589 mutex_unlock(&codec->spdif_mutex);
2593 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2594 struct snd_ctl_elem_value *ucontrol)
2596 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2597 hda_nid_t nid = kcontrol->private_value;
2601 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2602 sbits = convert_to_spdif_status(val);
2603 ucontrol->value.iec958.status[0] = sbits;
2604 ucontrol->value.iec958.status[1] = sbits >> 8;
2605 ucontrol->value.iec958.status[2] = sbits >> 16;
2606 ucontrol->value.iec958.status[3] = sbits >> 24;
2610 static struct snd_kcontrol_new dig_in_ctls[] = {
2612 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2613 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2614 .info = snd_hda_spdif_in_switch_info,
2615 .get = snd_hda_spdif_in_switch_get,
2616 .put = snd_hda_spdif_in_switch_put,
2619 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2620 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2621 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2622 .info = snd_hda_spdif_mask_info,
2623 .get = snd_hda_spdif_in_status_get,
2629 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2630 * @codec: the HDA codec
2631 * @nid: audio in widget NID
2633 * Creates controls related with the SPDIF input.
2634 * Called from each patch supporting the SPDIF in.
2636 * Returns 0 if successful, or a negative error code.
2638 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2641 struct snd_kcontrol *kctl;
2642 struct snd_kcontrol_new *dig_mix;
2645 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2646 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2650 if (idx >= SPDIF_MAX_IDX) {
2651 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2654 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2655 kctl = snd_ctl_new1(dig_mix, codec);
2658 kctl->private_value = nid;
2659 err = snd_hda_ctl_add(codec, nid, kctl);
2663 codec->spdif_in_enable =
2664 snd_hda_codec_read(codec, nid, 0,
2665 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2669 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2671 #ifdef SND_HDA_NEEDS_RESUME
2676 /* build a 32bit cache key with the widget id and the command parameter */
2677 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2678 #define get_cmd_cache_nid(key) ((key) & 0xff)
2679 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2682 * snd_hda_codec_write_cache - send a single command with caching
2683 * @codec: the HDA codec
2684 * @nid: NID to send the command
2685 * @direct: direct flag
2686 * @verb: the verb to send
2687 * @parm: the parameter for the verb
2689 * Send a single command without waiting for response.
2691 * Returns 0 if successful, or a negative error code.
2693 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2694 int direct, unsigned int verb, unsigned int parm)
2696 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2697 struct hda_cache_head *c;
2702 /* parm may contain the verb stuff for get/set amp */
2703 verb = verb | (parm >> 8);
2705 key = build_cmd_cache_key(nid, verb);
2706 mutex_lock(&codec->bus->cmd_mutex);
2707 c = get_alloc_hash(&codec->cmd_cache, key);
2710 mutex_unlock(&codec->bus->cmd_mutex);
2713 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2716 * snd_hda_codec_resume_cache - Resume the all commands from the cache
2717 * @codec: HD-audio codec
2719 * Execute all verbs recorded in the command caches to resume.
2721 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2723 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2726 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2727 u32 key = buffer->key;
2730 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2731 get_cmd_cache_cmd(key), buffer->val);
2734 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2737 * snd_hda_sequence_write_cache - sequence writes with caching
2738 * @codec: the HDA codec
2739 * @seq: VERB array to send
2741 * Send the commands sequentially from the given array.
2742 * Thte commands are recorded on cache for power-save and resume.
2743 * The array must be terminated with NID=0.
2745 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2746 const struct hda_verb *seq)
2748 for (; seq->nid; seq++)
2749 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2752 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2753 #endif /* SND_HDA_NEEDS_RESUME */
2756 * set power state of the codec
2758 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2759 unsigned int power_state)
2764 /* this delay seems necessary to avoid click noise at power-down */
2765 if (power_state == AC_PWRST_D3)
2767 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2769 /* partial workaround for "azx_get_response timeout" */
2770 if (power_state == AC_PWRST_D0 &&
2771 (codec->vendor_id & 0xffff0000) == 0x14f10000)
2774 nid = codec->start_nid;
2775 for (i = 0; i < codec->num_nodes; i++, nid++) {
2776 unsigned int wcaps = get_wcaps(codec, nid);
2777 if (wcaps & AC_WCAP_POWER) {
2778 unsigned int wid_type = get_wcaps_type(wcaps);
2779 if (power_state == AC_PWRST_D3 &&
2780 wid_type == AC_WID_PIN) {
2781 unsigned int pincap;
2783 * don't power down the widget if it controls
2784 * eapd and EAPD_BTLENABLE is set.
2786 pincap = snd_hda_query_pin_caps(codec, nid);
2787 if (pincap & AC_PINCAP_EAPD) {
2788 int eapd = snd_hda_codec_read(codec,
2790 AC_VERB_GET_EAPD_BTLENABLE, 0);
2796 snd_hda_codec_write(codec, nid, 0,
2797 AC_VERB_SET_POWER_STATE,
2802 if (power_state == AC_PWRST_D0) {
2803 unsigned long end_time;
2805 /* wait until the codec reachs to D0 */
2806 end_time = jiffies + msecs_to_jiffies(500);
2808 state = snd_hda_codec_read(codec, fg, 0,
2809 AC_VERB_GET_POWER_STATE, 0);
2810 if (state == power_state)
2813 } while (time_after_eq(end_time, jiffies));
2817 #ifdef CONFIG_SND_HDA_HWDEP
2818 /* execute additional init verbs */
2819 static void hda_exec_init_verbs(struct hda_codec *codec)
2821 if (codec->init_verbs.list)
2822 snd_hda_sequence_write(codec, codec->init_verbs.list);
2825 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2828 #ifdef SND_HDA_NEEDS_RESUME
2830 * call suspend and power-down; used both from PM and power-save
2832 static void hda_call_codec_suspend(struct hda_codec *codec)
2834 if (codec->patch_ops.suspend)
2835 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2836 hda_set_power_state(codec,
2837 codec->afg ? codec->afg : codec->mfg,
2839 #ifdef CONFIG_SND_HDA_POWER_SAVE
2840 snd_hda_update_power_acct(codec);
2841 cancel_delayed_work(&codec->power_work);
2842 codec->power_on = 0;
2843 codec->power_transition = 0;
2844 codec->power_jiffies = jiffies;
2849 * kick up codec; used both from PM and power-save
2851 static void hda_call_codec_resume(struct hda_codec *codec)
2853 hda_set_power_state(codec,
2854 codec->afg ? codec->afg : codec->mfg,
2856 restore_pincfgs(codec); /* restore all current pin configs */
2857 hda_exec_init_verbs(codec);
2858 if (codec->patch_ops.resume)
2859 codec->patch_ops.resume(codec);
2861 if (codec->patch_ops.init)
2862 codec->patch_ops.init(codec);
2863 snd_hda_codec_resume_amp(codec);
2864 snd_hda_codec_resume_cache(codec);
2867 #endif /* SND_HDA_NEEDS_RESUME */
2871 * snd_hda_build_controls - build mixer controls
2874 * Creates mixer controls for each codec included in the bus.
2876 * Returns 0 if successful, otherwise a negative error code.
2878 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2880 struct hda_codec *codec;
2882 list_for_each_entry(codec, &bus->codec_list, list) {
2883 int err = snd_hda_codec_build_controls(codec);
2885 printk(KERN_ERR "hda_codec: cannot build controls"
2886 "for #%d (error %d)\n", codec->addr, err);
2887 err = snd_hda_codec_reset(codec);
2890 "hda_codec: cannot revert codec\n");
2897 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2899 int snd_hda_codec_build_controls(struct hda_codec *codec)
2902 hda_exec_init_verbs(codec);
2903 /* continue to initialize... */
2904 if (codec->patch_ops.init)
2905 err = codec->patch_ops.init(codec);
2906 if (!err && codec->patch_ops.build_controls)
2907 err = codec->patch_ops.build_controls(codec);
2916 struct hda_rate_tbl {
2918 unsigned int alsa_bits;
2919 unsigned int hda_fmt;
2922 static struct hda_rate_tbl rate_bits[] = {
2923 /* rate in Hz, ALSA rate bitmask, HDA format value */
2925 /* autodetected value used in snd_hda_query_supported_pcm */
2926 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2927 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2928 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2929 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2930 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2931 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2932 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2933 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2934 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2935 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2936 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2937 #define AC_PAR_PCM_RATE_BITS 11
2938 /* up to bits 10, 384kHZ isn't supported properly */
2940 /* not autodetected value */
2941 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2943 { 0 } /* terminator */
2947 * snd_hda_calc_stream_format - calculate format bitset
2948 * @rate: the sample rate
2949 * @channels: the number of channels
2950 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2951 * @maxbps: the max. bps
2953 * Calculate the format bitset from the given rate, channels and th PCM format.
2955 * Return zero if invalid.
2957 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2958 unsigned int channels,
2959 unsigned int format,
2960 unsigned int maxbps)
2963 unsigned int val = 0;
2965 for (i = 0; rate_bits[i].hz; i++)
2966 if (rate_bits[i].hz == rate) {
2967 val = rate_bits[i].hda_fmt;
2970 if (!rate_bits[i].hz) {
2971 snd_printdd("invalid rate %d\n", rate);
2975 if (channels == 0 || channels > 8) {
2976 snd_printdd("invalid channels %d\n", channels);
2979 val |= channels - 1;
2981 switch (snd_pcm_format_width(format)) {
2982 case 8: val |= 0x00; break;
2983 case 16: val |= 0x10; break;
2987 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
2989 else if (maxbps >= 24)
2995 snd_printdd("invalid format width %d\n",
2996 snd_pcm_format_width(format));
3002 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3004 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3006 unsigned int val = 0;
3007 if (nid != codec->afg &&
3008 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3009 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3010 if (!val || val == -1)
3011 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3012 if (!val || val == -1)
3017 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3019 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3023 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3025 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3026 if (!streams || streams == -1)
3027 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3028 if (!streams || streams == -1)
3033 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3035 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3040 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3041 * @codec: the HDA codec
3042 * @nid: NID to query
3043 * @ratesp: the pointer to store the detected rate bitflags
3044 * @formatsp: the pointer to store the detected formats
3045 * @bpsp: the pointer to store the detected format widths
3047 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3048 * or @bsps argument is ignored.
3050 * Returns 0 if successful, otherwise a negative error code.
3052 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3053 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3055 unsigned int i, val, wcaps;
3057 wcaps = get_wcaps(codec, nid);
3058 val = query_pcm_param(codec, nid);
3062 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3064 rates |= rate_bits[i].alsa_bits;
3067 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3068 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3070 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3076 if (formatsp || bpsp) {
3078 unsigned int streams, bps;
3080 streams = query_stream_param(codec, nid);
3085 if (streams & AC_SUPFMT_PCM) {
3086 if (val & AC_SUPPCM_BITS_8) {
3087 formats |= SNDRV_PCM_FMTBIT_U8;
3090 if (val & AC_SUPPCM_BITS_16) {
3091 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3094 if (wcaps & AC_WCAP_DIGITAL) {
3095 if (val & AC_SUPPCM_BITS_32)
3096 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3097 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3098 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3099 if (val & AC_SUPPCM_BITS_24)
3101 else if (val & AC_SUPPCM_BITS_20)
3103 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3104 AC_SUPPCM_BITS_32)) {
3105 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3106 if (val & AC_SUPPCM_BITS_32)
3108 else if (val & AC_SUPPCM_BITS_24)
3110 else if (val & AC_SUPPCM_BITS_20)
3114 if (streams & AC_SUPFMT_FLOAT32) {
3115 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3119 if (streams == AC_SUPFMT_AC3) {
3120 /* should be exclusive */
3121 /* temporary hack: we have still no proper support
3122 * for the direct AC3 stream...
3124 formats |= SNDRV_PCM_FMTBIT_U8;
3128 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3129 "(nid=0x%x, val=0x%x, ovrd=%i, "
3132 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3137 *formatsp = formats;
3146 * snd_hda_is_supported_format - Check the validity of the format
3147 * @codec: HD-audio codec
3148 * @nid: NID to check
3149 * @format: the HD-audio format value to check
3151 * Check whether the given node supports the format value.
3153 * Returns 1 if supported, 0 if not.
3155 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3156 unsigned int format)
3159 unsigned int val = 0, rate, stream;
3161 val = query_pcm_param(codec, nid);
3165 rate = format & 0xff00;
3166 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3167 if (rate_bits[i].hda_fmt == rate) {
3172 if (i >= AC_PAR_PCM_RATE_BITS)
3175 stream = query_stream_param(codec, nid);
3179 if (stream & AC_SUPFMT_PCM) {
3180 switch (format & 0xf0) {
3182 if (!(val & AC_SUPPCM_BITS_8))
3186 if (!(val & AC_SUPPCM_BITS_16))
3190 if (!(val & AC_SUPPCM_BITS_20))
3194 if (!(val & AC_SUPPCM_BITS_24))
3198 if (!(val & AC_SUPPCM_BITS_32))
3205 /* FIXME: check for float32 and AC3? */
3210 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3215 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3216 struct hda_codec *codec,
3217 struct snd_pcm_substream *substream)
3222 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3223 struct hda_codec *codec,
3224 unsigned int stream_tag,
3225 unsigned int format,
3226 struct snd_pcm_substream *substream)
3228 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3232 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3233 struct hda_codec *codec,
3234 struct snd_pcm_substream *substream)
3236 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3240 static int set_pcm_default_values(struct hda_codec *codec,
3241 struct hda_pcm_stream *info)
3245 /* query support PCM information from the given NID */
3246 if (info->nid && (!info->rates || !info->formats)) {
3247 err = snd_hda_query_supported_pcm(codec, info->nid,
3248 info->rates ? NULL : &info->rates,
3249 info->formats ? NULL : &info->formats,
3250 info->maxbps ? NULL : &info->maxbps);
3254 if (info->ops.open == NULL)
3255 info->ops.open = hda_pcm_default_open_close;
3256 if (info->ops.close == NULL)
3257 info->ops.close = hda_pcm_default_open_close;
3258 if (info->ops.prepare == NULL) {
3259 if (snd_BUG_ON(!info->nid))
3261 info->ops.prepare = hda_pcm_default_prepare;
3263 if (info->ops.cleanup == NULL) {
3264 if (snd_BUG_ON(!info->nid))
3266 info->ops.cleanup = hda_pcm_default_cleanup;
3272 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3273 "Audio", "SPDIF", "HDMI", "Modem"
3277 * get the empty PCM device number to assign
3279 * note the max device number is limited by HDA_MAX_PCMS, currently 10
3281 static int get_empty_pcm_device(struct hda_bus *bus, int type)
3283 /* audio device indices; not linear to keep compatibility */
3284 static int audio_idx[HDA_PCM_NTYPES][5] = {
3285 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3286 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3287 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
3288 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
3292 if (type >= HDA_PCM_NTYPES) {
3293 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3297 for (i = 0; audio_idx[type][i] >= 0 ; i++)
3298 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3299 return audio_idx[type][i];
3301 snd_printk(KERN_WARNING "Too many %s devices\n", snd_hda_pcm_type_name[type]);
3306 * attach a new PCM stream
3308 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
3310 struct hda_bus *bus = codec->bus;
3311 struct hda_pcm_stream *info;
3314 if (snd_BUG_ON(!pcm->name))
3316 for (stream = 0; stream < 2; stream++) {
3317 info = &pcm->stream[stream];
3318 if (info->substreams) {
3319 err = set_pcm_default_values(codec, info);
3324 return bus->ops.attach_pcm(bus, codec, pcm);
3327 /* assign all PCMs of the given codec */
3328 int snd_hda_codec_build_pcms(struct hda_codec *codec)
3333 if (!codec->num_pcms) {
3334 if (!codec->patch_ops.build_pcms)
3336 err = codec->patch_ops.build_pcms(codec);
3338 printk(KERN_ERR "hda_codec: cannot build PCMs"
3339 "for #%d (error %d)\n", codec->addr, err);
3340 err = snd_hda_codec_reset(codec);
3343 "hda_codec: cannot revert codec\n");
3348 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
3349 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
3352 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
3353 continue; /* no substreams assigned */
3356 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
3358 continue; /* no fatal error */
3360 err = snd_hda_attach_pcm(codec, cpcm);
3362 printk(KERN_ERR "hda_codec: cannot attach "
3363 "PCM stream %d for codec #%d\n",
3365 continue; /* no fatal error */
3373 * snd_hda_build_pcms - build PCM information
3376 * Create PCM information for each codec included in the bus.
3378 * The build_pcms codec patch is requested to set up codec->num_pcms and
3379 * codec->pcm_info properly. The array is referred by the top-level driver
3380 * to create its PCM instances.
3381 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3384 * At least, substreams, channels_min and channels_max must be filled for
3385 * each stream. substreams = 0 indicates that the stream doesn't exist.
3386 * When rates and/or formats are zero, the supported values are queried
3387 * from the given nid. The nid is used also by the default ops.prepare
3388 * and ops.cleanup callbacks.
3390 * The driver needs to call ops.open in its open callback. Similarly,
3391 * ops.close is supposed to be called in the close callback.
3392 * ops.prepare should be called in the prepare or hw_params callback
3393 * with the proper parameters for set up.
3394 * ops.cleanup should be called in hw_free for clean up of streams.
3396 * This function returns 0 if successfull, or a negative error code.
3398 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
3400 struct hda_codec *codec;
3402 list_for_each_entry(codec, &bus->codec_list, list) {
3403 int err = snd_hda_codec_build_pcms(codec);
3409 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
3412 * snd_hda_check_board_config - compare the current codec with the config table
3413 * @codec: the HDA codec
3414 * @num_configs: number of config enums
3415 * @models: array of model name strings
3416 * @tbl: configuration table, terminated by null entries
3418 * Compares the modelname or PCI subsystem id of the current codec with the
3419 * given configuration table. If a matching entry is found, returns its
3420 * config value (supposed to be 0 or positive).
3422 * If no entries are matching, the function returns a negative value.
3424 int snd_hda_check_board_config(struct hda_codec *codec,
3425 int num_configs, const char **models,
3426 const struct snd_pci_quirk *tbl)
3428 if (codec->modelname && models) {
3430 for (i = 0; i < num_configs; i++) {
3432 !strcmp(codec->modelname, models[i])) {
3433 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3434 "selected\n", models[i]);
3440 if (!codec->bus->pci || !tbl)
3443 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3446 if (tbl->value >= 0 && tbl->value < num_configs) {
3447 #ifdef CONFIG_SND_DEBUG_VERBOSE
3449 const char *model = NULL;
3451 model = models[tbl->value];
3453 sprintf(tmp, "#%d", tbl->value);
3456 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3457 "for config %x:%x (%s)\n",
3458 model, tbl->subvendor, tbl->subdevice,
3459 (tbl->name ? tbl->name : "Unknown device"));
3465 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3468 * snd_hda_check_board_codec_sid_config - compare the current codec
3469 subsystem ID with the
3472 This is important for Gateway notebooks with SB450 HDA Audio
3473 where the vendor ID of the PCI device is:
3474 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3475 and the vendor/subvendor are found only at the codec.
3477 * @codec: the HDA codec
3478 * @num_configs: number of config enums
3479 * @models: array of model name strings
3480 * @tbl: configuration table, terminated by null entries
3482 * Compares the modelname or PCI subsystem id of the current codec with the
3483 * given configuration table. If a matching entry is found, returns its
3484 * config value (supposed to be 0 or positive).
3486 * If no entries are matching, the function returns a negative value.
3488 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3489 int num_configs, const char **models,
3490 const struct snd_pci_quirk *tbl)
3492 const struct snd_pci_quirk *q;
3494 /* Search for codec ID */
3495 for (q = tbl; q->subvendor; q++) {
3496 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3498 if (vendorid == codec->subsystem_id)
3507 if (tbl->value >= 0 && tbl->value < num_configs) {
3508 #ifdef CONFIG_SND_DEBUG_VERBOSE
3510 const char *model = NULL;
3512 model = models[tbl->value];
3514 sprintf(tmp, "#%d", tbl->value);
3517 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3518 "for config %x:%x (%s)\n",
3519 model, tbl->subvendor, tbl->subdevice,
3520 (tbl->name ? tbl->name : "Unknown device"));
3526 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3529 * snd_hda_add_new_ctls - create controls from the array
3530 * @codec: the HDA codec
3531 * @knew: the array of struct snd_kcontrol_new
3533 * This helper function creates and add new controls in the given array.
3534 * The array must be terminated with an empty entry as terminator.
3536 * Returns 0 if successful, or a negative error code.
3538 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3542 for (; knew->name; knew++) {
3543 struct snd_kcontrol *kctl;
3544 if (knew->iface == -1) /* skip this codec private value */
3546 kctl = snd_ctl_new1(knew, codec);
3549 err = snd_hda_ctl_add(codec, 0, kctl);
3553 kctl = snd_ctl_new1(knew, codec);
3556 kctl->id.device = codec->addr;
3557 err = snd_hda_ctl_add(codec, 0, kctl);
3564 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3566 #ifdef CONFIG_SND_HDA_POWER_SAVE
3567 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3568 unsigned int power_state);
3570 static void hda_power_work(struct work_struct *work)
3572 struct hda_codec *codec =
3573 container_of(work, struct hda_codec, power_work.work);
3574 struct hda_bus *bus = codec->bus;
3576 if (!codec->power_on || codec->power_count) {
3577 codec->power_transition = 0;
3581 hda_call_codec_suspend(codec);
3582 if (bus->ops.pm_notify)
3583 bus->ops.pm_notify(bus);
3586 static void hda_keep_power_on(struct hda_codec *codec)
3588 codec->power_count++;
3589 codec->power_on = 1;
3590 codec->power_jiffies = jiffies;
3593 /* update the power on/off account with the current jiffies */
3594 void snd_hda_update_power_acct(struct hda_codec *codec)
3596 unsigned long delta = jiffies - codec->power_jiffies;
3597 if (codec->power_on)
3598 codec->power_on_acct += delta;
3600 codec->power_off_acct += delta;
3601 codec->power_jiffies += delta;
3605 * snd_hda_power_up - Power-up the codec
3606 * @codec: HD-audio codec
3608 * Increment the power-up counter and power up the hardware really when
3609 * not turned on yet.
3611 void snd_hda_power_up(struct hda_codec *codec)
3613 struct hda_bus *bus = codec->bus;
3615 codec->power_count++;
3616 if (codec->power_on || codec->power_transition)
3619 snd_hda_update_power_acct(codec);
3620 codec->power_on = 1;
3621 codec->power_jiffies = jiffies;
3622 if (bus->ops.pm_notify)
3623 bus->ops.pm_notify(bus);
3624 hda_call_codec_resume(codec);
3625 cancel_delayed_work(&codec->power_work);
3626 codec->power_transition = 0;
3628 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3630 #define power_save(codec) \
3631 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3634 * snd_hda_power_down - Power-down the codec
3635 * @codec: HD-audio codec
3637 * Decrement the power-up counter and schedules the power-off work if
3638 * the counter rearches to zero.
3640 void snd_hda_power_down(struct hda_codec *codec)
3642 --codec->power_count;
3643 if (!codec->power_on || codec->power_count || codec->power_transition)
3645 if (power_save(codec)) {
3646 codec->power_transition = 1; /* avoid reentrance */
3647 queue_delayed_work(codec->bus->workq, &codec->power_work,
3648 msecs_to_jiffies(power_save(codec) * 1000));
3651 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3654 * snd_hda_check_amp_list_power - Check the amp list and update the power
3655 * @codec: HD-audio codec
3656 * @check: the object containing an AMP list and the status
3657 * @nid: NID to check / update
3659 * Check whether the given NID is in the amp list. If it's in the list,
3660 * check the current AMP status, and update the the power-status according
3661 * to the mute status.
3663 * This function is supposed to be set or called from the check_power_status
3666 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3667 struct hda_loopback_check *check,
3670 struct hda_amp_list *p;
3673 if (!check->amplist)
3675 for (p = check->amplist; p->nid; p++) {
3680 return 0; /* nothing changed */
3682 for (p = check->amplist; p->nid; p++) {
3683 for (ch = 0; ch < 2; ch++) {
3684 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3686 if (!(v & HDA_AMP_MUTE) && v > 0) {
3687 if (!check->power_on) {
3688 check->power_on = 1;
3689 snd_hda_power_up(codec);
3695 if (check->power_on) {
3696 check->power_on = 0;
3697 snd_hda_power_down(codec);
3701 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3705 * Channel mode helper
3709 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
3711 int snd_hda_ch_mode_info(struct hda_codec *codec,
3712 struct snd_ctl_elem_info *uinfo,
3713 const struct hda_channel_mode *chmode,
3716 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3718 uinfo->value.enumerated.items = num_chmodes;
3719 if (uinfo->value.enumerated.item >= num_chmodes)
3720 uinfo->value.enumerated.item = num_chmodes - 1;
3721 sprintf(uinfo->value.enumerated.name, "%dch",
3722 chmode[uinfo->value.enumerated.item].channels);
3725 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3728 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
3730 int snd_hda_ch_mode_get(struct hda_codec *codec,
3731 struct snd_ctl_elem_value *ucontrol,
3732 const struct hda_channel_mode *chmode,
3738 for (i = 0; i < num_chmodes; i++) {
3739 if (max_channels == chmode[i].channels) {
3740 ucontrol->value.enumerated.item[0] = i;
3746 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3749 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
3751 int snd_hda_ch_mode_put(struct hda_codec *codec,
3752 struct snd_ctl_elem_value *ucontrol,
3753 const struct hda_channel_mode *chmode,
3759 mode = ucontrol->value.enumerated.item[0];
3760 if (mode >= num_chmodes)
3762 if (*max_channelsp == chmode[mode].channels)
3764 /* change the current channel setting */
3765 *max_channelsp = chmode[mode].channels;
3766 if (chmode[mode].sequence)
3767 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3770 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3777 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
3779 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3780 struct snd_ctl_elem_info *uinfo)
3784 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3786 uinfo->value.enumerated.items = imux->num_items;
3787 if (!imux->num_items)
3789 index = uinfo->value.enumerated.item;
3790 if (index >= imux->num_items)
3791 index = imux->num_items - 1;
3792 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3795 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3798 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
3800 int snd_hda_input_mux_put(struct hda_codec *codec,
3801 const struct hda_input_mux *imux,
3802 struct snd_ctl_elem_value *ucontrol,
3804 unsigned int *cur_val)
3808 if (!imux->num_items)
3810 idx = ucontrol->value.enumerated.item[0];
3811 if (idx >= imux->num_items)
3812 idx = imux->num_items - 1;
3813 if (*cur_val == idx)
3815 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3816 imux->items[idx].index);
3820 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3824 * Multi-channel / digital-out PCM helper functions
3827 /* setup SPDIF output stream */
3828 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3829 unsigned int stream_tag, unsigned int format)
3831 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3832 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3833 set_dig_out_convert(codec, nid,
3834 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3836 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3837 if (codec->slave_dig_outs) {
3839 for (d = codec->slave_dig_outs; *d; d++)
3840 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3843 /* turn on again (if needed) */
3844 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3845 set_dig_out_convert(codec, nid,
3846 codec->spdif_ctls & 0xff, -1);
3849 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3851 snd_hda_codec_cleanup_stream(codec, nid);
3852 if (codec->slave_dig_outs) {
3854 for (d = codec->slave_dig_outs; *d; d++)
3855 snd_hda_codec_cleanup_stream(codec, *d);
3860 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
3861 * @bus: HD-audio bus
3863 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
3865 struct hda_codec *codec;
3869 list_for_each_entry(codec, &bus->codec_list, list) {
3870 #ifdef CONFIG_SND_HDA_POWER_SAVE
3871 if (!codec->power_on)
3874 if (codec->patch_ops.reboot_notify)
3875 codec->patch_ops.reboot_notify(codec);
3878 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
3881 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
3883 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3884 struct hda_multi_out *mout)
3886 mutex_lock(&codec->spdif_mutex);
3887 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3888 /* already opened as analog dup; reset it once */
3889 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3890 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3891 mutex_unlock(&codec->spdif_mutex);
3894 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3897 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
3899 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3900 struct hda_multi_out *mout,
3901 unsigned int stream_tag,
3902 unsigned int format,
3903 struct snd_pcm_substream *substream)
3905 mutex_lock(&codec->spdif_mutex);
3906 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3907 mutex_unlock(&codec->spdif_mutex);
3910 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3913 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
3915 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3916 struct hda_multi_out *mout)
3918 mutex_lock(&codec->spdif_mutex);
3919 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3920 mutex_unlock(&codec->spdif_mutex);
3923 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3926 * snd_hda_multi_out_dig_close - release the digital out stream
3928 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3929 struct hda_multi_out *mout)
3931 mutex_lock(&codec->spdif_mutex);
3932 mout->dig_out_used = 0;
3933 mutex_unlock(&codec->spdif_mutex);
3936 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3939 * snd_hda_multi_out_analog_open - open analog outputs
3941 * Open analog outputs and set up the hw-constraints.
3942 * If the digital outputs can be opened as slave, open the digital
3945 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3946 struct hda_multi_out *mout,
3947 struct snd_pcm_substream *substream,
3948 struct hda_pcm_stream *hinfo)
3950 struct snd_pcm_runtime *runtime = substream->runtime;
3951 runtime->hw.channels_max = mout->max_channels;
3952 if (mout->dig_out_nid) {
3953 if (!mout->analog_rates) {
3954 mout->analog_rates = hinfo->rates;
3955 mout->analog_formats = hinfo->formats;
3956 mout->analog_maxbps = hinfo->maxbps;
3958 runtime->hw.rates = mout->analog_rates;
3959 runtime->hw.formats = mout->analog_formats;
3960 hinfo->maxbps = mout->analog_maxbps;
3962 if (!mout->spdif_rates) {
3963 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3965 &mout->spdif_formats,
3966 &mout->spdif_maxbps);
3968 mutex_lock(&codec->spdif_mutex);
3969 if (mout->share_spdif) {
3970 if ((runtime->hw.rates & mout->spdif_rates) &&
3971 (runtime->hw.formats & mout->spdif_formats)) {
3972 runtime->hw.rates &= mout->spdif_rates;
3973 runtime->hw.formats &= mout->spdif_formats;
3974 if (mout->spdif_maxbps < hinfo->maxbps)
3975 hinfo->maxbps = mout->spdif_maxbps;
3977 mout->share_spdif = 0;
3978 /* FIXME: need notify? */
3981 mutex_unlock(&codec->spdif_mutex);
3983 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3984 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3986 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3989 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
3991 * Set up the i/o for analog out.
3992 * When the digital out is available, copy the front out to digital out, too.
3994 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3995 struct hda_multi_out *mout,
3996 unsigned int stream_tag,
3997 unsigned int format,
3998 struct snd_pcm_substream *substream)
4000 hda_nid_t *nids = mout->dac_nids;
4001 int chs = substream->runtime->channels;
4004 mutex_lock(&codec->spdif_mutex);
4005 if (mout->dig_out_nid && mout->share_spdif &&
4006 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4008 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4010 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
4011 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4012 setup_dig_out_stream(codec, mout->dig_out_nid,
4013 stream_tag, format);
4015 mout->dig_out_used = 0;
4016 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4019 mutex_unlock(&codec->spdif_mutex);
4022 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4024 if (!mout->no_share_stream &&
4025 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4026 /* headphone out will just decode front left/right (stereo) */
4027 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4029 /* extra outputs copied from front */
4030 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4031 if (!mout->no_share_stream && mout->extra_out_nid[i])
4032 snd_hda_codec_setup_stream(codec,
4033 mout->extra_out_nid[i],
4034 stream_tag, 0, format);
4037 for (i = 1; i < mout->num_dacs; i++) {
4038 if (chs >= (i + 1) * 2) /* independent out */
4039 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4041 else if (!mout->no_share_stream) /* copy front */
4042 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4047 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
4050 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4052 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4053 struct hda_multi_out *mout)
4055 hda_nid_t *nids = mout->dac_nids;
4058 for (i = 0; i < mout->num_dacs; i++)
4059 snd_hda_codec_cleanup_stream(codec, nids[i]);
4061 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4062 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4063 if (mout->extra_out_nid[i])
4064 snd_hda_codec_cleanup_stream(codec,
4065 mout->extra_out_nid[i]);
4066 mutex_lock(&codec->spdif_mutex);
4067 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4068 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4069 mout->dig_out_used = 0;
4071 mutex_unlock(&codec->spdif_mutex);
4074 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4077 * Helper for automatic pin configuration
4080 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
4082 for (; *list; list++)
4090 * Sort an associated group of pins according to their sequence numbers.
4092 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
4099 for (i = 0; i < num_pins; i++) {
4100 for (j = i + 1; j < num_pins; j++) {
4101 if (sequences[i] > sequences[j]) {
4103 sequences[i] = sequences[j];
4115 * Parse all pin widgets and store the useful pin nids to cfg
4117 * The number of line-outs or any primary output is stored in line_outs,
4118 * and the corresponding output pins are assigned to line_out_pins[],
4119 * in the order of front, rear, CLFE, side, ...
4121 * If more extra outputs (speaker and headphone) are found, the pins are
4122 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
4123 * is detected, one of speaker of HP pins is assigned as the primary
4124 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4125 * if any analog output exists.
4127 * The analog input pins are assigned to input_pins array.
4128 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4131 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
4132 struct auto_pin_cfg *cfg,
4133 hda_nid_t *ignore_nids)
4135 hda_nid_t nid, end_nid;
4136 short seq, assoc_line_out, assoc_speaker;
4137 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4138 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
4139 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
4141 memset(cfg, 0, sizeof(*cfg));
4143 memset(sequences_line_out, 0, sizeof(sequences_line_out));
4144 memset(sequences_speaker, 0, sizeof(sequences_speaker));
4145 memset(sequences_hp, 0, sizeof(sequences_hp));
4146 assoc_line_out = assoc_speaker = 0;
4148 end_nid = codec->start_nid + codec->num_nodes;
4149 for (nid = codec->start_nid; nid < end_nid; nid++) {
4150 unsigned int wid_caps = get_wcaps(codec, nid);
4151 unsigned int wid_type = get_wcaps_type(wid_caps);
4152 unsigned int def_conf;
4155 /* read all default configuration for pin complex */
4156 if (wid_type != AC_WID_PIN)
4158 /* ignore the given nids (e.g. pc-beep returns error) */
4159 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4162 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4163 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
4165 loc = get_defcfg_location(def_conf);
4166 switch (get_defcfg_device(def_conf)) {
4167 case AC_JACK_LINE_OUT:
4168 seq = get_defcfg_sequence(def_conf);
4169 assoc = get_defcfg_association(def_conf);
4171 if (!(wid_caps & AC_WCAP_STEREO))
4172 if (!cfg->mono_out_pin)
4173 cfg->mono_out_pin = nid;
4176 if (!assoc_line_out)
4177 assoc_line_out = assoc;
4178 else if (assoc_line_out != assoc)
4180 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4182 cfg->line_out_pins[cfg->line_outs] = nid;
4183 sequences_line_out[cfg->line_outs] = seq;
4186 case AC_JACK_SPEAKER:
4187 seq = get_defcfg_sequence(def_conf);
4188 assoc = get_defcfg_association(def_conf);
4191 if (! assoc_speaker)
4192 assoc_speaker = assoc;
4193 else if (assoc_speaker != assoc)
4195 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4197 cfg->speaker_pins[cfg->speaker_outs] = nid;
4198 sequences_speaker[cfg->speaker_outs] = seq;
4199 cfg->speaker_outs++;
4201 case AC_JACK_HP_OUT:
4202 seq = get_defcfg_sequence(def_conf);
4203 assoc = get_defcfg_association(def_conf);
4204 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4206 cfg->hp_pins[cfg->hp_outs] = nid;
4207 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
4210 case AC_JACK_MIC_IN: {
4212 if (loc == AC_JACK_LOC_FRONT) {
4213 preferred = AUTO_PIN_FRONT_MIC;
4216 preferred = AUTO_PIN_MIC;
4217 alt = AUTO_PIN_FRONT_MIC;
4219 if (!cfg->input_pins[preferred])
4220 cfg->input_pins[preferred] = nid;
4221 else if (!cfg->input_pins[alt])
4222 cfg->input_pins[alt] = nid;
4225 case AC_JACK_LINE_IN:
4226 if (loc == AC_JACK_LOC_FRONT)
4227 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
4229 cfg->input_pins[AUTO_PIN_LINE] = nid;
4232 cfg->input_pins[AUTO_PIN_CD] = nid;
4235 cfg->input_pins[AUTO_PIN_AUX] = nid;
4237 case AC_JACK_SPDIF_OUT:
4238 case AC_JACK_DIG_OTHER_OUT:
4239 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
4241 cfg->dig_out_pins[cfg->dig_outs] = nid;
4242 cfg->dig_out_type[cfg->dig_outs] =
4243 (loc == AC_JACK_LOC_HDMI) ?
4244 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
4247 case AC_JACK_SPDIF_IN:
4248 case AC_JACK_DIG_OTHER_IN:
4249 cfg->dig_in_pin = nid;
4250 if (loc == AC_JACK_LOC_HDMI)
4251 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
4253 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
4259 * If no line-out is defined but multiple HPs are found,
4260 * some of them might be the real line-outs.
4262 if (!cfg->line_outs && cfg->hp_outs > 1) {
4264 while (i < cfg->hp_outs) {
4265 /* The real HPs should have the sequence 0x0f */
4266 if ((sequences_hp[i] & 0x0f) == 0x0f) {
4270 /* Move it to the line-out table */
4271 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
4272 sequences_line_out[cfg->line_outs] = sequences_hp[i];
4275 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
4276 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
4277 memmove(sequences_hp + i - 1, sequences_hp + i,
4278 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
4282 /* sort by sequence */
4283 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
4285 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
4287 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
4290 /* if we have only one mic, make it AUTO_PIN_MIC */
4291 if (!cfg->input_pins[AUTO_PIN_MIC] &&
4292 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
4293 cfg->input_pins[AUTO_PIN_MIC] =
4294 cfg->input_pins[AUTO_PIN_FRONT_MIC];
4295 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
4297 /* ditto for line-in */
4298 if (!cfg->input_pins[AUTO_PIN_LINE] &&
4299 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
4300 cfg->input_pins[AUTO_PIN_LINE] =
4301 cfg->input_pins[AUTO_PIN_FRONT_LINE];
4302 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
4306 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4307 * as a primary output
4309 if (!cfg->line_outs) {
4310 if (cfg->speaker_outs) {
4311 cfg->line_outs = cfg->speaker_outs;
4312 memcpy(cfg->line_out_pins, cfg->speaker_pins,
4313 sizeof(cfg->speaker_pins));
4314 cfg->speaker_outs = 0;
4315 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
4316 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
4317 } else if (cfg->hp_outs) {
4318 cfg->line_outs = cfg->hp_outs;
4319 memcpy(cfg->line_out_pins, cfg->hp_pins,
4320 sizeof(cfg->hp_pins));
4322 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4323 cfg->line_out_type = AUTO_PIN_HP_OUT;
4327 /* Reorder the surround channels
4328 * ALSA sequence is front/surr/clfe/side
4330 * 4-ch: front/surr => OK as it is
4331 * 6-ch: front/clfe/surr
4332 * 8-ch: front/clfe/rear/side|fc
4334 switch (cfg->line_outs) {
4337 nid = cfg->line_out_pins[1];
4338 cfg->line_out_pins[1] = cfg->line_out_pins[2];
4339 cfg->line_out_pins[2] = nid;
4344 * debug prints of the parsed results
4346 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4347 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
4348 cfg->line_out_pins[2], cfg->line_out_pins[3],
4349 cfg->line_out_pins[4]);
4350 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4351 cfg->speaker_outs, cfg->speaker_pins[0],
4352 cfg->speaker_pins[1], cfg->speaker_pins[2],
4353 cfg->speaker_pins[3], cfg->speaker_pins[4]);
4354 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4355 cfg->hp_outs, cfg->hp_pins[0],
4356 cfg->hp_pins[1], cfg->hp_pins[2],
4357 cfg->hp_pins[3], cfg->hp_pins[4]);
4358 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
4360 snd_printd(" dig-out=0x%x/0x%x\n",
4361 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
4362 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
4363 " cd=0x%x, aux=0x%x\n",
4364 cfg->input_pins[AUTO_PIN_MIC],
4365 cfg->input_pins[AUTO_PIN_FRONT_MIC],
4366 cfg->input_pins[AUTO_PIN_LINE],
4367 cfg->input_pins[AUTO_PIN_FRONT_LINE],
4368 cfg->input_pins[AUTO_PIN_CD],
4369 cfg->input_pins[AUTO_PIN_AUX]);
4370 if (cfg->dig_in_pin)
4371 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
4375 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
4377 /* labels for input pins */
4378 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
4379 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
4381 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
4390 * snd_hda_suspend - suspend the codecs
4393 * Returns 0 if successful.
4395 int snd_hda_suspend(struct hda_bus *bus)
4397 struct hda_codec *codec;
4399 list_for_each_entry(codec, &bus->codec_list, list) {
4400 #ifdef CONFIG_SND_HDA_POWER_SAVE
4401 if (!codec->power_on)
4404 hda_call_codec_suspend(codec);
4408 EXPORT_SYMBOL_HDA(snd_hda_suspend);
4411 * snd_hda_resume - resume the codecs
4414 * Returns 0 if successful.
4416 * This fucntion is defined only when POWER_SAVE isn't set.
4417 * In the power-save mode, the codec is resumed dynamically.
4419 int snd_hda_resume(struct hda_bus *bus)
4421 struct hda_codec *codec;
4423 list_for_each_entry(codec, &bus->codec_list, list) {
4424 if (snd_hda_codec_needs_resume(codec))
4425 hda_call_codec_resume(codec);
4429 EXPORT_SYMBOL_HDA(snd_hda_resume);
4430 #endif /* CONFIG_PM */
4437 * snd_array_new - get a new element from the given array
4438 * @array: the array object
4440 * Get a new element from the given array. If it exceeds the
4441 * pre-allocated array size, re-allocate the array.
4443 * Returns NULL if allocation failed.
4445 void *snd_array_new(struct snd_array *array)
4447 if (array->used >= array->alloced) {
4448 int num = array->alloced + array->alloc_align;
4450 if (snd_BUG_ON(num >= 4096))
4452 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
4456 memcpy(nlist, array->list,
4457 array->elem_size * array->alloced);
4460 array->list = nlist;
4461 array->alloced = num;
4463 return snd_array_elem(array, array->used++);
4465 EXPORT_SYMBOL_HDA(snd_array_new);
4468 * snd_array_free - free the given array elements
4469 * @array: the array object
4471 void snd_array_free(struct snd_array *array)
4478 EXPORT_SYMBOL_HDA(snd_array_free);
4481 * snd_print_pcm_rates - Print the supported PCM rates to the string buffer
4482 * @pcm: PCM caps bits
4483 * @buf: the string buffer to write
4484 * @buflen: the max buffer length
4486 * used by hda_proc.c and hda_eld.c
4488 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
4490 static unsigned int rates[] = {
4491 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
4492 96000, 176400, 192000, 384000
4496 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
4498 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
4500 buf[j] = '\0'; /* necessary when j == 0 */
4502 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
4505 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4506 * @pcm: PCM caps bits
4507 * @buf: the string buffer to write
4508 * @buflen: the max buffer length
4510 * used by hda_proc.c and hda_eld.c
4512 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4514 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
4517 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4518 if (pcm & (AC_SUPPCM_BITS_8 << i))
4519 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
4521 buf[j] = '\0'; /* necessary when j == 0 */
4523 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
4525 MODULE_DESCRIPTION("HDA codec core");
4526 MODULE_LICENSE("GPL");