2 * Universal Interface for Intel High Definition Audio Codec
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/pci.h>
26 #include <linux/mutex.h>
27 #include <sound/core.h>
28 #include "hda_codec.h"
29 #include <sound/asoundef.h>
30 #include <sound/tlv.h>
31 #include <sound/initval.h>
32 #include "hda_local.h"
33 #include <sound/hda_hwdep.h>
36 * vendor / preset table
39 struct hda_vendor_id {
44 /* codec vendor labels */
45 static struct hda_vendor_id hda_vendor_ids[] = {
47 { 0x1013, "Cirrus Logic" },
48 { 0x1057, "Motorola" },
49 { 0x1095, "Silicon Image" },
51 { 0x10ec, "Realtek" },
52 { 0x1102, "Creative" },
56 { 0x11d4, "Analog Devices" },
57 { 0x13f6, "C-Media" },
58 { 0x14f1, "Conexant" },
59 { 0x17e8, "Chrontel" },
61 { 0x1aec, "Wolfson Microelectronics" },
62 { 0x434d, "C-Media" },
64 { 0x8384, "SigmaTel" },
68 static DEFINE_MUTEX(preset_mutex);
69 static LIST_HEAD(hda_preset_tables);
71 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
73 mutex_lock(&preset_mutex);
74 list_add_tail(&preset->list, &hda_preset_tables);
75 mutex_unlock(&preset_mutex);
78 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
80 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
82 mutex_lock(&preset_mutex);
83 list_del(&preset->list);
84 mutex_unlock(&preset_mutex);
87 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
89 #ifdef CONFIG_SND_HDA_POWER_SAVE
90 static void hda_power_work(struct work_struct *work);
91 static void hda_keep_power_on(struct hda_codec *codec);
93 static inline void hda_keep_power_on(struct hda_codec *codec) {}
96 const char *snd_hda_get_jack_location(u32 cfg)
98 static char *bases[7] = {
99 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
101 static unsigned char specials_idx[] = {
106 static char *specials[] = {
107 "Rear Panel", "Drive Bar",
108 "Riser", "HDMI", "ATAPI",
109 "Mobile-In", "Mobile-Out"
112 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
113 if ((cfg & 0x0f) < 7)
114 return bases[cfg & 0x0f];
115 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
116 if (cfg == specials_idx[i])
121 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
123 const char *snd_hda_get_jack_connectivity(u32 cfg)
125 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
127 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
129 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
131 const char *snd_hda_get_jack_type(u32 cfg)
133 static char *jack_types[16] = {
134 "Line Out", "Speaker", "HP Out", "CD",
135 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
136 "Line In", "Aux", "Mic", "Telephony",
137 "SPDIF In", "Digitial In", "Reserved", "Other"
140 return jack_types[(cfg & AC_DEFCFG_DEVICE)
141 >> AC_DEFCFG_DEVICE_SHIFT];
143 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
146 * Compose a 32bit command word to be sent to the HD-audio controller
148 static inline unsigned int
149 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
150 unsigned int verb, unsigned int parm)
154 val = (u32)(codec->addr & 0x0f) << 28;
155 val |= (u32)direct << 27;
156 val |= (u32)nid << 20;
163 * Send and receive a verb
165 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
168 struct hda_bus *bus = codec->bus;
174 snd_hda_power_up(codec);
175 mutex_lock(&bus->cmd_mutex);
176 err = bus->ops.command(bus, cmd);
178 *res = bus->ops.get_response(bus);
179 mutex_unlock(&bus->cmd_mutex);
180 snd_hda_power_down(codec);
181 if (res && *res == -1 && bus->rirb_error) {
182 if (bus->response_reset) {
183 snd_printd("hda_codec: resetting BUS due to "
184 "fatal communication error\n");
185 bus->ops.bus_reset(bus);
189 /* clear reset-flag when the communication gets recovered */
191 bus->response_reset = 0;
196 * snd_hda_codec_read - send a command and get the response
197 * @codec: the HDA codec
198 * @nid: NID to send the command
199 * @direct: direct flag
200 * @verb: the verb to send
201 * @parm: the parameter for the verb
203 * Send a single command and read the corresponding response.
205 * Returns the obtained response value, or -1 for an error.
207 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
209 unsigned int verb, unsigned int parm)
211 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
213 codec_exec_verb(codec, cmd, &res);
216 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
219 * snd_hda_codec_write - send a single command without waiting for response
220 * @codec: the HDA codec
221 * @nid: NID to send the command
222 * @direct: direct flag
223 * @verb: the verb to send
224 * @parm: the parameter for the verb
226 * Send a single command without waiting for response.
228 * Returns 0 if successful, or a negative error code.
230 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
231 unsigned int verb, unsigned int parm)
233 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
235 return codec_exec_verb(codec, cmd,
236 codec->bus->sync_write ? &res : NULL);
238 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
241 * snd_hda_sequence_write - sequence writes
242 * @codec: the HDA codec
243 * @seq: VERB array to send
245 * Send the commands sequentially from the given array.
246 * The array must be terminated with NID=0.
248 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
250 for (; seq->nid; seq++)
251 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
253 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
256 * snd_hda_get_sub_nodes - get the range of sub nodes
257 * @codec: the HDA codec
259 * @start_id: the pointer to store the start NID
261 * Parse the NID and store the start NID of its sub-nodes.
262 * Returns the number of sub-nodes.
264 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
269 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
272 *start_id = (parm >> 16) & 0x7fff;
273 return (int)(parm & 0x7fff);
275 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
278 * snd_hda_get_connections - get connection list
279 * @codec: the HDA codec
281 * @conn_list: connection list array
282 * @max_conns: max. number of connections to store
284 * Parses the connection list of the given widget and stores the list
287 * Returns the number of connections, or a negative error code.
289 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
290 hda_nid_t *conn_list, int max_conns)
293 int i, conn_len, conns;
294 unsigned int shift, num_elems, mask;
297 if (snd_BUG_ON(!conn_list || max_conns <= 0))
300 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
301 if (parm & AC_CLIST_LONG) {
310 conn_len = parm & AC_CLIST_LENGTH;
311 mask = (1 << (shift-1)) - 1;
314 return 0; /* no connection */
317 /* single connection */
318 parm = snd_hda_codec_read(codec, nid, 0,
319 AC_VERB_GET_CONNECT_LIST, 0);
320 conn_list[0] = parm & mask;
324 /* multi connection */
327 for (i = 0; i < conn_len; i++) {
331 if (i % num_elems == 0)
332 parm = snd_hda_codec_read(codec, nid, 0,
333 AC_VERB_GET_CONNECT_LIST, i);
334 range_val = !!(parm & (1 << (shift-1))); /* ranges */
338 /* ranges between the previous and this one */
339 if (!prev_nid || prev_nid >= val) {
340 snd_printk(KERN_WARNING "hda_codec: "
341 "invalid dep_range_val %x:%x\n",
345 for (n = prev_nid + 1; n <= val; n++) {
346 if (conns >= max_conns) {
348 "Too many connections\n");
351 conn_list[conns++] = n;
354 if (conns >= max_conns) {
355 snd_printk(KERN_ERR "Too many connections\n");
358 conn_list[conns++] = val;
364 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
368 * snd_hda_queue_unsol_event - add an unsolicited event to queue
370 * @res: unsolicited event (lower 32bit of RIRB entry)
371 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
373 * Adds the given event to the queue. The events are processed in
374 * the workqueue asynchronously. Call this function in the interrupt
375 * hanlder when RIRB receives an unsolicited event.
377 * Returns 0 if successful, or a negative error code.
379 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
381 struct hda_bus_unsolicited *unsol;
388 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
392 unsol->queue[wp] = res;
393 unsol->queue[wp + 1] = res_ex;
395 queue_work(bus->workq, &unsol->work);
399 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
402 * process queued unsolicited events
404 static void process_unsol_events(struct work_struct *work)
406 struct hda_bus_unsolicited *unsol =
407 container_of(work, struct hda_bus_unsolicited, work);
408 struct hda_bus *bus = unsol->bus;
409 struct hda_codec *codec;
410 unsigned int rp, caddr, res;
412 while (unsol->rp != unsol->wp) {
413 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
416 res = unsol->queue[rp];
417 caddr = unsol->queue[rp + 1];
418 if (!(caddr & (1 << 4))) /* no unsolicited event? */
420 codec = bus->caddr_tbl[caddr & 0x0f];
421 if (codec && codec->patch_ops.unsol_event)
422 codec->patch_ops.unsol_event(codec, res);
427 * initialize unsolicited queue
429 static int init_unsol_queue(struct hda_bus *bus)
431 struct hda_bus_unsolicited *unsol;
433 if (bus->unsol) /* already initialized */
436 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
438 snd_printk(KERN_ERR "hda_codec: "
439 "can't allocate unsolicited queue\n");
442 INIT_WORK(&unsol->work, process_unsol_events);
451 static void snd_hda_codec_free(struct hda_codec *codec);
453 static int snd_hda_bus_free(struct hda_bus *bus)
455 struct hda_codec *codec, *n;
460 flush_workqueue(bus->workq);
463 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
464 snd_hda_codec_free(codec);
466 if (bus->ops.private_free)
467 bus->ops.private_free(bus);
469 destroy_workqueue(bus->workq);
474 static int snd_hda_bus_dev_free(struct snd_device *device)
476 struct hda_bus *bus = device->device_data;
478 return snd_hda_bus_free(bus);
481 #ifdef CONFIG_SND_HDA_HWDEP
482 static int snd_hda_bus_dev_register(struct snd_device *device)
484 struct hda_bus *bus = device->device_data;
485 struct hda_codec *codec;
486 list_for_each_entry(codec, &bus->codec_list, list) {
487 snd_hda_hwdep_add_sysfs(codec);
492 #define snd_hda_bus_dev_register NULL
496 * snd_hda_bus_new - create a HDA bus
497 * @card: the card entry
498 * @temp: the template for hda_bus information
499 * @busp: the pointer to store the created bus instance
501 * Returns 0 if successful, or a negative error code.
503 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
504 const struct hda_bus_template *temp,
505 struct hda_bus **busp)
509 static struct snd_device_ops dev_ops = {
510 .dev_register = snd_hda_bus_dev_register,
511 .dev_free = snd_hda_bus_dev_free,
514 if (snd_BUG_ON(!temp))
516 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
522 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
524 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
529 bus->private_data = temp->private_data;
530 bus->pci = temp->pci;
531 bus->modelname = temp->modelname;
532 bus->power_save = temp->power_save;
533 bus->ops = temp->ops;
535 mutex_init(&bus->cmd_mutex);
536 INIT_LIST_HEAD(&bus->codec_list);
538 snprintf(bus->workq_name, sizeof(bus->workq_name),
539 "hd-audio%d", card->number);
540 bus->workq = create_singlethread_workqueue(bus->workq_name);
542 snd_printk(KERN_ERR "cannot create workqueue %s\n",
548 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
550 snd_hda_bus_free(bus);
557 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
559 #ifdef CONFIG_SND_HDA_GENERIC
560 #define is_generic_config(codec) \
561 (codec->modelname && !strcmp(codec->modelname, "generic"))
563 #define is_generic_config(codec) 0
567 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
569 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
573 * find a matching codec preset
575 static const struct hda_codec_preset *
576 find_codec_preset(struct hda_codec *codec)
578 struct hda_codec_preset_list *tbl;
579 const struct hda_codec_preset *preset;
580 int mod_requested = 0;
582 if (is_generic_config(codec))
583 return NULL; /* use the generic parser */
586 mutex_lock(&preset_mutex);
587 list_for_each_entry(tbl, &hda_preset_tables, list) {
588 if (!try_module_get(tbl->owner)) {
589 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
592 for (preset = tbl->preset; preset->id; preset++) {
593 u32 mask = preset->mask;
594 if (preset->afg && preset->afg != codec->afg)
596 if (preset->mfg && preset->mfg != codec->mfg)
600 if (preset->id == (codec->vendor_id & mask) &&
602 preset->rev == codec->revision_id)) {
603 mutex_unlock(&preset_mutex);
604 codec->owner = tbl->owner;
608 module_put(tbl->owner);
610 mutex_unlock(&preset_mutex);
612 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
615 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
618 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
619 (codec->vendor_id >> 16) & 0xffff);
620 request_module(name);
628 * get_codec_name - store the codec name
630 static int get_codec_name(struct hda_codec *codec)
632 const struct hda_vendor_id *c;
633 const char *vendor = NULL;
634 u16 vendor_id = codec->vendor_id >> 16;
637 if (codec->vendor_name)
640 for (c = hda_vendor_ids; c->id; c++) {
641 if (c->id == vendor_id) {
647 sprintf(tmp, "Generic %04x", vendor_id);
650 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
651 if (!codec->vendor_name)
655 if (codec->chip_name)
658 if (codec->preset && codec->preset->name)
659 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
661 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
662 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
664 if (!codec->chip_name)
670 * look for an AFG and MFG nodes
672 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
674 int i, total_nodes, function_id;
677 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
678 for (i = 0; i < total_nodes; i++, nid++) {
679 function_id = snd_hda_param_read(codec, nid,
680 AC_PAR_FUNCTION_TYPE) & 0xff;
681 switch (function_id) {
682 case AC_GRP_AUDIO_FUNCTION:
684 codec->function_id = function_id;
686 case AC_GRP_MODEM_FUNCTION:
688 codec->function_id = function_id;
697 * read widget caps for each widget and store in cache
699 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
704 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
706 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
709 nid = codec->start_nid;
710 for (i = 0; i < codec->num_nodes; i++, nid++)
711 codec->wcaps[i] = snd_hda_param_read(codec, nid,
712 AC_PAR_AUDIO_WIDGET_CAP);
716 /* read all pin default configurations and save codec->init_pins */
717 static int read_pin_defaults(struct hda_codec *codec)
720 hda_nid_t nid = codec->start_nid;
722 for (i = 0; i < codec->num_nodes; i++, nid++) {
723 struct hda_pincfg *pin;
724 unsigned int wcaps = get_wcaps(codec, nid);
725 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
727 if (wid_type != AC_WID_PIN)
729 pin = snd_array_new(&codec->init_pins);
733 pin->cfg = snd_hda_codec_read(codec, nid, 0,
734 AC_VERB_GET_CONFIG_DEFAULT, 0);
739 /* look up the given pin config list and return the item matching with NID */
740 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
741 struct snd_array *array,
745 for (i = 0; i < array->used; i++) {
746 struct hda_pincfg *pin = snd_array_elem(array, i);
753 /* write a config value for the given NID */
754 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
758 for (i = 0; i < 4; i++) {
759 snd_hda_codec_write(codec, nid, 0,
760 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
766 /* set the current pin config value for the given NID.
767 * the value is cached, and read via snd_hda_codec_get_pincfg()
769 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
770 hda_nid_t nid, unsigned int cfg)
772 struct hda_pincfg *pin;
775 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
776 pin = look_up_pincfg(codec, list, nid);
778 pin = snd_array_new(list);
785 /* change only when needed; e.g. if the pincfg is already present
786 * in user_pins[], don't write it
788 cfg = snd_hda_codec_get_pincfg(codec, nid);
790 set_pincfg(codec, nid, cfg);
794 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
795 hda_nid_t nid, unsigned int cfg)
797 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
799 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
801 /* get the current pin config value of the given pin NID */
802 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
804 struct hda_pincfg *pin;
806 #ifdef CONFIG_SND_HDA_HWDEP
807 pin = look_up_pincfg(codec, &codec->user_pins, nid);
811 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
814 pin = look_up_pincfg(codec, &codec->init_pins, nid);
819 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
821 /* restore all current pin configs */
822 static void restore_pincfgs(struct hda_codec *codec)
825 for (i = 0; i < codec->init_pins.used; i++) {
826 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
827 set_pincfg(codec, pin->nid,
828 snd_hda_codec_get_pincfg(codec, pin->nid));
832 static void init_hda_cache(struct hda_cache_rec *cache,
833 unsigned int record_size);
834 static void free_hda_cache(struct hda_cache_rec *cache);
836 /* restore the initial pin cfgs and release all pincfg lists */
837 static void restore_init_pincfgs(struct hda_codec *codec)
839 /* first free driver_pins and user_pins, then call restore_pincfg
840 * so that only the values in init_pins are restored
842 snd_array_free(&codec->driver_pins);
843 #ifdef CONFIG_SND_HDA_HWDEP
844 snd_array_free(&codec->user_pins);
846 restore_pincfgs(codec);
847 snd_array_free(&codec->init_pins);
853 static void snd_hda_codec_free(struct hda_codec *codec)
857 restore_init_pincfgs(codec);
858 #ifdef CONFIG_SND_HDA_POWER_SAVE
859 cancel_delayed_work(&codec->power_work);
860 flush_workqueue(codec->bus->workq);
862 list_del(&codec->list);
863 snd_array_free(&codec->mixers);
864 codec->bus->caddr_tbl[codec->addr] = NULL;
865 if (codec->patch_ops.free)
866 codec->patch_ops.free(codec);
867 module_put(codec->owner);
868 free_hda_cache(&codec->amp_cache);
869 free_hda_cache(&codec->cmd_cache);
870 kfree(codec->vendor_name);
871 kfree(codec->chip_name);
872 kfree(codec->modelname);
877 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
878 unsigned int power_state);
881 * snd_hda_codec_new - create a HDA codec
882 * @bus: the bus to assign
883 * @codec_addr: the codec address
884 * @codecp: the pointer to store the generated codec
886 * Returns 0 if successful, or a negative error code.
888 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
889 struct hda_codec **codecp)
891 struct hda_codec *codec;
895 if (snd_BUG_ON(!bus))
897 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
900 if (bus->caddr_tbl[codec_addr]) {
901 snd_printk(KERN_ERR "hda_codec: "
902 "address 0x%x is already occupied\n", codec_addr);
906 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
908 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
913 codec->addr = codec_addr;
914 mutex_init(&codec->spdif_mutex);
915 mutex_init(&codec->control_mutex);
916 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
917 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
918 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
919 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
920 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
921 if (codec->bus->modelname) {
922 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
923 if (!codec->modelname) {
924 snd_hda_codec_free(codec);
929 #ifdef CONFIG_SND_HDA_POWER_SAVE
930 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
931 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
932 * the caller has to power down appropriatley after initialization
935 hda_keep_power_on(codec);
938 list_add_tail(&codec->list, &bus->codec_list);
939 bus->caddr_tbl[codec_addr] = codec;
941 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
943 if (codec->vendor_id == -1)
944 /* read again, hopefully the access method was corrected
945 * in the last read...
947 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
949 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
950 AC_PAR_SUBSYSTEM_ID);
951 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
954 setup_fg_nodes(codec);
955 if (!codec->afg && !codec->mfg) {
956 snd_printdd("hda_codec: no AFG or MFG node found\n");
961 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
963 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
966 err = read_pin_defaults(codec);
970 if (!codec->subsystem_id) {
971 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
972 codec->subsystem_id =
973 snd_hda_codec_read(codec, nid, 0,
974 AC_VERB_GET_SUBSYSTEM_ID, 0);
977 /* power-up all before initialization */
978 hda_set_power_state(codec,
979 codec->afg ? codec->afg : codec->mfg,
982 snd_hda_codec_proc_new(codec);
984 snd_hda_create_hwdep(codec);
986 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
987 codec->subsystem_id, codec->revision_id);
988 snd_component_add(codec->bus->card, component);
995 snd_hda_codec_free(codec);
998 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1000 int snd_hda_codec_configure(struct hda_codec *codec)
1004 codec->preset = find_codec_preset(codec);
1005 if (!codec->vendor_name || !codec->chip_name) {
1006 err = get_codec_name(codec);
1010 /* audio codec should override the mixer name */
1011 if (codec->afg || !*codec->bus->card->mixername)
1012 snprintf(codec->bus->card->mixername,
1013 sizeof(codec->bus->card->mixername),
1014 "%s %s", codec->vendor_name, codec->chip_name);
1016 if (is_generic_config(codec)) {
1017 err = snd_hda_parse_generic_codec(codec);
1020 if (codec->preset && codec->preset->patch) {
1021 err = codec->preset->patch(codec);
1025 /* call the default parser */
1026 err = snd_hda_parse_generic_codec(codec);
1028 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1031 if (!err && codec->patch_ops.unsol_event)
1032 err = init_unsol_queue(codec->bus);
1035 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1038 * snd_hda_codec_setup_stream - set up the codec for streaming
1039 * @codec: the CODEC to set up
1040 * @nid: the NID to set up
1041 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1042 * @channel_id: channel id to pass, zero based.
1043 * @format: stream format.
1045 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1047 int channel_id, int format)
1052 snd_printdd("hda_codec_setup_stream: "
1053 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1054 nid, stream_tag, channel_id, format);
1055 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1056 (stream_tag << 4) | channel_id);
1058 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1060 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1062 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1067 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1068 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1069 #if 0 /* keep the format */
1071 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1074 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
1077 * amp access functions
1080 /* FIXME: more better hash key? */
1081 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1082 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1083 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1084 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1085 #define INFO_AMP_CAPS (1<<0)
1086 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1088 /* initialize the hash table */
1089 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1090 unsigned int record_size)
1092 memset(cache, 0, sizeof(*cache));
1093 memset(cache->hash, 0xff, sizeof(cache->hash));
1094 snd_array_init(&cache->buf, record_size, 64);
1097 static void free_hda_cache(struct hda_cache_rec *cache)
1099 snd_array_free(&cache->buf);
1102 /* query the hash. allocate an entry if not found. */
1103 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1106 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1107 u16 cur = cache->hash[idx];
1108 struct hda_cache_head *info;
1110 while (cur != 0xffff) {
1111 info = snd_array_elem(&cache->buf, cur);
1112 if (info->key == key)
1117 /* add a new hash entry */
1118 info = snd_array_new(&cache->buf);
1121 cur = snd_array_index(&cache->buf, info);
1124 info->next = cache->hash[idx];
1125 cache->hash[idx] = cur;
1130 /* query and allocate an amp hash entry */
1131 static inline struct hda_amp_info *
1132 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1134 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1138 * query AMP capabilities for the given widget and direction
1140 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1142 struct hda_amp_info *info;
1144 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1147 if (!(info->head.val & INFO_AMP_CAPS)) {
1148 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1150 info->amp_caps = snd_hda_param_read(codec, nid,
1151 direction == HDA_OUTPUT ?
1152 AC_PAR_AMP_OUT_CAP :
1155 info->head.val |= INFO_AMP_CAPS;
1157 return info->amp_caps;
1159 EXPORT_SYMBOL_HDA(query_amp_caps);
1161 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1164 struct hda_amp_info *info;
1166 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1169 info->amp_caps = caps;
1170 info->head.val |= INFO_AMP_CAPS;
1173 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1176 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1177 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1179 struct hda_amp_info *info;
1181 info = get_alloc_amp_hash(codec, key);
1184 if (!info->head.val) {
1185 info->head.val |= INFO_AMP_CAPS;
1186 info->amp_caps = func(codec, nid);
1188 return info->amp_caps;
1191 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1193 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1196 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1198 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1201 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1204 * read the current volume to info
1205 * if the cache exists, read the cache value.
1207 static unsigned int get_vol_mute(struct hda_codec *codec,
1208 struct hda_amp_info *info, hda_nid_t nid,
1209 int ch, int direction, int index)
1213 if (info->head.val & INFO_AMP_VOL(ch))
1214 return info->vol[ch];
1216 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1217 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1219 val = snd_hda_codec_read(codec, nid, 0,
1220 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1221 info->vol[ch] = val & 0xff;
1222 info->head.val |= INFO_AMP_VOL(ch);
1223 return info->vol[ch];
1227 * write the current volume in info to the h/w and update the cache
1229 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1230 hda_nid_t nid, int ch, int direction, int index,
1235 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1236 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1237 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1239 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1240 info->vol[ch] = val;
1244 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1246 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1247 int direction, int index)
1249 struct hda_amp_info *info;
1250 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1253 return get_vol_mute(codec, info, nid, ch, direction, index);
1255 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1258 * update the AMP value, mask = bit mask to set, val = the value
1260 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1261 int direction, int idx, int mask, int val)
1263 struct hda_amp_info *info;
1265 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1269 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1270 if (info->vol[ch] == val)
1272 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1275 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1278 * update the AMP stereo with the same mask and value
1280 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1281 int direction, int idx, int mask, int val)
1284 for (ch = 0; ch < 2; ch++)
1285 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1289 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1291 #ifdef SND_HDA_NEEDS_RESUME
1292 /* resume the all amp commands from the cache */
1293 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1295 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1298 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1299 u32 key = buffer->head.key;
1301 unsigned int idx, dir, ch;
1305 idx = (key >> 16) & 0xff;
1306 dir = (key >> 24) & 0xff;
1307 for (ch = 0; ch < 2; ch++) {
1308 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1310 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1315 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1316 #endif /* SND_HDA_NEEDS_RESUME */
1319 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1320 struct snd_ctl_elem_info *uinfo)
1322 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1323 u16 nid = get_amp_nid(kcontrol);
1324 u8 chs = get_amp_channels(kcontrol);
1325 int dir = get_amp_direction(kcontrol);
1326 unsigned int ofs = get_amp_offset(kcontrol);
1329 caps = query_amp_caps(codec, nid, dir);
1331 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1333 printk(KERN_WARNING "hda_codec: "
1334 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1340 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1341 uinfo->count = chs == 3 ? 2 : 1;
1342 uinfo->value.integer.min = 0;
1343 uinfo->value.integer.max = caps;
1346 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1349 static inline unsigned int
1350 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1351 int ch, int dir, int idx, unsigned int ofs)
1354 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1355 val &= HDA_AMP_VOLMASK;
1364 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1365 int ch, int dir, int idx, unsigned int ofs,
1370 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1371 HDA_AMP_VOLMASK, val);
1374 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1375 struct snd_ctl_elem_value *ucontrol)
1377 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1378 hda_nid_t nid = get_amp_nid(kcontrol);
1379 int chs = get_amp_channels(kcontrol);
1380 int dir = get_amp_direction(kcontrol);
1381 int idx = get_amp_index(kcontrol);
1382 unsigned int ofs = get_amp_offset(kcontrol);
1383 long *valp = ucontrol->value.integer.value;
1386 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1388 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1391 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1393 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1394 struct snd_ctl_elem_value *ucontrol)
1396 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1397 hda_nid_t nid = get_amp_nid(kcontrol);
1398 int chs = get_amp_channels(kcontrol);
1399 int dir = get_amp_direction(kcontrol);
1400 int idx = get_amp_index(kcontrol);
1401 unsigned int ofs = get_amp_offset(kcontrol);
1402 long *valp = ucontrol->value.integer.value;
1405 snd_hda_power_up(codec);
1407 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1411 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1412 snd_hda_power_down(codec);
1415 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1417 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1418 unsigned int size, unsigned int __user *_tlv)
1420 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1421 hda_nid_t nid = get_amp_nid(kcontrol);
1422 int dir = get_amp_direction(kcontrol);
1423 unsigned int ofs = get_amp_offset(kcontrol);
1424 u32 caps, val1, val2;
1426 if (size < 4 * sizeof(unsigned int))
1428 caps = query_amp_caps(codec, nid, dir);
1429 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1430 val2 = (val2 + 1) * 25;
1431 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1433 val1 = ((int)val1) * ((int)val2);
1434 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1436 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1438 if (put_user(val1, _tlv + 2))
1440 if (put_user(val2, _tlv + 3))
1444 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1447 * set (static) TLV for virtual master volume; recalculated as max 0dB
1449 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1455 caps = query_amp_caps(codec, nid, dir);
1456 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1457 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1458 step = (step + 1) * 25;
1459 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1460 tlv[1] = 2 * sizeof(unsigned int);
1461 tlv[2] = -nums * step;
1464 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1466 /* find a mixer control element with the given name */
1467 static struct snd_kcontrol *
1468 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1469 const char *name, int idx)
1471 struct snd_ctl_elem_id id;
1472 memset(&id, 0, sizeof(id));
1473 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1475 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1477 strcpy(id.name, name);
1478 return snd_ctl_find_id(codec->bus->card, &id);
1481 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1484 return _snd_hda_find_mixer_ctl(codec, name, 0);
1486 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1488 /* Add a control element and assign to the codec */
1489 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1492 struct snd_kcontrol **knewp;
1494 err = snd_ctl_add(codec->bus->card, kctl);
1497 knewp = snd_array_new(&codec->mixers);
1503 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1505 /* Clear all controls assigned to the given codec */
1506 void snd_hda_ctls_clear(struct hda_codec *codec)
1509 struct snd_kcontrol **kctls = codec->mixers.list;
1510 for (i = 0; i < codec->mixers.used; i++)
1511 snd_ctl_remove(codec->bus->card, kctls[i]);
1512 snd_array_free(&codec->mixers);
1515 /* pseudo device locking
1516 * toggle card->shutdown to allow/disallow the device access (as a hack)
1518 static int hda_lock_devices(struct snd_card *card)
1520 spin_lock(&card->files_lock);
1521 if (card->shutdown) {
1522 spin_unlock(&card->files_lock);
1526 spin_unlock(&card->files_lock);
1530 static void hda_unlock_devices(struct snd_card *card)
1532 spin_lock(&card->files_lock);
1534 spin_unlock(&card->files_lock);
1537 int snd_hda_codec_reset(struct hda_codec *codec)
1539 struct snd_card *card = codec->bus->card;
1542 if (hda_lock_devices(card) < 0)
1544 /* check whether the codec isn't used by any mixer or PCM streams */
1545 if (!list_empty(&card->ctl_files)) {
1546 hda_unlock_devices(card);
1549 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1550 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1553 if (cpcm->pcm->streams[0].substream_opened ||
1554 cpcm->pcm->streams[1].substream_opened) {
1555 hda_unlock_devices(card);
1560 /* OK, let it free */
1562 #ifdef CONFIG_SND_HDA_POWER_SAVE
1563 cancel_delayed_work(&codec->power_work);
1564 flush_workqueue(codec->bus->workq);
1566 snd_hda_ctls_clear(codec);
1568 for (i = 0; i < codec->num_pcms; i++) {
1569 if (codec->pcm_info[i].pcm) {
1570 snd_device_free(card, codec->pcm_info[i].pcm);
1571 clear_bit(codec->pcm_info[i].device,
1572 codec->bus->pcm_dev_bits);
1575 if (codec->patch_ops.free)
1576 codec->patch_ops.free(codec);
1577 codec->proc_widget_hook = NULL;
1579 free_hda_cache(&codec->amp_cache);
1580 free_hda_cache(&codec->cmd_cache);
1581 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1582 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1583 /* free only driver_pins so that init_pins + user_pins are restored */
1584 snd_array_free(&codec->driver_pins);
1585 restore_pincfgs(codec);
1586 codec->num_pcms = 0;
1587 codec->pcm_info = NULL;
1588 codec->preset = NULL;
1589 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1590 codec->slave_dig_outs = NULL;
1591 codec->spdif_status_reset = 0;
1592 module_put(codec->owner);
1593 codec->owner = NULL;
1595 /* allow device access again */
1596 hda_unlock_devices(card);
1600 /* create a virtual master control and add slaves */
1601 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1602 unsigned int *tlv, const char **slaves)
1604 struct snd_kcontrol *kctl;
1608 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1611 snd_printdd("No slave found for %s\n", name);
1614 kctl = snd_ctl_make_virtual_master(name, tlv);
1617 err = snd_hda_ctl_add(codec, kctl);
1621 for (s = slaves; *s; s++) {
1622 struct snd_kcontrol *sctl;
1625 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1628 snd_printdd("Cannot find slave %s, "
1632 err = snd_ctl_add_slave(kctl, sctl);
1640 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1643 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1644 struct snd_ctl_elem_info *uinfo)
1646 int chs = get_amp_channels(kcontrol);
1648 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1649 uinfo->count = chs == 3 ? 2 : 1;
1650 uinfo->value.integer.min = 0;
1651 uinfo->value.integer.max = 1;
1654 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1656 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1657 struct snd_ctl_elem_value *ucontrol)
1659 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1660 hda_nid_t nid = get_amp_nid(kcontrol);
1661 int chs = get_amp_channels(kcontrol);
1662 int dir = get_amp_direction(kcontrol);
1663 int idx = get_amp_index(kcontrol);
1664 long *valp = ucontrol->value.integer.value;
1667 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1668 HDA_AMP_MUTE) ? 0 : 1;
1670 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1671 HDA_AMP_MUTE) ? 0 : 1;
1674 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1676 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1677 struct snd_ctl_elem_value *ucontrol)
1679 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1680 hda_nid_t nid = get_amp_nid(kcontrol);
1681 int chs = get_amp_channels(kcontrol);
1682 int dir = get_amp_direction(kcontrol);
1683 int idx = get_amp_index(kcontrol);
1684 long *valp = ucontrol->value.integer.value;
1687 snd_hda_power_up(codec);
1689 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1691 *valp ? 0 : HDA_AMP_MUTE);
1695 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1697 *valp ? 0 : HDA_AMP_MUTE);
1698 #ifdef CONFIG_SND_HDA_POWER_SAVE
1699 if (codec->patch_ops.check_power_status)
1700 codec->patch_ops.check_power_status(codec, nid);
1702 snd_hda_power_down(codec);
1705 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1708 * bound volume controls
1710 * bind multiple volumes (# indices, from 0)
1713 #define AMP_VAL_IDX_SHIFT 19
1714 #define AMP_VAL_IDX_MASK (0x0f<<19)
1716 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1717 struct snd_ctl_elem_value *ucontrol)
1719 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1723 mutex_lock(&codec->control_mutex);
1724 pval = kcontrol->private_value;
1725 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1726 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1727 kcontrol->private_value = pval;
1728 mutex_unlock(&codec->control_mutex);
1731 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1733 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1734 struct snd_ctl_elem_value *ucontrol)
1736 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1738 int i, indices, err = 0, change = 0;
1740 mutex_lock(&codec->control_mutex);
1741 pval = kcontrol->private_value;
1742 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1743 for (i = 0; i < indices; i++) {
1744 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1745 (i << AMP_VAL_IDX_SHIFT);
1746 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1751 kcontrol->private_value = pval;
1752 mutex_unlock(&codec->control_mutex);
1753 return err < 0 ? err : change;
1755 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1758 * generic bound volume/swtich controls
1760 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1761 struct snd_ctl_elem_info *uinfo)
1763 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1764 struct hda_bind_ctls *c;
1767 mutex_lock(&codec->control_mutex);
1768 c = (struct hda_bind_ctls *)kcontrol->private_value;
1769 kcontrol->private_value = *c->values;
1770 err = c->ops->info(kcontrol, uinfo);
1771 kcontrol->private_value = (long)c;
1772 mutex_unlock(&codec->control_mutex);
1775 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1777 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1778 struct snd_ctl_elem_value *ucontrol)
1780 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1781 struct hda_bind_ctls *c;
1784 mutex_lock(&codec->control_mutex);
1785 c = (struct hda_bind_ctls *)kcontrol->private_value;
1786 kcontrol->private_value = *c->values;
1787 err = c->ops->get(kcontrol, ucontrol);
1788 kcontrol->private_value = (long)c;
1789 mutex_unlock(&codec->control_mutex);
1792 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1794 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1795 struct snd_ctl_elem_value *ucontrol)
1797 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1798 struct hda_bind_ctls *c;
1799 unsigned long *vals;
1800 int err = 0, change = 0;
1802 mutex_lock(&codec->control_mutex);
1803 c = (struct hda_bind_ctls *)kcontrol->private_value;
1804 for (vals = c->values; *vals; vals++) {
1805 kcontrol->private_value = *vals;
1806 err = c->ops->put(kcontrol, ucontrol);
1811 kcontrol->private_value = (long)c;
1812 mutex_unlock(&codec->control_mutex);
1813 return err < 0 ? err : change;
1815 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1817 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1818 unsigned int size, unsigned int __user *tlv)
1820 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1821 struct hda_bind_ctls *c;
1824 mutex_lock(&codec->control_mutex);
1825 c = (struct hda_bind_ctls *)kcontrol->private_value;
1826 kcontrol->private_value = *c->values;
1827 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1828 kcontrol->private_value = (long)c;
1829 mutex_unlock(&codec->control_mutex);
1832 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1834 struct hda_ctl_ops snd_hda_bind_vol = {
1835 .info = snd_hda_mixer_amp_volume_info,
1836 .get = snd_hda_mixer_amp_volume_get,
1837 .put = snd_hda_mixer_amp_volume_put,
1838 .tlv = snd_hda_mixer_amp_tlv
1840 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1842 struct hda_ctl_ops snd_hda_bind_sw = {
1843 .info = snd_hda_mixer_amp_switch_info,
1844 .get = snd_hda_mixer_amp_switch_get,
1845 .put = snd_hda_mixer_amp_switch_put,
1846 .tlv = snd_hda_mixer_amp_tlv
1848 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1851 * SPDIF out controls
1854 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1855 struct snd_ctl_elem_info *uinfo)
1857 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1862 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1863 struct snd_ctl_elem_value *ucontrol)
1865 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1866 IEC958_AES0_NONAUDIO |
1867 IEC958_AES0_CON_EMPHASIS_5015 |
1868 IEC958_AES0_CON_NOT_COPYRIGHT;
1869 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1870 IEC958_AES1_CON_ORIGINAL;
1874 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1875 struct snd_ctl_elem_value *ucontrol)
1877 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1878 IEC958_AES0_NONAUDIO |
1879 IEC958_AES0_PRO_EMPHASIS_5015;
1883 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1884 struct snd_ctl_elem_value *ucontrol)
1886 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1888 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1889 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1890 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1891 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1896 /* convert from SPDIF status bits to HDA SPDIF bits
1897 * bit 0 (DigEn) is always set zero (to be filled later)
1899 static unsigned short convert_from_spdif_status(unsigned int sbits)
1901 unsigned short val = 0;
1903 if (sbits & IEC958_AES0_PROFESSIONAL)
1904 val |= AC_DIG1_PROFESSIONAL;
1905 if (sbits & IEC958_AES0_NONAUDIO)
1906 val |= AC_DIG1_NONAUDIO;
1907 if (sbits & IEC958_AES0_PROFESSIONAL) {
1908 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1909 IEC958_AES0_PRO_EMPHASIS_5015)
1910 val |= AC_DIG1_EMPHASIS;
1912 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1913 IEC958_AES0_CON_EMPHASIS_5015)
1914 val |= AC_DIG1_EMPHASIS;
1915 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1916 val |= AC_DIG1_COPYRIGHT;
1917 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1918 val |= AC_DIG1_LEVEL;
1919 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1924 /* convert to SPDIF status bits from HDA SPDIF bits
1926 static unsigned int convert_to_spdif_status(unsigned short val)
1928 unsigned int sbits = 0;
1930 if (val & AC_DIG1_NONAUDIO)
1931 sbits |= IEC958_AES0_NONAUDIO;
1932 if (val & AC_DIG1_PROFESSIONAL)
1933 sbits |= IEC958_AES0_PROFESSIONAL;
1934 if (sbits & IEC958_AES0_PROFESSIONAL) {
1935 if (sbits & AC_DIG1_EMPHASIS)
1936 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1938 if (val & AC_DIG1_EMPHASIS)
1939 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1940 if (!(val & AC_DIG1_COPYRIGHT))
1941 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1942 if (val & AC_DIG1_LEVEL)
1943 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1944 sbits |= val & (0x7f << 8);
1949 /* set digital convert verbs both for the given NID and its slaves */
1950 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1955 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1956 d = codec->slave_dig_outs;
1960 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1963 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1967 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1969 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1972 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1973 struct snd_ctl_elem_value *ucontrol)
1975 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1976 hda_nid_t nid = kcontrol->private_value;
1980 mutex_lock(&codec->spdif_mutex);
1981 codec->spdif_status = ucontrol->value.iec958.status[0] |
1982 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1983 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1984 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1985 val = convert_from_spdif_status(codec->spdif_status);
1986 val |= codec->spdif_ctls & 1;
1987 change = codec->spdif_ctls != val;
1988 codec->spdif_ctls = val;
1991 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1993 mutex_unlock(&codec->spdif_mutex);
1997 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1999 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2000 struct snd_ctl_elem_value *ucontrol)
2002 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2004 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
2008 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2009 struct snd_ctl_elem_value *ucontrol)
2011 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2012 hda_nid_t nid = kcontrol->private_value;
2016 mutex_lock(&codec->spdif_mutex);
2017 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2018 if (ucontrol->value.integer.value[0])
2019 val |= AC_DIG1_ENABLE;
2020 change = codec->spdif_ctls != val;
2022 codec->spdif_ctls = val;
2023 set_dig_out_convert(codec, nid, val & 0xff, -1);
2024 /* unmute amp switch (if any) */
2025 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2026 (val & AC_DIG1_ENABLE))
2027 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2030 mutex_unlock(&codec->spdif_mutex);
2034 static struct snd_kcontrol_new dig_mixes[] = {
2036 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2037 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2038 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2039 .info = snd_hda_spdif_mask_info,
2040 .get = snd_hda_spdif_cmask_get,
2043 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2044 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2045 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2046 .info = snd_hda_spdif_mask_info,
2047 .get = snd_hda_spdif_pmask_get,
2050 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2051 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2052 .info = snd_hda_spdif_mask_info,
2053 .get = snd_hda_spdif_default_get,
2054 .put = snd_hda_spdif_default_put,
2057 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2058 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2059 .info = snd_hda_spdif_out_switch_info,
2060 .get = snd_hda_spdif_out_switch_get,
2061 .put = snd_hda_spdif_out_switch_put,
2066 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2069 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2070 * @codec: the HDA codec
2071 * @nid: audio out widget NID
2073 * Creates controls related with the SPDIF output.
2074 * Called from each patch supporting the SPDIF out.
2076 * Returns 0 if successful, or a negative error code.
2078 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2081 struct snd_kcontrol *kctl;
2082 struct snd_kcontrol_new *dig_mix;
2085 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2086 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2090 if (idx >= SPDIF_MAX_IDX) {
2091 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2094 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2095 kctl = snd_ctl_new1(dig_mix, codec);
2098 kctl->id.index = idx;
2099 kctl->private_value = nid;
2100 err = snd_hda_ctl_add(codec, kctl);
2105 snd_hda_codec_read(codec, nid, 0,
2106 AC_VERB_GET_DIGI_CONVERT_1, 0);
2107 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2110 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2113 * SPDIF sharing with analog output
2115 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2116 struct snd_ctl_elem_value *ucontrol)
2118 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2119 ucontrol->value.integer.value[0] = mout->share_spdif;
2123 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2124 struct snd_ctl_elem_value *ucontrol)
2126 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2127 mout->share_spdif = !!ucontrol->value.integer.value[0];
2131 static struct snd_kcontrol_new spdif_share_sw = {
2132 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2133 .name = "IEC958 Default PCM Playback Switch",
2134 .info = snd_ctl_boolean_mono_info,
2135 .get = spdif_share_sw_get,
2136 .put = spdif_share_sw_put,
2139 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2140 struct hda_multi_out *mout)
2142 if (!mout->dig_out_nid)
2144 /* ATTENTION: here mout is passed as private_data, instead of codec */
2145 return snd_hda_ctl_add(codec,
2146 snd_ctl_new1(&spdif_share_sw, mout));
2148 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2154 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2156 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2157 struct snd_ctl_elem_value *ucontrol)
2159 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2161 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2165 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2166 struct snd_ctl_elem_value *ucontrol)
2168 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2169 hda_nid_t nid = kcontrol->private_value;
2170 unsigned int val = !!ucontrol->value.integer.value[0];
2173 mutex_lock(&codec->spdif_mutex);
2174 change = codec->spdif_in_enable != val;
2176 codec->spdif_in_enable = val;
2177 snd_hda_codec_write_cache(codec, nid, 0,
2178 AC_VERB_SET_DIGI_CONVERT_1, val);
2180 mutex_unlock(&codec->spdif_mutex);
2184 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2185 struct snd_ctl_elem_value *ucontrol)
2187 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2188 hda_nid_t nid = kcontrol->private_value;
2192 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2193 sbits = convert_to_spdif_status(val);
2194 ucontrol->value.iec958.status[0] = sbits;
2195 ucontrol->value.iec958.status[1] = sbits >> 8;
2196 ucontrol->value.iec958.status[2] = sbits >> 16;
2197 ucontrol->value.iec958.status[3] = sbits >> 24;
2201 static struct snd_kcontrol_new dig_in_ctls[] = {
2203 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2204 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2205 .info = snd_hda_spdif_in_switch_info,
2206 .get = snd_hda_spdif_in_switch_get,
2207 .put = snd_hda_spdif_in_switch_put,
2210 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2211 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2212 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2213 .info = snd_hda_spdif_mask_info,
2214 .get = snd_hda_spdif_in_status_get,
2220 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2221 * @codec: the HDA codec
2222 * @nid: audio in widget NID
2224 * Creates controls related with the SPDIF input.
2225 * Called from each patch supporting the SPDIF in.
2227 * Returns 0 if successful, or a negative error code.
2229 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2232 struct snd_kcontrol *kctl;
2233 struct snd_kcontrol_new *dig_mix;
2236 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2237 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2241 if (idx >= SPDIF_MAX_IDX) {
2242 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2245 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2246 kctl = snd_ctl_new1(dig_mix, codec);
2249 kctl->private_value = nid;
2250 err = snd_hda_ctl_add(codec, kctl);
2254 codec->spdif_in_enable =
2255 snd_hda_codec_read(codec, nid, 0,
2256 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2260 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2262 #ifdef SND_HDA_NEEDS_RESUME
2267 /* build a 32bit cache key with the widget id and the command parameter */
2268 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2269 #define get_cmd_cache_nid(key) ((key) & 0xff)
2270 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2273 * snd_hda_codec_write_cache - send a single command with caching
2274 * @codec: the HDA codec
2275 * @nid: NID to send the command
2276 * @direct: direct flag
2277 * @verb: the verb to send
2278 * @parm: the parameter for the verb
2280 * Send a single command without waiting for response.
2282 * Returns 0 if successful, or a negative error code.
2284 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2285 int direct, unsigned int verb, unsigned int parm)
2287 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2288 struct hda_cache_head *c;
2293 /* parm may contain the verb stuff for get/set amp */
2294 verb = verb | (parm >> 8);
2296 key = build_cmd_cache_key(nid, verb);
2297 mutex_lock(&codec->bus->cmd_mutex);
2298 c = get_alloc_hash(&codec->cmd_cache, key);
2301 mutex_unlock(&codec->bus->cmd_mutex);
2304 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2306 /* resume the all commands from the cache */
2307 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2309 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2312 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2313 u32 key = buffer->key;
2316 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2317 get_cmd_cache_cmd(key), buffer->val);
2320 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2323 * snd_hda_sequence_write_cache - sequence writes with caching
2324 * @codec: the HDA codec
2325 * @seq: VERB array to send
2327 * Send the commands sequentially from the given array.
2328 * Thte commands are recorded on cache for power-save and resume.
2329 * The array must be terminated with NID=0.
2331 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2332 const struct hda_verb *seq)
2334 for (; seq->nid; seq++)
2335 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2338 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2339 #endif /* SND_HDA_NEEDS_RESUME */
2342 * set power state of the codec
2344 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2345 unsigned int power_state)
2350 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2352 msleep(10); /* partial workaround for "azx_get_response timeout" */
2354 nid = codec->start_nid;
2355 for (i = 0; i < codec->num_nodes; i++, nid++) {
2356 unsigned int wcaps = get_wcaps(codec, nid);
2357 if (wcaps & AC_WCAP_POWER) {
2358 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2360 if (power_state == AC_PWRST_D3 &&
2361 wid_type == AC_WID_PIN) {
2362 unsigned int pincap;
2364 * don't power down the widget if it controls
2365 * eapd and EAPD_BTLENABLE is set.
2367 pincap = snd_hda_query_pin_caps(codec, nid);
2368 if (pincap & AC_PINCAP_EAPD) {
2369 int eapd = snd_hda_codec_read(codec,
2371 AC_VERB_GET_EAPD_BTLENABLE, 0);
2377 snd_hda_codec_write(codec, nid, 0,
2378 AC_VERB_SET_POWER_STATE,
2383 if (power_state == AC_PWRST_D0) {
2384 unsigned long end_time;
2387 /* wait until the codec reachs to D0 */
2388 end_time = jiffies + msecs_to_jiffies(500);
2390 state = snd_hda_codec_read(codec, fg, 0,
2391 AC_VERB_GET_POWER_STATE, 0);
2392 if (state == power_state)
2395 } while (time_after_eq(end_time, jiffies));
2399 #ifdef CONFIG_SND_HDA_HWDEP
2400 /* execute additional init verbs */
2401 static void hda_exec_init_verbs(struct hda_codec *codec)
2403 if (codec->init_verbs.list)
2404 snd_hda_sequence_write(codec, codec->init_verbs.list);
2407 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2410 #ifdef SND_HDA_NEEDS_RESUME
2412 * call suspend and power-down; used both from PM and power-save
2414 static void hda_call_codec_suspend(struct hda_codec *codec)
2416 if (codec->patch_ops.suspend)
2417 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2418 hda_set_power_state(codec,
2419 codec->afg ? codec->afg : codec->mfg,
2421 #ifdef CONFIG_SND_HDA_POWER_SAVE
2422 cancel_delayed_work(&codec->power_work);
2423 codec->power_on = 0;
2424 codec->power_transition = 0;
2429 * kick up codec; used both from PM and power-save
2431 static void hda_call_codec_resume(struct hda_codec *codec)
2433 hda_set_power_state(codec,
2434 codec->afg ? codec->afg : codec->mfg,
2436 restore_pincfgs(codec); /* restore all current pin configs */
2437 hda_exec_init_verbs(codec);
2438 if (codec->patch_ops.resume)
2439 codec->patch_ops.resume(codec);
2441 if (codec->patch_ops.init)
2442 codec->patch_ops.init(codec);
2443 snd_hda_codec_resume_amp(codec);
2444 snd_hda_codec_resume_cache(codec);
2447 #endif /* SND_HDA_NEEDS_RESUME */
2451 * snd_hda_build_controls - build mixer controls
2454 * Creates mixer controls for each codec included in the bus.
2456 * Returns 0 if successful, otherwise a negative error code.
2458 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2460 struct hda_codec *codec;
2462 list_for_each_entry(codec, &bus->codec_list, list) {
2463 int err = snd_hda_codec_build_controls(codec);
2465 printk(KERN_ERR "hda_codec: cannot build controls"
2466 "for #%d (error %d)\n", codec->addr, err);
2467 err = snd_hda_codec_reset(codec);
2470 "hda_codec: cannot revert codec\n");
2477 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2479 int snd_hda_codec_build_controls(struct hda_codec *codec)
2482 hda_exec_init_verbs(codec);
2483 /* continue to initialize... */
2484 if (codec->patch_ops.init)
2485 err = codec->patch_ops.init(codec);
2486 if (!err && codec->patch_ops.build_controls)
2487 err = codec->patch_ops.build_controls(codec);
2496 struct hda_rate_tbl {
2498 unsigned int alsa_bits;
2499 unsigned int hda_fmt;
2502 static struct hda_rate_tbl rate_bits[] = {
2503 /* rate in Hz, ALSA rate bitmask, HDA format value */
2505 /* autodetected value used in snd_hda_query_supported_pcm */
2506 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2507 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2508 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2509 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2510 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2511 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2512 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2513 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2514 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2515 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2516 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2517 #define AC_PAR_PCM_RATE_BITS 11
2518 /* up to bits 10, 384kHZ isn't supported properly */
2520 /* not autodetected value */
2521 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2523 { 0 } /* terminator */
2527 * snd_hda_calc_stream_format - calculate format bitset
2528 * @rate: the sample rate
2529 * @channels: the number of channels
2530 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2531 * @maxbps: the max. bps
2533 * Calculate the format bitset from the given rate, channels and th PCM format.
2535 * Return zero if invalid.
2537 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2538 unsigned int channels,
2539 unsigned int format,
2540 unsigned int maxbps)
2543 unsigned int val = 0;
2545 for (i = 0; rate_bits[i].hz; i++)
2546 if (rate_bits[i].hz == rate) {
2547 val = rate_bits[i].hda_fmt;
2550 if (!rate_bits[i].hz) {
2551 snd_printdd("invalid rate %d\n", rate);
2555 if (channels == 0 || channels > 8) {
2556 snd_printdd("invalid channels %d\n", channels);
2559 val |= channels - 1;
2561 switch (snd_pcm_format_width(format)) {
2562 case 8: val |= 0x00; break;
2563 case 16: val |= 0x10; break;
2569 else if (maxbps >= 24)
2575 snd_printdd("invalid format width %d\n",
2576 snd_pcm_format_width(format));
2582 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2584 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2586 unsigned int val = 0;
2587 if (nid != codec->afg &&
2588 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2589 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2590 if (!val || val == -1)
2591 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2592 if (!val || val == -1)
2597 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2599 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2603 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2605 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2606 if (!streams || streams == -1)
2607 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2608 if (!streams || streams == -1)
2613 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2615 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2620 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2621 * @codec: the HDA codec
2622 * @nid: NID to query
2623 * @ratesp: the pointer to store the detected rate bitflags
2624 * @formatsp: the pointer to store the detected formats
2625 * @bpsp: the pointer to store the detected format widths
2627 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2628 * or @bsps argument is ignored.
2630 * Returns 0 if successful, otherwise a negative error code.
2632 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2633 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2635 unsigned int i, val, wcaps;
2637 wcaps = get_wcaps(codec, nid);
2638 val = query_pcm_param(codec, nid);
2642 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2644 rates |= rate_bits[i].alsa_bits;
2647 snd_printk(KERN_ERR "hda_codec: rates == 0 "
2648 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2650 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2656 if (formatsp || bpsp) {
2658 unsigned int streams, bps;
2660 streams = query_stream_param(codec, nid);
2665 if (streams & AC_SUPFMT_PCM) {
2666 if (val & AC_SUPPCM_BITS_8) {
2667 formats |= SNDRV_PCM_FMTBIT_U8;
2670 if (val & AC_SUPPCM_BITS_16) {
2671 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2674 if (wcaps & AC_WCAP_DIGITAL) {
2675 if (val & AC_SUPPCM_BITS_32)
2676 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2677 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2678 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2679 if (val & AC_SUPPCM_BITS_24)
2681 else if (val & AC_SUPPCM_BITS_20)
2683 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2684 AC_SUPPCM_BITS_32)) {
2685 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2686 if (val & AC_SUPPCM_BITS_32)
2688 else if (val & AC_SUPPCM_BITS_24)
2690 else if (val & AC_SUPPCM_BITS_20)
2694 if (streams & AC_SUPFMT_FLOAT32) {
2695 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2698 if (streams == AC_SUPFMT_AC3) {
2699 /* should be exclusive */
2700 /* temporary hack: we have still no proper support
2701 * for the direct AC3 stream...
2703 formats |= SNDRV_PCM_FMTBIT_U8;
2707 snd_printk(KERN_ERR "hda_codec: formats == 0 "
2708 "(nid=0x%x, val=0x%x, ovrd=%i, "
2711 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2716 *formatsp = formats;
2725 * snd_hda_is_supported_format - check whether the given node supports
2728 * Returns 1 if supported, 0 if not.
2730 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2731 unsigned int format)
2734 unsigned int val = 0, rate, stream;
2736 val = query_pcm_param(codec, nid);
2740 rate = format & 0xff00;
2741 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2742 if (rate_bits[i].hda_fmt == rate) {
2747 if (i >= AC_PAR_PCM_RATE_BITS)
2750 stream = query_stream_param(codec, nid);
2754 if (stream & AC_SUPFMT_PCM) {
2755 switch (format & 0xf0) {
2757 if (!(val & AC_SUPPCM_BITS_8))
2761 if (!(val & AC_SUPPCM_BITS_16))
2765 if (!(val & AC_SUPPCM_BITS_20))
2769 if (!(val & AC_SUPPCM_BITS_24))
2773 if (!(val & AC_SUPPCM_BITS_32))
2780 /* FIXME: check for float32 and AC3? */
2785 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2790 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2791 struct hda_codec *codec,
2792 struct snd_pcm_substream *substream)
2797 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2798 struct hda_codec *codec,
2799 unsigned int stream_tag,
2800 unsigned int format,
2801 struct snd_pcm_substream *substream)
2803 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2807 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2808 struct hda_codec *codec,
2809 struct snd_pcm_substream *substream)
2811 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2815 static int set_pcm_default_values(struct hda_codec *codec,
2816 struct hda_pcm_stream *info)
2820 /* query support PCM information from the given NID */
2821 if (info->nid && (!info->rates || !info->formats)) {
2822 err = snd_hda_query_supported_pcm(codec, info->nid,
2823 info->rates ? NULL : &info->rates,
2824 info->formats ? NULL : &info->formats,
2825 info->maxbps ? NULL : &info->maxbps);
2829 if (info->ops.open == NULL)
2830 info->ops.open = hda_pcm_default_open_close;
2831 if (info->ops.close == NULL)
2832 info->ops.close = hda_pcm_default_open_close;
2833 if (info->ops.prepare == NULL) {
2834 if (snd_BUG_ON(!info->nid))
2836 info->ops.prepare = hda_pcm_default_prepare;
2838 if (info->ops.cleanup == NULL) {
2839 if (snd_BUG_ON(!info->nid))
2841 info->ops.cleanup = hda_pcm_default_cleanup;
2847 * get the empty PCM device number to assign
2849 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2851 static const char *dev_name[HDA_PCM_NTYPES] = {
2852 "Audio", "SPDIF", "HDMI", "Modem"
2854 /* starting device index for each PCM type */
2855 static int dev_idx[HDA_PCM_NTYPES] = {
2856 [HDA_PCM_TYPE_AUDIO] = 0,
2857 [HDA_PCM_TYPE_SPDIF] = 1,
2858 [HDA_PCM_TYPE_HDMI] = 3,
2859 [HDA_PCM_TYPE_MODEM] = 6
2861 /* normal audio device indices; not linear to keep compatibility */
2862 static int audio_idx[4] = { 0, 2, 4, 5 };
2866 case HDA_PCM_TYPE_AUDIO:
2867 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2869 if (!test_bit(dev, bus->pcm_dev_bits))
2872 snd_printk(KERN_WARNING "Too many audio devices\n");
2874 case HDA_PCM_TYPE_SPDIF:
2875 case HDA_PCM_TYPE_HDMI:
2876 case HDA_PCM_TYPE_MODEM:
2877 dev = dev_idx[type];
2878 if (test_bit(dev, bus->pcm_dev_bits)) {
2879 snd_printk(KERN_WARNING "%s already defined\n",
2885 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2889 set_bit(dev, bus->pcm_dev_bits);
2894 * attach a new PCM stream
2896 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2898 struct hda_bus *bus = codec->bus;
2899 struct hda_pcm_stream *info;
2902 if (snd_BUG_ON(!pcm->name))
2904 for (stream = 0; stream < 2; stream++) {
2905 info = &pcm->stream[stream];
2906 if (info->substreams) {
2907 err = set_pcm_default_values(codec, info);
2912 return bus->ops.attach_pcm(bus, codec, pcm);
2915 /* assign all PCMs of the given codec */
2916 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2921 if (!codec->num_pcms) {
2922 if (!codec->patch_ops.build_pcms)
2924 err = codec->patch_ops.build_pcms(codec);
2926 printk(KERN_ERR "hda_codec: cannot build PCMs"
2927 "for #%d (error %d)\n", codec->addr, err);
2928 err = snd_hda_codec_reset(codec);
2931 "hda_codec: cannot revert codec\n");
2936 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2937 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2940 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2941 continue; /* no substreams assigned */
2944 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2946 continue; /* no fatal error */
2948 err = snd_hda_attach_pcm(codec, cpcm);
2950 printk(KERN_ERR "hda_codec: cannot attach "
2951 "PCM stream %d for codec #%d\n",
2953 continue; /* no fatal error */
2961 * snd_hda_build_pcms - build PCM information
2964 * Create PCM information for each codec included in the bus.
2966 * The build_pcms codec patch is requested to set up codec->num_pcms and
2967 * codec->pcm_info properly. The array is referred by the top-level driver
2968 * to create its PCM instances.
2969 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2972 * At least, substreams, channels_min and channels_max must be filled for
2973 * each stream. substreams = 0 indicates that the stream doesn't exist.
2974 * When rates and/or formats are zero, the supported values are queried
2975 * from the given nid. The nid is used also by the default ops.prepare
2976 * and ops.cleanup callbacks.
2978 * The driver needs to call ops.open in its open callback. Similarly,
2979 * ops.close is supposed to be called in the close callback.
2980 * ops.prepare should be called in the prepare or hw_params callback
2981 * with the proper parameters for set up.
2982 * ops.cleanup should be called in hw_free for clean up of streams.
2984 * This function returns 0 if successfull, or a negative error code.
2986 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2988 struct hda_codec *codec;
2990 list_for_each_entry(codec, &bus->codec_list, list) {
2991 int err = snd_hda_codec_build_pcms(codec);
2997 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
3000 * snd_hda_check_board_config - compare the current codec with the config table
3001 * @codec: the HDA codec
3002 * @num_configs: number of config enums
3003 * @models: array of model name strings
3004 * @tbl: configuration table, terminated by null entries
3006 * Compares the modelname or PCI subsystem id of the current codec with the
3007 * given configuration table. If a matching entry is found, returns its
3008 * config value (supposed to be 0 or positive).
3010 * If no entries are matching, the function returns a negative value.
3012 int snd_hda_check_board_config(struct hda_codec *codec,
3013 int num_configs, const char **models,
3014 const struct snd_pci_quirk *tbl)
3016 if (codec->modelname && models) {
3018 for (i = 0; i < num_configs; i++) {
3020 !strcmp(codec->modelname, models[i])) {
3021 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3022 "selected\n", models[i]);
3028 if (!codec->bus->pci || !tbl)
3031 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3034 if (tbl->value >= 0 && tbl->value < num_configs) {
3035 #ifdef CONFIG_SND_DEBUG_VERBOSE
3037 const char *model = NULL;
3039 model = models[tbl->value];
3041 sprintf(tmp, "#%d", tbl->value);
3044 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3045 "for config %x:%x (%s)\n",
3046 model, tbl->subvendor, tbl->subdevice,
3047 (tbl->name ? tbl->name : "Unknown device"));
3053 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3056 * snd_hda_check_board_codec_sid_config - compare the current codec
3057 subsystem ID with the
3060 This is important for Gateway notebooks with SB450 HDA Audio
3061 where the vendor ID of the PCI device is:
3062 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3063 and the vendor/subvendor are found only at the codec.
3065 * @codec: the HDA codec
3066 * @num_configs: number of config enums
3067 * @models: array of model name strings
3068 * @tbl: configuration table, terminated by null entries
3070 * Compares the modelname or PCI subsystem id of the current codec with the
3071 * given configuration table. If a matching entry is found, returns its
3072 * config value (supposed to be 0 or positive).
3074 * If no entries are matching, the function returns a negative value.
3076 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3077 int num_configs, const char **models,
3078 const struct snd_pci_quirk *tbl)
3080 const struct snd_pci_quirk *q;
3082 /* Search for codec ID */
3083 for (q = tbl; q->subvendor; q++) {
3084 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3086 if (vendorid == codec->subsystem_id)
3095 if (tbl->value >= 0 && tbl->value < num_configs) {
3096 #ifdef CONFIG_SND_DEBUG_DETECT
3098 const char *model = NULL;
3100 model = models[tbl->value];
3102 sprintf(tmp, "#%d", tbl->value);
3105 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3106 "for config %x:%x (%s)\n",
3107 model, tbl->subvendor, tbl->subdevice,
3108 (tbl->name ? tbl->name : "Unknown device"));
3114 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3117 * snd_hda_add_new_ctls - create controls from the array
3118 * @codec: the HDA codec
3119 * @knew: the array of struct snd_kcontrol_new
3121 * This helper function creates and add new controls in the given array.
3122 * The array must be terminated with an empty entry as terminator.
3124 * Returns 0 if successful, or a negative error code.
3126 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3130 for (; knew->name; knew++) {
3131 struct snd_kcontrol *kctl;
3132 kctl = snd_ctl_new1(knew, codec);
3135 err = snd_hda_ctl_add(codec, kctl);
3139 kctl = snd_ctl_new1(knew, codec);
3142 kctl->id.device = codec->addr;
3143 err = snd_hda_ctl_add(codec, kctl);
3150 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3152 #ifdef CONFIG_SND_HDA_POWER_SAVE
3153 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3154 unsigned int power_state);
3156 static void hda_power_work(struct work_struct *work)
3158 struct hda_codec *codec =
3159 container_of(work, struct hda_codec, power_work.work);
3160 struct hda_bus *bus = codec->bus;
3162 if (!codec->power_on || codec->power_count) {
3163 codec->power_transition = 0;
3167 hda_call_codec_suspend(codec);
3168 if (bus->ops.pm_notify)
3169 bus->ops.pm_notify(bus);
3172 static void hda_keep_power_on(struct hda_codec *codec)
3174 codec->power_count++;
3175 codec->power_on = 1;
3178 void snd_hda_power_up(struct hda_codec *codec)
3180 struct hda_bus *bus = codec->bus;
3182 codec->power_count++;
3183 if (codec->power_on || codec->power_transition)
3186 codec->power_on = 1;
3187 if (bus->ops.pm_notify)
3188 bus->ops.pm_notify(bus);
3189 hda_call_codec_resume(codec);
3190 cancel_delayed_work(&codec->power_work);
3191 codec->power_transition = 0;
3193 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3195 #define power_save(codec) \
3196 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3198 #define power_save(codec) \
3199 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3201 void snd_hda_power_down(struct hda_codec *codec)
3203 --codec->power_count;
3204 if (!codec->power_on || codec->power_count || codec->power_transition)
3206 if (power_save(codec)) {
3207 codec->power_transition = 1; /* avoid reentrance */
3208 queue_delayed_work(codec->bus->workq, &codec->power_work,
3209 msecs_to_jiffies(power_save(codec) * 1000));
3212 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3214 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3215 struct hda_loopback_check *check,
3218 struct hda_amp_list *p;
3221 if (!check->amplist)
3223 for (p = check->amplist; p->nid; p++) {
3228 return 0; /* nothing changed */
3230 for (p = check->amplist; p->nid; p++) {
3231 for (ch = 0; ch < 2; ch++) {
3232 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3234 if (!(v & HDA_AMP_MUTE) && v > 0) {
3235 if (!check->power_on) {
3236 check->power_on = 1;
3237 snd_hda_power_up(codec);
3243 if (check->power_on) {
3244 check->power_on = 0;
3245 snd_hda_power_down(codec);
3249 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3253 * Channel mode helper
3255 int snd_hda_ch_mode_info(struct hda_codec *codec,
3256 struct snd_ctl_elem_info *uinfo,
3257 const struct hda_channel_mode *chmode,
3260 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3262 uinfo->value.enumerated.items = num_chmodes;
3263 if (uinfo->value.enumerated.item >= num_chmodes)
3264 uinfo->value.enumerated.item = num_chmodes - 1;
3265 sprintf(uinfo->value.enumerated.name, "%dch",
3266 chmode[uinfo->value.enumerated.item].channels);
3269 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3271 int snd_hda_ch_mode_get(struct hda_codec *codec,
3272 struct snd_ctl_elem_value *ucontrol,
3273 const struct hda_channel_mode *chmode,
3279 for (i = 0; i < num_chmodes; i++) {
3280 if (max_channels == chmode[i].channels) {
3281 ucontrol->value.enumerated.item[0] = i;
3287 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3289 int snd_hda_ch_mode_put(struct hda_codec *codec,
3290 struct snd_ctl_elem_value *ucontrol,
3291 const struct hda_channel_mode *chmode,
3297 mode = ucontrol->value.enumerated.item[0];
3298 if (mode >= num_chmodes)
3300 if (*max_channelsp == chmode[mode].channels)
3302 /* change the current channel setting */
3303 *max_channelsp = chmode[mode].channels;
3304 if (chmode[mode].sequence)
3305 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3308 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3313 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3314 struct snd_ctl_elem_info *uinfo)
3318 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3320 uinfo->value.enumerated.items = imux->num_items;
3321 if (!imux->num_items)
3323 index = uinfo->value.enumerated.item;
3324 if (index >= imux->num_items)
3325 index = imux->num_items - 1;
3326 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3329 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3331 int snd_hda_input_mux_put(struct hda_codec *codec,
3332 const struct hda_input_mux *imux,
3333 struct snd_ctl_elem_value *ucontrol,
3335 unsigned int *cur_val)
3339 if (!imux->num_items)
3341 idx = ucontrol->value.enumerated.item[0];
3342 if (idx >= imux->num_items)
3343 idx = imux->num_items - 1;
3344 if (*cur_val == idx)
3346 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3347 imux->items[idx].index);
3351 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3355 * Multi-channel / digital-out PCM helper functions
3358 /* setup SPDIF output stream */
3359 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3360 unsigned int stream_tag, unsigned int format)
3362 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3363 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3364 set_dig_out_convert(codec, nid,
3365 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3367 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3368 if (codec->slave_dig_outs) {
3370 for (d = codec->slave_dig_outs; *d; d++)
3371 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3374 /* turn on again (if needed) */
3375 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3376 set_dig_out_convert(codec, nid,
3377 codec->spdif_ctls & 0xff, -1);
3380 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3382 snd_hda_codec_cleanup_stream(codec, nid);
3383 if (codec->slave_dig_outs) {
3385 for (d = codec->slave_dig_outs; *d; d++)
3386 snd_hda_codec_cleanup_stream(codec, *d);
3391 * open the digital out in the exclusive mode
3393 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3394 struct hda_multi_out *mout)
3396 mutex_lock(&codec->spdif_mutex);
3397 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3398 /* already opened as analog dup; reset it once */
3399 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3400 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3401 mutex_unlock(&codec->spdif_mutex);
3404 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3406 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3407 struct hda_multi_out *mout,
3408 unsigned int stream_tag,
3409 unsigned int format,
3410 struct snd_pcm_substream *substream)
3412 mutex_lock(&codec->spdif_mutex);
3413 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3414 mutex_unlock(&codec->spdif_mutex);
3417 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3419 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3420 struct hda_multi_out *mout)
3422 mutex_lock(&codec->spdif_mutex);
3423 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3424 mutex_unlock(&codec->spdif_mutex);
3427 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3430 * release the digital out
3432 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3433 struct hda_multi_out *mout)
3435 mutex_lock(&codec->spdif_mutex);
3436 mout->dig_out_used = 0;
3437 mutex_unlock(&codec->spdif_mutex);
3440 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3443 * set up more restrictions for analog out
3445 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3446 struct hda_multi_out *mout,
3447 struct snd_pcm_substream *substream,
3448 struct hda_pcm_stream *hinfo)
3450 struct snd_pcm_runtime *runtime = substream->runtime;
3451 runtime->hw.channels_max = mout->max_channels;
3452 if (mout->dig_out_nid) {
3453 if (!mout->analog_rates) {
3454 mout->analog_rates = hinfo->rates;
3455 mout->analog_formats = hinfo->formats;
3456 mout->analog_maxbps = hinfo->maxbps;
3458 runtime->hw.rates = mout->analog_rates;
3459 runtime->hw.formats = mout->analog_formats;
3460 hinfo->maxbps = mout->analog_maxbps;
3462 if (!mout->spdif_rates) {
3463 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3465 &mout->spdif_formats,
3466 &mout->spdif_maxbps);
3468 mutex_lock(&codec->spdif_mutex);
3469 if (mout->share_spdif) {
3470 runtime->hw.rates &= mout->spdif_rates;
3471 runtime->hw.formats &= mout->spdif_formats;
3472 if (mout->spdif_maxbps < hinfo->maxbps)
3473 hinfo->maxbps = mout->spdif_maxbps;
3475 mutex_unlock(&codec->spdif_mutex);
3477 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3478 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3480 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3483 * set up the i/o for analog out
3484 * when the digital out is available, copy the front out to digital out, too.
3486 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3487 struct hda_multi_out *mout,
3488 unsigned int stream_tag,
3489 unsigned int format,
3490 struct snd_pcm_substream *substream)
3492 hda_nid_t *nids = mout->dac_nids;
3493 int chs = substream->runtime->channels;
3496 mutex_lock(&codec->spdif_mutex);
3497 if (mout->dig_out_nid && mout->share_spdif &&
3498 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3500 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3502 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3503 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3504 setup_dig_out_stream(codec, mout->dig_out_nid,
3505 stream_tag, format);
3507 mout->dig_out_used = 0;
3508 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3511 mutex_unlock(&codec->spdif_mutex);
3514 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3516 if (!mout->no_share_stream &&
3517 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3518 /* headphone out will just decode front left/right (stereo) */
3519 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3521 /* extra outputs copied from front */
3522 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3523 if (!mout->no_share_stream && mout->extra_out_nid[i])
3524 snd_hda_codec_setup_stream(codec,
3525 mout->extra_out_nid[i],
3526 stream_tag, 0, format);
3529 for (i = 1; i < mout->num_dacs; i++) {
3530 if (chs >= (i + 1) * 2) /* independent out */
3531 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3533 else if (!mout->no_share_stream) /* copy front */
3534 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3539 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3542 * clean up the setting for analog out
3544 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3545 struct hda_multi_out *mout)
3547 hda_nid_t *nids = mout->dac_nids;
3550 for (i = 0; i < mout->num_dacs; i++)
3551 snd_hda_codec_cleanup_stream(codec, nids[i]);
3553 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3554 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3555 if (mout->extra_out_nid[i])
3556 snd_hda_codec_cleanup_stream(codec,
3557 mout->extra_out_nid[i]);
3558 mutex_lock(&codec->spdif_mutex);
3559 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3560 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3561 mout->dig_out_used = 0;
3563 mutex_unlock(&codec->spdif_mutex);
3566 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3569 * Helper for automatic pin configuration
3572 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3574 for (; *list; list++)
3582 * Sort an associated group of pins according to their sequence numbers.
3584 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3591 for (i = 0; i < num_pins; i++) {
3592 for (j = i + 1; j < num_pins; j++) {
3593 if (sequences[i] > sequences[j]) {
3595 sequences[i] = sequences[j];
3607 * Parse all pin widgets and store the useful pin nids to cfg
3609 * The number of line-outs or any primary output is stored in line_outs,
3610 * and the corresponding output pins are assigned to line_out_pins[],
3611 * in the order of front, rear, CLFE, side, ...
3613 * If more extra outputs (speaker and headphone) are found, the pins are
3614 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3615 * is detected, one of speaker of HP pins is assigned as the primary
3616 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3617 * if any analog output exists.
3619 * The analog input pins are assigned to input_pins array.
3620 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3623 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3624 struct auto_pin_cfg *cfg,
3625 hda_nid_t *ignore_nids)
3627 hda_nid_t nid, end_nid;
3628 short seq, assoc_line_out, assoc_speaker;
3629 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3630 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3631 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3633 memset(cfg, 0, sizeof(*cfg));
3635 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3636 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3637 memset(sequences_hp, 0, sizeof(sequences_hp));
3638 assoc_line_out = assoc_speaker = 0;
3640 end_nid = codec->start_nid + codec->num_nodes;
3641 for (nid = codec->start_nid; nid < end_nid; nid++) {
3642 unsigned int wid_caps = get_wcaps(codec, nid);
3643 unsigned int wid_type =
3644 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3645 unsigned int def_conf;
3648 /* read all default configuration for pin complex */
3649 if (wid_type != AC_WID_PIN)
3651 /* ignore the given nids (e.g. pc-beep returns error) */
3652 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3655 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3656 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3658 loc = get_defcfg_location(def_conf);
3659 switch (get_defcfg_device(def_conf)) {
3660 case AC_JACK_LINE_OUT:
3661 seq = get_defcfg_sequence(def_conf);
3662 assoc = get_defcfg_association(def_conf);
3664 if (!(wid_caps & AC_WCAP_STEREO))
3665 if (!cfg->mono_out_pin)
3666 cfg->mono_out_pin = nid;
3669 if (!assoc_line_out)
3670 assoc_line_out = assoc;
3671 else if (assoc_line_out != assoc)
3673 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3675 cfg->line_out_pins[cfg->line_outs] = nid;
3676 sequences_line_out[cfg->line_outs] = seq;
3679 case AC_JACK_SPEAKER:
3680 seq = get_defcfg_sequence(def_conf);
3681 assoc = get_defcfg_association(def_conf);
3684 if (! assoc_speaker)
3685 assoc_speaker = assoc;
3686 else if (assoc_speaker != assoc)
3688 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3690 cfg->speaker_pins[cfg->speaker_outs] = nid;
3691 sequences_speaker[cfg->speaker_outs] = seq;
3692 cfg->speaker_outs++;
3694 case AC_JACK_HP_OUT:
3695 seq = get_defcfg_sequence(def_conf);
3696 assoc = get_defcfg_association(def_conf);
3697 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3699 cfg->hp_pins[cfg->hp_outs] = nid;
3700 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3703 case AC_JACK_MIC_IN: {
3705 if (loc == AC_JACK_LOC_FRONT) {
3706 preferred = AUTO_PIN_FRONT_MIC;
3709 preferred = AUTO_PIN_MIC;
3710 alt = AUTO_PIN_FRONT_MIC;
3712 if (!cfg->input_pins[preferred])
3713 cfg->input_pins[preferred] = nid;
3714 else if (!cfg->input_pins[alt])
3715 cfg->input_pins[alt] = nid;
3718 case AC_JACK_LINE_IN:
3719 if (loc == AC_JACK_LOC_FRONT)
3720 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3722 cfg->input_pins[AUTO_PIN_LINE] = nid;
3725 cfg->input_pins[AUTO_PIN_CD] = nid;
3728 cfg->input_pins[AUTO_PIN_AUX] = nid;
3730 case AC_JACK_SPDIF_OUT:
3731 case AC_JACK_DIG_OTHER_OUT:
3732 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3734 cfg->dig_out_pins[cfg->dig_outs] = nid;
3735 cfg->dig_out_type[cfg->dig_outs] =
3736 (loc == AC_JACK_LOC_HDMI) ?
3737 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3740 case AC_JACK_SPDIF_IN:
3741 case AC_JACK_DIG_OTHER_IN:
3742 cfg->dig_in_pin = nid;
3743 if (loc == AC_JACK_LOC_HDMI)
3744 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3746 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
3752 * If no line-out is defined but multiple HPs are found,
3753 * some of them might be the real line-outs.
3755 if (!cfg->line_outs && cfg->hp_outs > 1) {
3757 while (i < cfg->hp_outs) {
3758 /* The real HPs should have the sequence 0x0f */
3759 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3763 /* Move it to the line-out table */
3764 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3765 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3768 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3769 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3770 memmove(sequences_hp + i - 1, sequences_hp + i,
3771 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3775 /* sort by sequence */
3776 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3778 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3780 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3783 /* if we have only one mic, make it AUTO_PIN_MIC */
3784 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3785 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3786 cfg->input_pins[AUTO_PIN_MIC] =
3787 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3788 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3790 /* ditto for line-in */
3791 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3792 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3793 cfg->input_pins[AUTO_PIN_LINE] =
3794 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3795 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3799 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3800 * as a primary output
3802 if (!cfg->line_outs) {
3803 if (cfg->speaker_outs) {
3804 cfg->line_outs = cfg->speaker_outs;
3805 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3806 sizeof(cfg->speaker_pins));
3807 cfg->speaker_outs = 0;
3808 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3809 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3810 } else if (cfg->hp_outs) {
3811 cfg->line_outs = cfg->hp_outs;
3812 memcpy(cfg->line_out_pins, cfg->hp_pins,
3813 sizeof(cfg->hp_pins));
3815 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3816 cfg->line_out_type = AUTO_PIN_HP_OUT;
3820 /* Reorder the surround channels
3821 * ALSA sequence is front/surr/clfe/side
3823 * 4-ch: front/surr => OK as it is
3824 * 6-ch: front/clfe/surr
3825 * 8-ch: front/clfe/rear/side|fc
3827 switch (cfg->line_outs) {
3830 nid = cfg->line_out_pins[1];
3831 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3832 cfg->line_out_pins[2] = nid;
3837 * debug prints of the parsed results
3839 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3840 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3841 cfg->line_out_pins[2], cfg->line_out_pins[3],
3842 cfg->line_out_pins[4]);
3843 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3844 cfg->speaker_outs, cfg->speaker_pins[0],
3845 cfg->speaker_pins[1], cfg->speaker_pins[2],
3846 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3847 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3848 cfg->hp_outs, cfg->hp_pins[0],
3849 cfg->hp_pins[1], cfg->hp_pins[2],
3850 cfg->hp_pins[3], cfg->hp_pins[4]);
3851 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3853 snd_printd(" dig-out=0x%x/0x%x\n",
3854 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
3855 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3856 " cd=0x%x, aux=0x%x\n",
3857 cfg->input_pins[AUTO_PIN_MIC],
3858 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3859 cfg->input_pins[AUTO_PIN_LINE],
3860 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3861 cfg->input_pins[AUTO_PIN_CD],
3862 cfg->input_pins[AUTO_PIN_AUX]);
3863 if (cfg->dig_in_pin)
3864 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
3868 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3870 /* labels for input pins */
3871 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3872 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3874 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3883 * snd_hda_suspend - suspend the codecs
3886 * Returns 0 if successful.
3888 int snd_hda_suspend(struct hda_bus *bus)
3890 struct hda_codec *codec;
3892 list_for_each_entry(codec, &bus->codec_list, list) {
3893 #ifdef CONFIG_SND_HDA_POWER_SAVE
3894 if (!codec->power_on)
3897 hda_call_codec_suspend(codec);
3901 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3904 * snd_hda_resume - resume the codecs
3907 * Returns 0 if successful.
3909 * This fucntion is defined only when POWER_SAVE isn't set.
3910 * In the power-save mode, the codec is resumed dynamically.
3912 int snd_hda_resume(struct hda_bus *bus)
3914 struct hda_codec *codec;
3916 list_for_each_entry(codec, &bus->codec_list, list) {
3917 if (snd_hda_codec_needs_resume(codec))
3918 hda_call_codec_resume(codec);
3922 EXPORT_SYMBOL_HDA(snd_hda_resume);
3923 #endif /* CONFIG_PM */
3929 /* get a new element from the given array
3930 * if it exceeds the pre-allocated array size, re-allocate the array
3932 void *snd_array_new(struct snd_array *array)
3934 if (array->used >= array->alloced) {
3935 int num = array->alloced + array->alloc_align;
3937 if (snd_BUG_ON(num >= 4096))
3939 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3943 memcpy(nlist, array->list,
3944 array->elem_size * array->alloced);
3947 array->list = nlist;
3948 array->alloced = num;
3950 return snd_array_elem(array, array->used++);
3952 EXPORT_SYMBOL_HDA(snd_array_new);
3954 /* free the given array elements */
3955 void snd_array_free(struct snd_array *array)
3962 EXPORT_SYMBOL_HDA(snd_array_free);
3965 * used by hda_proc.c and hda_eld.c
3967 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3969 static unsigned int rates[] = {
3970 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3971 96000, 176400, 192000, 384000
3975 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3977 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3979 buf[j] = '\0'; /* necessary when j == 0 */
3981 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3983 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3985 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3988 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3989 if (pcm & (AC_SUPPCM_BITS_8 << i))
3990 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3992 buf[j] = '\0'; /* necessary when j == 0 */
3994 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
3996 MODULE_DESCRIPTION("HDA codec core");
3997 MODULE_LICENSE("GPL");