2 * Universal Interface for Intel High Definition Audio Codec
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/pci.h>
26 #include <linux/mutex.h>
27 #include <sound/core.h>
28 #include "hda_codec.h"
29 #include <sound/asoundef.h>
30 #include <sound/tlv.h>
31 #include <sound/initval.h>
32 #include "hda_local.h"
33 #include <sound/hda_hwdep.h>
36 * vendor / preset table
39 struct hda_vendor_id {
44 /* codec vendor labels */
45 static struct hda_vendor_id hda_vendor_ids[] = {
47 { 0x1057, "Motorola" },
48 { 0x1095, "Silicon Image" },
50 { 0x10ec, "Realtek" },
54 { 0x11d4, "Analog Devices" },
55 { 0x13f6, "C-Media" },
56 { 0x14f1, "Conexant" },
57 { 0x17e8, "Chrontel" },
59 { 0x1aec, "Wolfson Microelectronics" },
60 { 0x434d, "C-Media" },
62 { 0x8384, "SigmaTel" },
66 static DEFINE_MUTEX(preset_mutex);
67 static LIST_HEAD(hda_preset_tables);
69 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
71 mutex_lock(&preset_mutex);
72 list_add_tail(&preset->list, &hda_preset_tables);
73 mutex_unlock(&preset_mutex);
76 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
78 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
80 mutex_lock(&preset_mutex);
81 list_del(&preset->list);
82 mutex_unlock(&preset_mutex);
85 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
87 #ifdef CONFIG_SND_HDA_POWER_SAVE
88 static void hda_power_work(struct work_struct *work);
89 static void hda_keep_power_on(struct hda_codec *codec);
91 static inline void hda_keep_power_on(struct hda_codec *codec) {}
94 const char *snd_hda_get_jack_location(u32 cfg)
96 static char *bases[7] = {
97 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
99 static unsigned char specials_idx[] = {
104 static char *specials[] = {
105 "Rear Panel", "Drive Bar",
106 "Riser", "HDMI", "ATAPI",
107 "Mobile-In", "Mobile-Out"
110 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
111 if ((cfg & 0x0f) < 7)
112 return bases[cfg & 0x0f];
113 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
114 if (cfg == specials_idx[i])
119 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
121 const char *snd_hda_get_jack_connectivity(u32 cfg)
123 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
125 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
127 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
129 const char *snd_hda_get_jack_type(u32 cfg)
131 static char *jack_types[16] = {
132 "Line Out", "Speaker", "HP Out", "CD",
133 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
134 "Line In", "Aux", "Mic", "Telephony",
135 "SPDIF In", "Digitial In", "Reserved", "Other"
138 return jack_types[(cfg & AC_DEFCFG_DEVICE)
139 >> AC_DEFCFG_DEVICE_SHIFT];
141 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
144 * Compose a 32bit command word to be sent to the HD-audio controller
146 static inline unsigned int
147 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
148 unsigned int verb, unsigned int parm)
152 val = (u32)(codec->addr & 0x0f) << 28;
153 val |= (u32)direct << 27;
154 val |= (u32)nid << 20;
161 * snd_hda_codec_read - send a command and get the response
162 * @codec: the HDA codec
163 * @nid: NID to send the command
164 * @direct: direct flag
165 * @verb: the verb to send
166 * @parm: the parameter for the verb
168 * Send a single command and read the corresponding response.
170 * Returns the obtained response value, or -1 for an error.
172 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
174 unsigned int verb, unsigned int parm)
176 struct hda_bus *bus = codec->bus;
179 res = make_codec_cmd(codec, nid, direct, verb, parm);
180 snd_hda_power_up(codec);
181 mutex_lock(&bus->cmd_mutex);
182 if (!bus->ops.command(bus, res))
183 res = bus->ops.get_response(bus);
185 res = (unsigned int)-1;
186 mutex_unlock(&bus->cmd_mutex);
187 snd_hda_power_down(codec);
190 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
193 * snd_hda_codec_write - send a single command without waiting for response
194 * @codec: the HDA codec
195 * @nid: NID to send the command
196 * @direct: direct flag
197 * @verb: the verb to send
198 * @parm: the parameter for the verb
200 * Send a single command without waiting for response.
202 * Returns 0 if successful, or a negative error code.
204 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
205 unsigned int verb, unsigned int parm)
207 struct hda_bus *bus = codec->bus;
211 res = make_codec_cmd(codec, nid, direct, verb, parm);
212 snd_hda_power_up(codec);
213 mutex_lock(&bus->cmd_mutex);
214 err = bus->ops.command(bus, res);
215 mutex_unlock(&bus->cmd_mutex);
216 snd_hda_power_down(codec);
219 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
222 * snd_hda_sequence_write - sequence writes
223 * @codec: the HDA codec
224 * @seq: VERB array to send
226 * Send the commands sequentially from the given array.
227 * The array must be terminated with NID=0.
229 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
231 for (; seq->nid; seq++)
232 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
234 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
237 * snd_hda_get_sub_nodes - get the range of sub nodes
238 * @codec: the HDA codec
240 * @start_id: the pointer to store the start NID
242 * Parse the NID and store the start NID of its sub-nodes.
243 * Returns the number of sub-nodes.
245 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
250 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
253 *start_id = (parm >> 16) & 0x7fff;
254 return (int)(parm & 0x7fff);
256 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
259 * snd_hda_get_connections - get connection list
260 * @codec: the HDA codec
262 * @conn_list: connection list array
263 * @max_conns: max. number of connections to store
265 * Parses the connection list of the given widget and stores the list
268 * Returns the number of connections, or a negative error code.
270 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
271 hda_nid_t *conn_list, int max_conns)
274 int i, conn_len, conns;
275 unsigned int shift, num_elems, mask;
278 if (snd_BUG_ON(!conn_list || max_conns <= 0))
281 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
282 if (parm & AC_CLIST_LONG) {
291 conn_len = parm & AC_CLIST_LENGTH;
292 mask = (1 << (shift-1)) - 1;
295 return 0; /* no connection */
298 /* single connection */
299 parm = snd_hda_codec_read(codec, nid, 0,
300 AC_VERB_GET_CONNECT_LIST, 0);
301 conn_list[0] = parm & mask;
305 /* multi connection */
308 for (i = 0; i < conn_len; i++) {
312 if (i % num_elems == 0)
313 parm = snd_hda_codec_read(codec, nid, 0,
314 AC_VERB_GET_CONNECT_LIST, i);
315 range_val = !!(parm & (1 << (shift-1))); /* ranges */
319 /* ranges between the previous and this one */
320 if (!prev_nid || prev_nid >= val) {
321 snd_printk(KERN_WARNING "hda_codec: "
322 "invalid dep_range_val %x:%x\n",
326 for (n = prev_nid + 1; n <= val; n++) {
327 if (conns >= max_conns) {
329 "Too many connections\n");
332 conn_list[conns++] = n;
335 if (conns >= max_conns) {
336 snd_printk(KERN_ERR "Too many connections\n");
339 conn_list[conns++] = val;
345 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
349 * snd_hda_queue_unsol_event - add an unsolicited event to queue
351 * @res: unsolicited event (lower 32bit of RIRB entry)
352 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
354 * Adds the given event to the queue. The events are processed in
355 * the workqueue asynchronously. Call this function in the interrupt
356 * hanlder when RIRB receives an unsolicited event.
358 * Returns 0 if successful, or a negative error code.
360 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
362 struct hda_bus_unsolicited *unsol;
369 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
373 unsol->queue[wp] = res;
374 unsol->queue[wp + 1] = res_ex;
376 queue_work(bus->workq, &unsol->work);
380 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
383 * process queued unsolicited events
385 static void process_unsol_events(struct work_struct *work)
387 struct hda_bus_unsolicited *unsol =
388 container_of(work, struct hda_bus_unsolicited, work);
389 struct hda_bus *bus = unsol->bus;
390 struct hda_codec *codec;
391 unsigned int rp, caddr, res;
393 while (unsol->rp != unsol->wp) {
394 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
397 res = unsol->queue[rp];
398 caddr = unsol->queue[rp + 1];
399 if (!(caddr & (1 << 4))) /* no unsolicited event? */
401 codec = bus->caddr_tbl[caddr & 0x0f];
402 if (codec && codec->patch_ops.unsol_event)
403 codec->patch_ops.unsol_event(codec, res);
408 * initialize unsolicited queue
410 static int init_unsol_queue(struct hda_bus *bus)
412 struct hda_bus_unsolicited *unsol;
414 if (bus->unsol) /* already initialized */
417 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
419 snd_printk(KERN_ERR "hda_codec: "
420 "can't allocate unsolicited queue\n");
423 INIT_WORK(&unsol->work, process_unsol_events);
432 static void snd_hda_codec_free(struct hda_codec *codec);
434 static int snd_hda_bus_free(struct hda_bus *bus)
436 struct hda_codec *codec, *n;
441 flush_workqueue(bus->workq);
444 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
445 snd_hda_codec_free(codec);
447 if (bus->ops.private_free)
448 bus->ops.private_free(bus);
450 destroy_workqueue(bus->workq);
455 static int snd_hda_bus_dev_free(struct snd_device *device)
457 struct hda_bus *bus = device->device_data;
459 return snd_hda_bus_free(bus);
462 #ifdef CONFIG_SND_HDA_HWDEP
463 static int snd_hda_bus_dev_register(struct snd_device *device)
465 struct hda_bus *bus = device->device_data;
466 struct hda_codec *codec;
467 list_for_each_entry(codec, &bus->codec_list, list) {
468 snd_hda_hwdep_add_sysfs(codec);
473 #define snd_hda_bus_dev_register NULL
477 * snd_hda_bus_new - create a HDA bus
478 * @card: the card entry
479 * @temp: the template for hda_bus information
480 * @busp: the pointer to store the created bus instance
482 * Returns 0 if successful, or a negative error code.
484 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
485 const struct hda_bus_template *temp,
486 struct hda_bus **busp)
490 static struct snd_device_ops dev_ops = {
491 .dev_register = snd_hda_bus_dev_register,
492 .dev_free = snd_hda_bus_dev_free,
495 if (snd_BUG_ON(!temp))
497 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
503 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
505 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
510 bus->private_data = temp->private_data;
511 bus->pci = temp->pci;
512 bus->modelname = temp->modelname;
513 bus->power_save = temp->power_save;
514 bus->ops = temp->ops;
516 mutex_init(&bus->cmd_mutex);
517 INIT_LIST_HEAD(&bus->codec_list);
519 snprintf(bus->workq_name, sizeof(bus->workq_name),
520 "hd-audio%d", card->number);
521 bus->workq = create_singlethread_workqueue(bus->workq_name);
523 snd_printk(KERN_ERR "cannot create workqueue %s\n",
529 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
531 snd_hda_bus_free(bus);
538 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
540 #ifdef CONFIG_SND_HDA_GENERIC
541 #define is_generic_config(codec) \
542 (codec->modelname && !strcmp(codec->modelname, "generic"))
544 #define is_generic_config(codec) 0
548 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
550 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
554 * find a matching codec preset
556 static const struct hda_codec_preset *
557 find_codec_preset(struct hda_codec *codec)
559 struct hda_codec_preset_list *tbl;
560 const struct hda_codec_preset *preset;
561 int mod_requested = 0;
563 if (is_generic_config(codec))
564 return NULL; /* use the generic parser */
567 mutex_lock(&preset_mutex);
568 list_for_each_entry(tbl, &hda_preset_tables, list) {
569 if (!try_module_get(tbl->owner)) {
570 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
573 for (preset = tbl->preset; preset->id; preset++) {
574 u32 mask = preset->mask;
575 if (preset->afg && preset->afg != codec->afg)
577 if (preset->mfg && preset->mfg != codec->mfg)
581 if (preset->id == (codec->vendor_id & mask) &&
583 preset->rev == codec->revision_id)) {
584 mutex_unlock(&preset_mutex);
585 codec->owner = tbl->owner;
589 module_put(tbl->owner);
591 mutex_unlock(&preset_mutex);
593 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
596 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
599 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
600 (codec->vendor_id >> 16) & 0xffff);
601 request_module(name);
609 * get_codec_name - store the codec name
611 static int get_codec_name(struct hda_codec *codec)
613 const struct hda_vendor_id *c;
614 const char *vendor = NULL;
615 u16 vendor_id = codec->vendor_id >> 16;
616 char tmp[16], name[32];
618 for (c = hda_vendor_ids; c->id; c++) {
619 if (c->id == vendor_id) {
625 sprintf(tmp, "Generic %04x", vendor_id);
628 if (codec->preset && codec->preset->name)
629 snprintf(name, sizeof(name), "%s %s", vendor,
630 codec->preset->name);
632 snprintf(name, sizeof(name), "%s ID %x", vendor,
633 codec->vendor_id & 0xffff);
634 codec->name = kstrdup(name, GFP_KERNEL);
641 * look for an AFG and MFG nodes
643 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
648 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
649 for (i = 0; i < total_nodes; i++, nid++) {
651 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
652 switch (func & 0xff) {
653 case AC_GRP_AUDIO_FUNCTION:
656 case AC_GRP_MODEM_FUNCTION:
666 * read widget caps for each widget and store in cache
668 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
673 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
675 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
678 nid = codec->start_nid;
679 for (i = 0; i < codec->num_nodes; i++, nid++)
680 codec->wcaps[i] = snd_hda_param_read(codec, nid,
681 AC_PAR_AUDIO_WIDGET_CAP);
685 /* read all pin default configurations and save codec->init_pins */
686 static int read_pin_defaults(struct hda_codec *codec)
689 hda_nid_t nid = codec->start_nid;
691 for (i = 0; i < codec->num_nodes; i++, nid++) {
692 struct hda_pincfg *pin;
693 unsigned int wcaps = get_wcaps(codec, nid);
694 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
696 if (wid_type != AC_WID_PIN)
698 pin = snd_array_new(&codec->init_pins);
702 pin->cfg = snd_hda_codec_read(codec, nid, 0,
703 AC_VERB_GET_CONFIG_DEFAULT, 0);
708 /* look up the given pin config list and return the item matching with NID */
709 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
710 struct snd_array *array,
714 for (i = 0; i < array->used; i++) {
715 struct hda_pincfg *pin = snd_array_elem(array, i);
722 /* write a config value for the given NID */
723 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
727 for (i = 0; i < 4; i++) {
728 snd_hda_codec_write(codec, nid, 0,
729 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
735 /* set the current pin config value for the given NID.
736 * the value is cached, and read via snd_hda_codec_get_pincfg()
738 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
739 hda_nid_t nid, unsigned int cfg)
741 struct hda_pincfg *pin;
744 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
745 pin = look_up_pincfg(codec, list, nid);
747 pin = snd_array_new(list);
754 /* change only when needed; e.g. if the pincfg is already present
755 * in user_pins[], don't write it
757 cfg = snd_hda_codec_get_pincfg(codec, nid);
759 set_pincfg(codec, nid, cfg);
763 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
764 hda_nid_t nid, unsigned int cfg)
766 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
768 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
770 /* get the current pin config value of the given pin NID */
771 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
773 struct hda_pincfg *pin;
775 #ifdef CONFIG_SND_HDA_HWDEP
776 pin = look_up_pincfg(codec, &codec->user_pins, nid);
780 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
783 pin = look_up_pincfg(codec, &codec->init_pins, nid);
788 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
790 /* restore all current pin configs */
791 static void restore_pincfgs(struct hda_codec *codec)
794 for (i = 0; i < codec->init_pins.used; i++) {
795 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
796 set_pincfg(codec, pin->nid,
797 snd_hda_codec_get_pincfg(codec, pin->nid));
801 static void init_hda_cache(struct hda_cache_rec *cache,
802 unsigned int record_size);
803 static void free_hda_cache(struct hda_cache_rec *cache);
805 /* restore the initial pin cfgs and release all pincfg lists */
806 static void restore_init_pincfgs(struct hda_codec *codec)
808 /* first free driver_pins and user_pins, then call restore_pincfg
809 * so that only the values in init_pins are restored
811 snd_array_free(&codec->driver_pins);
812 #ifdef CONFIG_SND_HDA_HWDEP
813 snd_array_free(&codec->user_pins);
815 restore_pincfgs(codec);
816 snd_array_free(&codec->init_pins);
822 static void snd_hda_codec_free(struct hda_codec *codec)
826 restore_init_pincfgs(codec);
827 #ifdef CONFIG_SND_HDA_POWER_SAVE
828 cancel_delayed_work(&codec->power_work);
829 flush_workqueue(codec->bus->workq);
831 list_del(&codec->list);
832 snd_array_free(&codec->mixers);
833 codec->bus->caddr_tbl[codec->addr] = NULL;
834 if (codec->patch_ops.free)
835 codec->patch_ops.free(codec);
836 module_put(codec->owner);
837 free_hda_cache(&codec->amp_cache);
838 free_hda_cache(&codec->cmd_cache);
840 kfree(codec->modelname);
846 * snd_hda_codec_new - create a HDA codec
847 * @bus: the bus to assign
848 * @codec_addr: the codec address
849 * @codecp: the pointer to store the generated codec
851 * Returns 0 if successful, or a negative error code.
853 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
854 int do_init, struct hda_codec **codecp)
856 struct hda_codec *codec;
860 if (snd_BUG_ON(!bus))
862 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
865 if (bus->caddr_tbl[codec_addr]) {
866 snd_printk(KERN_ERR "hda_codec: "
867 "address 0x%x is already occupied\n", codec_addr);
871 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
873 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
878 codec->addr = codec_addr;
879 mutex_init(&codec->spdif_mutex);
880 mutex_init(&codec->control_mutex);
881 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
882 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
883 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
884 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
885 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
886 if (codec->bus->modelname) {
887 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
888 if (!codec->modelname) {
889 snd_hda_codec_free(codec);
894 #ifdef CONFIG_SND_HDA_POWER_SAVE
895 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
896 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
897 * the caller has to power down appropriatley after initialization
900 hda_keep_power_on(codec);
903 list_add_tail(&codec->list, &bus->codec_list);
904 bus->caddr_tbl[codec_addr] = codec;
906 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
908 if (codec->vendor_id == -1)
909 /* read again, hopefully the access method was corrected
910 * in the last read...
912 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
914 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
915 AC_PAR_SUBSYSTEM_ID);
916 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
919 setup_fg_nodes(codec);
920 if (!codec->afg && !codec->mfg) {
921 snd_printdd("hda_codec: no AFG or MFG node found\n");
926 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
928 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
931 err = read_pin_defaults(codec);
935 if (!codec->subsystem_id) {
936 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
937 codec->subsystem_id =
938 snd_hda_codec_read(codec, nid, 0,
939 AC_VERB_GET_SUBSYSTEM_ID, 0);
942 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
945 err = snd_hda_codec_configure(codec);
949 snd_hda_codec_proc_new(codec);
951 snd_hda_create_hwdep(codec);
953 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
954 codec->subsystem_id, codec->revision_id);
955 snd_component_add(codec->bus->card, component);
962 snd_hda_codec_free(codec);
965 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
967 int snd_hda_codec_configure(struct hda_codec *codec)
971 codec->preset = find_codec_preset(codec);
973 err = get_codec_name(codec);
977 /* audio codec should override the mixer name */
978 if (codec->afg || !*codec->bus->card->mixername)
979 strlcpy(codec->bus->card->mixername, codec->name,
980 sizeof(codec->bus->card->mixername));
982 if (is_generic_config(codec)) {
983 err = snd_hda_parse_generic_codec(codec);
986 if (codec->preset && codec->preset->patch) {
987 err = codec->preset->patch(codec);
991 /* call the default parser */
992 err = snd_hda_parse_generic_codec(codec);
994 printk(KERN_ERR "hda-codec: No codec parser is available\n");
997 if (!err && codec->patch_ops.unsol_event)
998 err = init_unsol_queue(codec->bus);
1003 * snd_hda_codec_setup_stream - set up the codec for streaming
1004 * @codec: the CODEC to set up
1005 * @nid: the NID to set up
1006 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1007 * @channel_id: channel id to pass, zero based.
1008 * @format: stream format.
1010 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1012 int channel_id, int format)
1017 snd_printdd("hda_codec_setup_stream: "
1018 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1019 nid, stream_tag, channel_id, format);
1020 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1021 (stream_tag << 4) | channel_id);
1023 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1025 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1027 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1032 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1033 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1034 #if 0 /* keep the format */
1036 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1039 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
1042 * amp access functions
1045 /* FIXME: more better hash key? */
1046 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1047 #define INFO_AMP_CAPS (1<<0)
1048 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1050 /* initialize the hash table */
1051 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1052 unsigned int record_size)
1054 memset(cache, 0, sizeof(*cache));
1055 memset(cache->hash, 0xff, sizeof(cache->hash));
1056 snd_array_init(&cache->buf, record_size, 64);
1059 static void free_hda_cache(struct hda_cache_rec *cache)
1061 snd_array_free(&cache->buf);
1064 /* query the hash. allocate an entry if not found. */
1065 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1068 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1069 u16 cur = cache->hash[idx];
1070 struct hda_cache_head *info;
1072 while (cur != 0xffff) {
1073 info = snd_array_elem(&cache->buf, cur);
1074 if (info->key == key)
1079 /* add a new hash entry */
1080 info = snd_array_new(&cache->buf);
1083 cur = snd_array_index(&cache->buf, info);
1086 info->next = cache->hash[idx];
1087 cache->hash[idx] = cur;
1092 /* query and allocate an amp hash entry */
1093 static inline struct hda_amp_info *
1094 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1096 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1100 * query AMP capabilities for the given widget and direction
1102 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1104 struct hda_amp_info *info;
1106 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1109 if (!(info->head.val & INFO_AMP_CAPS)) {
1110 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1112 info->amp_caps = snd_hda_param_read(codec, nid,
1113 direction == HDA_OUTPUT ?
1114 AC_PAR_AMP_OUT_CAP :
1117 info->head.val |= INFO_AMP_CAPS;
1119 return info->amp_caps;
1121 EXPORT_SYMBOL_HDA(query_amp_caps);
1123 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1126 struct hda_amp_info *info;
1128 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1131 info->amp_caps = caps;
1132 info->head.val |= INFO_AMP_CAPS;
1135 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1138 * read the current volume to info
1139 * if the cache exists, read the cache value.
1141 static unsigned int get_vol_mute(struct hda_codec *codec,
1142 struct hda_amp_info *info, hda_nid_t nid,
1143 int ch, int direction, int index)
1147 if (info->head.val & INFO_AMP_VOL(ch))
1148 return info->vol[ch];
1150 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1151 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1153 val = snd_hda_codec_read(codec, nid, 0,
1154 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1155 info->vol[ch] = val & 0xff;
1156 info->head.val |= INFO_AMP_VOL(ch);
1157 return info->vol[ch];
1161 * write the current volume in info to the h/w and update the cache
1163 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1164 hda_nid_t nid, int ch, int direction, int index,
1169 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1170 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1171 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1173 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1174 info->vol[ch] = val;
1178 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1180 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1181 int direction, int index)
1183 struct hda_amp_info *info;
1184 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1187 return get_vol_mute(codec, info, nid, ch, direction, index);
1189 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1192 * update the AMP value, mask = bit mask to set, val = the value
1194 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1195 int direction, int idx, int mask, int val)
1197 struct hda_amp_info *info;
1199 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1203 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1204 if (info->vol[ch] == val)
1206 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1209 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1212 * update the AMP stereo with the same mask and value
1214 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1215 int direction, int idx, int mask, int val)
1218 for (ch = 0; ch < 2; ch++)
1219 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1223 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1225 #ifdef SND_HDA_NEEDS_RESUME
1226 /* resume the all amp commands from the cache */
1227 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1229 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1232 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1233 u32 key = buffer->head.key;
1235 unsigned int idx, dir, ch;
1239 idx = (key >> 16) & 0xff;
1240 dir = (key >> 24) & 0xff;
1241 for (ch = 0; ch < 2; ch++) {
1242 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1244 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1249 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1250 #endif /* SND_HDA_NEEDS_RESUME */
1253 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1254 struct snd_ctl_elem_info *uinfo)
1256 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1257 u16 nid = get_amp_nid(kcontrol);
1258 u8 chs = get_amp_channels(kcontrol);
1259 int dir = get_amp_direction(kcontrol);
1260 unsigned int ofs = get_amp_offset(kcontrol);
1263 caps = query_amp_caps(codec, nid, dir);
1265 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1267 printk(KERN_WARNING "hda_codec: "
1268 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1274 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1275 uinfo->count = chs == 3 ? 2 : 1;
1276 uinfo->value.integer.min = 0;
1277 uinfo->value.integer.max = caps;
1280 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1283 static inline unsigned int
1284 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1285 int ch, int dir, int idx, unsigned int ofs)
1288 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1289 val &= HDA_AMP_VOLMASK;
1298 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1299 int ch, int dir, int idx, unsigned int ofs,
1304 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1305 HDA_AMP_VOLMASK, val);
1308 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1309 struct snd_ctl_elem_value *ucontrol)
1311 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1312 hda_nid_t nid = get_amp_nid(kcontrol);
1313 int chs = get_amp_channels(kcontrol);
1314 int dir = get_amp_direction(kcontrol);
1315 int idx = get_amp_index(kcontrol);
1316 unsigned int ofs = get_amp_offset(kcontrol);
1317 long *valp = ucontrol->value.integer.value;
1320 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1322 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1325 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1327 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1328 struct snd_ctl_elem_value *ucontrol)
1330 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1331 hda_nid_t nid = get_amp_nid(kcontrol);
1332 int chs = get_amp_channels(kcontrol);
1333 int dir = get_amp_direction(kcontrol);
1334 int idx = get_amp_index(kcontrol);
1335 unsigned int ofs = get_amp_offset(kcontrol);
1336 long *valp = ucontrol->value.integer.value;
1339 snd_hda_power_up(codec);
1341 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1345 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1346 snd_hda_power_down(codec);
1349 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1351 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1352 unsigned int size, unsigned int __user *_tlv)
1354 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1355 hda_nid_t nid = get_amp_nid(kcontrol);
1356 int dir = get_amp_direction(kcontrol);
1357 unsigned int ofs = get_amp_offset(kcontrol);
1358 u32 caps, val1, val2;
1360 if (size < 4 * sizeof(unsigned int))
1362 caps = query_amp_caps(codec, nid, dir);
1363 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1364 val2 = (val2 + 1) * 25;
1365 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1367 val1 = ((int)val1) * ((int)val2);
1368 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1370 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1372 if (put_user(val1, _tlv + 2))
1374 if (put_user(val2, _tlv + 3))
1378 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1381 * set (static) TLV for virtual master volume; recalculated as max 0dB
1383 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1389 caps = query_amp_caps(codec, nid, dir);
1390 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1391 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1392 step = (step + 1) * 25;
1393 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1394 tlv[1] = 2 * sizeof(unsigned int);
1395 tlv[2] = -nums * step;
1398 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1400 /* find a mixer control element with the given name */
1401 static struct snd_kcontrol *
1402 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1403 const char *name, int idx)
1405 struct snd_ctl_elem_id id;
1406 memset(&id, 0, sizeof(id));
1407 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1409 strcpy(id.name, name);
1410 return snd_ctl_find_id(codec->bus->card, &id);
1413 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1416 return _snd_hda_find_mixer_ctl(codec, name, 0);
1418 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1420 /* Add a control element and assign to the codec */
1421 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1424 struct snd_kcontrol **knewp;
1426 err = snd_ctl_add(codec->bus->card, kctl);
1429 knewp = snd_array_new(&codec->mixers);
1435 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1437 /* Clear all controls assigned to the given codec */
1438 void snd_hda_ctls_clear(struct hda_codec *codec)
1441 struct snd_kcontrol **kctls = codec->mixers.list;
1442 for (i = 0; i < codec->mixers.used; i++)
1443 snd_ctl_remove(codec->bus->card, kctls[i]);
1444 snd_array_free(&codec->mixers);
1447 /* pseudo device locking
1448 * toggle card->shutdown to allow/disallow the device access (as a hack)
1450 static int hda_lock_devices(struct snd_card *card)
1452 spin_lock(&card->files_lock);
1453 if (card->shutdown) {
1454 spin_unlock(&card->files_lock);
1458 spin_unlock(&card->files_lock);
1462 static void hda_unlock_devices(struct snd_card *card)
1464 spin_lock(&card->files_lock);
1466 spin_unlock(&card->files_lock);
1469 int snd_hda_codec_reset(struct hda_codec *codec)
1471 struct snd_card *card = codec->bus->card;
1474 if (hda_lock_devices(card) < 0)
1476 /* check whether the codec isn't used by any mixer or PCM streams */
1477 if (!list_empty(&card->ctl_files)) {
1478 hda_unlock_devices(card);
1481 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1482 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1485 if (cpcm->pcm->streams[0].substream_opened ||
1486 cpcm->pcm->streams[1].substream_opened) {
1487 hda_unlock_devices(card);
1492 /* OK, let it free */
1494 #ifdef CONFIG_SND_HDA_POWER_SAVE
1495 cancel_delayed_work(&codec->power_work);
1496 flush_workqueue(codec->bus->workq);
1498 snd_hda_ctls_clear(codec);
1500 for (i = 0; i < codec->num_pcms; i++) {
1501 if (codec->pcm_info[i].pcm) {
1502 snd_device_free(card, codec->pcm_info[i].pcm);
1503 clear_bit(codec->pcm_info[i].device,
1504 codec->bus->pcm_dev_bits);
1507 if (codec->patch_ops.free)
1508 codec->patch_ops.free(codec);
1509 codec->proc_widget_hook = NULL;
1511 free_hda_cache(&codec->amp_cache);
1512 free_hda_cache(&codec->cmd_cache);
1513 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1514 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1515 /* free only driver_pins so that init_pins + user_pins are restored */
1516 snd_array_free(&codec->driver_pins);
1517 restore_pincfgs(codec);
1518 codec->num_pcms = 0;
1519 codec->pcm_info = NULL;
1520 codec->preset = NULL;
1521 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1522 codec->slave_dig_outs = NULL;
1523 codec->spdif_status_reset = 0;
1524 module_put(codec->owner);
1525 codec->owner = NULL;
1527 /* allow device access again */
1528 hda_unlock_devices(card);
1532 /* create a virtual master control and add slaves */
1533 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1534 unsigned int *tlv, const char **slaves)
1536 struct snd_kcontrol *kctl;
1540 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1543 snd_printdd("No slave found for %s\n", name);
1546 kctl = snd_ctl_make_virtual_master(name, tlv);
1549 err = snd_hda_ctl_add(codec, kctl);
1553 for (s = slaves; *s; s++) {
1554 struct snd_kcontrol *sctl;
1556 sctl = snd_hda_find_mixer_ctl(codec, *s);
1558 snd_printdd("Cannot find slave %s, skipped\n", *s);
1561 err = snd_ctl_add_slave(kctl, sctl);
1567 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1570 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1571 struct snd_ctl_elem_info *uinfo)
1573 int chs = get_amp_channels(kcontrol);
1575 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1576 uinfo->count = chs == 3 ? 2 : 1;
1577 uinfo->value.integer.min = 0;
1578 uinfo->value.integer.max = 1;
1581 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1583 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1584 struct snd_ctl_elem_value *ucontrol)
1586 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1587 hda_nid_t nid = get_amp_nid(kcontrol);
1588 int chs = get_amp_channels(kcontrol);
1589 int dir = get_amp_direction(kcontrol);
1590 int idx = get_amp_index(kcontrol);
1591 long *valp = ucontrol->value.integer.value;
1594 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1595 HDA_AMP_MUTE) ? 0 : 1;
1597 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1598 HDA_AMP_MUTE) ? 0 : 1;
1601 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1603 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1604 struct snd_ctl_elem_value *ucontrol)
1606 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1607 hda_nid_t nid = get_amp_nid(kcontrol);
1608 int chs = get_amp_channels(kcontrol);
1609 int dir = get_amp_direction(kcontrol);
1610 int idx = get_amp_index(kcontrol);
1611 long *valp = ucontrol->value.integer.value;
1614 snd_hda_power_up(codec);
1616 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1618 *valp ? 0 : HDA_AMP_MUTE);
1622 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1624 *valp ? 0 : HDA_AMP_MUTE);
1625 #ifdef CONFIG_SND_HDA_POWER_SAVE
1626 if (codec->patch_ops.check_power_status)
1627 codec->patch_ops.check_power_status(codec, nid);
1629 snd_hda_power_down(codec);
1632 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1635 * bound volume controls
1637 * bind multiple volumes (# indices, from 0)
1640 #define AMP_VAL_IDX_SHIFT 19
1641 #define AMP_VAL_IDX_MASK (0x0f<<19)
1643 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1644 struct snd_ctl_elem_value *ucontrol)
1646 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1650 mutex_lock(&codec->control_mutex);
1651 pval = kcontrol->private_value;
1652 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1653 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1654 kcontrol->private_value = pval;
1655 mutex_unlock(&codec->control_mutex);
1658 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1660 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1661 struct snd_ctl_elem_value *ucontrol)
1663 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1665 int i, indices, err = 0, change = 0;
1667 mutex_lock(&codec->control_mutex);
1668 pval = kcontrol->private_value;
1669 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1670 for (i = 0; i < indices; i++) {
1671 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1672 (i << AMP_VAL_IDX_SHIFT);
1673 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1678 kcontrol->private_value = pval;
1679 mutex_unlock(&codec->control_mutex);
1680 return err < 0 ? err : change;
1682 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1685 * generic bound volume/swtich controls
1687 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1688 struct snd_ctl_elem_info *uinfo)
1690 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1691 struct hda_bind_ctls *c;
1694 mutex_lock(&codec->control_mutex);
1695 c = (struct hda_bind_ctls *)kcontrol->private_value;
1696 kcontrol->private_value = *c->values;
1697 err = c->ops->info(kcontrol, uinfo);
1698 kcontrol->private_value = (long)c;
1699 mutex_unlock(&codec->control_mutex);
1702 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1704 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1705 struct snd_ctl_elem_value *ucontrol)
1707 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1708 struct hda_bind_ctls *c;
1711 mutex_lock(&codec->control_mutex);
1712 c = (struct hda_bind_ctls *)kcontrol->private_value;
1713 kcontrol->private_value = *c->values;
1714 err = c->ops->get(kcontrol, ucontrol);
1715 kcontrol->private_value = (long)c;
1716 mutex_unlock(&codec->control_mutex);
1719 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1721 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1722 struct snd_ctl_elem_value *ucontrol)
1724 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1725 struct hda_bind_ctls *c;
1726 unsigned long *vals;
1727 int err = 0, change = 0;
1729 mutex_lock(&codec->control_mutex);
1730 c = (struct hda_bind_ctls *)kcontrol->private_value;
1731 for (vals = c->values; *vals; vals++) {
1732 kcontrol->private_value = *vals;
1733 err = c->ops->put(kcontrol, ucontrol);
1738 kcontrol->private_value = (long)c;
1739 mutex_unlock(&codec->control_mutex);
1740 return err < 0 ? err : change;
1742 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1744 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1745 unsigned int size, unsigned int __user *tlv)
1747 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1748 struct hda_bind_ctls *c;
1751 mutex_lock(&codec->control_mutex);
1752 c = (struct hda_bind_ctls *)kcontrol->private_value;
1753 kcontrol->private_value = *c->values;
1754 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1755 kcontrol->private_value = (long)c;
1756 mutex_unlock(&codec->control_mutex);
1759 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1761 struct hda_ctl_ops snd_hda_bind_vol = {
1762 .info = snd_hda_mixer_amp_volume_info,
1763 .get = snd_hda_mixer_amp_volume_get,
1764 .put = snd_hda_mixer_amp_volume_put,
1765 .tlv = snd_hda_mixer_amp_tlv
1767 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1769 struct hda_ctl_ops snd_hda_bind_sw = {
1770 .info = snd_hda_mixer_amp_switch_info,
1771 .get = snd_hda_mixer_amp_switch_get,
1772 .put = snd_hda_mixer_amp_switch_put,
1773 .tlv = snd_hda_mixer_amp_tlv
1775 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1778 * SPDIF out controls
1781 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1782 struct snd_ctl_elem_info *uinfo)
1784 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1789 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1790 struct snd_ctl_elem_value *ucontrol)
1792 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1793 IEC958_AES0_NONAUDIO |
1794 IEC958_AES0_CON_EMPHASIS_5015 |
1795 IEC958_AES0_CON_NOT_COPYRIGHT;
1796 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1797 IEC958_AES1_CON_ORIGINAL;
1801 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1802 struct snd_ctl_elem_value *ucontrol)
1804 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1805 IEC958_AES0_NONAUDIO |
1806 IEC958_AES0_PRO_EMPHASIS_5015;
1810 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1811 struct snd_ctl_elem_value *ucontrol)
1813 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1815 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1816 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1817 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1818 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1823 /* convert from SPDIF status bits to HDA SPDIF bits
1824 * bit 0 (DigEn) is always set zero (to be filled later)
1826 static unsigned short convert_from_spdif_status(unsigned int sbits)
1828 unsigned short val = 0;
1830 if (sbits & IEC958_AES0_PROFESSIONAL)
1831 val |= AC_DIG1_PROFESSIONAL;
1832 if (sbits & IEC958_AES0_NONAUDIO)
1833 val |= AC_DIG1_NONAUDIO;
1834 if (sbits & IEC958_AES0_PROFESSIONAL) {
1835 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1836 IEC958_AES0_PRO_EMPHASIS_5015)
1837 val |= AC_DIG1_EMPHASIS;
1839 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1840 IEC958_AES0_CON_EMPHASIS_5015)
1841 val |= AC_DIG1_EMPHASIS;
1842 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1843 val |= AC_DIG1_COPYRIGHT;
1844 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1845 val |= AC_DIG1_LEVEL;
1846 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1851 /* convert to SPDIF status bits from HDA SPDIF bits
1853 static unsigned int convert_to_spdif_status(unsigned short val)
1855 unsigned int sbits = 0;
1857 if (val & AC_DIG1_NONAUDIO)
1858 sbits |= IEC958_AES0_NONAUDIO;
1859 if (val & AC_DIG1_PROFESSIONAL)
1860 sbits |= IEC958_AES0_PROFESSIONAL;
1861 if (sbits & IEC958_AES0_PROFESSIONAL) {
1862 if (sbits & AC_DIG1_EMPHASIS)
1863 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1865 if (val & AC_DIG1_EMPHASIS)
1866 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1867 if (!(val & AC_DIG1_COPYRIGHT))
1868 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1869 if (val & AC_DIG1_LEVEL)
1870 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1871 sbits |= val & (0x7f << 8);
1876 /* set digital convert verbs both for the given NID and its slaves */
1877 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1882 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1883 d = codec->slave_dig_outs;
1887 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1890 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1894 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1896 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1899 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1900 struct snd_ctl_elem_value *ucontrol)
1902 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1903 hda_nid_t nid = kcontrol->private_value;
1907 mutex_lock(&codec->spdif_mutex);
1908 codec->spdif_status = ucontrol->value.iec958.status[0] |
1909 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1910 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1911 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1912 val = convert_from_spdif_status(codec->spdif_status);
1913 val |= codec->spdif_ctls & 1;
1914 change = codec->spdif_ctls != val;
1915 codec->spdif_ctls = val;
1918 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1920 mutex_unlock(&codec->spdif_mutex);
1924 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1926 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1927 struct snd_ctl_elem_value *ucontrol)
1929 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1931 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1935 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1936 struct snd_ctl_elem_value *ucontrol)
1938 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1939 hda_nid_t nid = kcontrol->private_value;
1943 mutex_lock(&codec->spdif_mutex);
1944 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1945 if (ucontrol->value.integer.value[0])
1946 val |= AC_DIG1_ENABLE;
1947 change = codec->spdif_ctls != val;
1949 codec->spdif_ctls = val;
1950 set_dig_out_convert(codec, nid, val & 0xff, -1);
1951 /* unmute amp switch (if any) */
1952 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1953 (val & AC_DIG1_ENABLE))
1954 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1957 mutex_unlock(&codec->spdif_mutex);
1961 static struct snd_kcontrol_new dig_mixes[] = {
1963 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1964 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1965 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1966 .info = snd_hda_spdif_mask_info,
1967 .get = snd_hda_spdif_cmask_get,
1970 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1971 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1972 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1973 .info = snd_hda_spdif_mask_info,
1974 .get = snd_hda_spdif_pmask_get,
1977 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1978 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1979 .info = snd_hda_spdif_mask_info,
1980 .get = snd_hda_spdif_default_get,
1981 .put = snd_hda_spdif_default_put,
1984 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1985 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1986 .info = snd_hda_spdif_out_switch_info,
1987 .get = snd_hda_spdif_out_switch_get,
1988 .put = snd_hda_spdif_out_switch_put,
1993 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1996 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1997 * @codec: the HDA codec
1998 * @nid: audio out widget NID
2000 * Creates controls related with the SPDIF output.
2001 * Called from each patch supporting the SPDIF out.
2003 * Returns 0 if successful, or a negative error code.
2005 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2008 struct snd_kcontrol *kctl;
2009 struct snd_kcontrol_new *dig_mix;
2012 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2013 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2017 if (idx >= SPDIF_MAX_IDX) {
2018 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2021 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2022 kctl = snd_ctl_new1(dig_mix, codec);
2025 kctl->id.index = idx;
2026 kctl->private_value = nid;
2027 err = snd_hda_ctl_add(codec, kctl);
2032 snd_hda_codec_read(codec, nid, 0,
2033 AC_VERB_GET_DIGI_CONVERT_1, 0);
2034 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2037 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2040 * SPDIF sharing with analog output
2042 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2043 struct snd_ctl_elem_value *ucontrol)
2045 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2046 ucontrol->value.integer.value[0] = mout->share_spdif;
2050 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2051 struct snd_ctl_elem_value *ucontrol)
2053 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2054 mout->share_spdif = !!ucontrol->value.integer.value[0];
2058 static struct snd_kcontrol_new spdif_share_sw = {
2059 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2060 .name = "IEC958 Default PCM Playback Switch",
2061 .info = snd_ctl_boolean_mono_info,
2062 .get = spdif_share_sw_get,
2063 .put = spdif_share_sw_put,
2066 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2067 struct hda_multi_out *mout)
2069 if (!mout->dig_out_nid)
2071 /* ATTENTION: here mout is passed as private_data, instead of codec */
2072 return snd_hda_ctl_add(codec,
2073 snd_ctl_new1(&spdif_share_sw, mout));
2075 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2081 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2083 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2084 struct snd_ctl_elem_value *ucontrol)
2086 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2088 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2092 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2093 struct snd_ctl_elem_value *ucontrol)
2095 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2096 hda_nid_t nid = kcontrol->private_value;
2097 unsigned int val = !!ucontrol->value.integer.value[0];
2100 mutex_lock(&codec->spdif_mutex);
2101 change = codec->spdif_in_enable != val;
2103 codec->spdif_in_enable = val;
2104 snd_hda_codec_write_cache(codec, nid, 0,
2105 AC_VERB_SET_DIGI_CONVERT_1, val);
2107 mutex_unlock(&codec->spdif_mutex);
2111 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2112 struct snd_ctl_elem_value *ucontrol)
2114 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2115 hda_nid_t nid = kcontrol->private_value;
2119 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2120 sbits = convert_to_spdif_status(val);
2121 ucontrol->value.iec958.status[0] = sbits;
2122 ucontrol->value.iec958.status[1] = sbits >> 8;
2123 ucontrol->value.iec958.status[2] = sbits >> 16;
2124 ucontrol->value.iec958.status[3] = sbits >> 24;
2128 static struct snd_kcontrol_new dig_in_ctls[] = {
2130 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2131 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2132 .info = snd_hda_spdif_in_switch_info,
2133 .get = snd_hda_spdif_in_switch_get,
2134 .put = snd_hda_spdif_in_switch_put,
2137 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2138 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2139 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2140 .info = snd_hda_spdif_mask_info,
2141 .get = snd_hda_spdif_in_status_get,
2147 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2148 * @codec: the HDA codec
2149 * @nid: audio in widget NID
2151 * Creates controls related with the SPDIF input.
2152 * Called from each patch supporting the SPDIF in.
2154 * Returns 0 if successful, or a negative error code.
2156 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2159 struct snd_kcontrol *kctl;
2160 struct snd_kcontrol_new *dig_mix;
2163 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2164 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2168 if (idx >= SPDIF_MAX_IDX) {
2169 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2172 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2173 kctl = snd_ctl_new1(dig_mix, codec);
2176 kctl->private_value = nid;
2177 err = snd_hda_ctl_add(codec, kctl);
2181 codec->spdif_in_enable =
2182 snd_hda_codec_read(codec, nid, 0,
2183 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2187 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2189 #ifdef SND_HDA_NEEDS_RESUME
2194 /* build a 32bit cache key with the widget id and the command parameter */
2195 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2196 #define get_cmd_cache_nid(key) ((key) & 0xff)
2197 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2200 * snd_hda_codec_write_cache - send a single command with caching
2201 * @codec: the HDA codec
2202 * @nid: NID to send the command
2203 * @direct: direct flag
2204 * @verb: the verb to send
2205 * @parm: the parameter for the verb
2207 * Send a single command without waiting for response.
2209 * Returns 0 if successful, or a negative error code.
2211 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2212 int direct, unsigned int verb, unsigned int parm)
2214 struct hda_bus *bus = codec->bus;
2218 res = make_codec_cmd(codec, nid, direct, verb, parm);
2219 snd_hda_power_up(codec);
2220 mutex_lock(&bus->cmd_mutex);
2221 err = bus->ops.command(bus, res);
2223 struct hda_cache_head *c;
2224 u32 key = build_cmd_cache_key(nid, verb);
2225 c = get_alloc_hash(&codec->cmd_cache, key);
2229 mutex_unlock(&bus->cmd_mutex);
2230 snd_hda_power_down(codec);
2233 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2235 /* resume the all commands from the cache */
2236 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2238 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2241 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2242 u32 key = buffer->key;
2245 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2246 get_cmd_cache_cmd(key), buffer->val);
2249 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2252 * snd_hda_sequence_write_cache - sequence writes with caching
2253 * @codec: the HDA codec
2254 * @seq: VERB array to send
2256 * Send the commands sequentially from the given array.
2257 * Thte commands are recorded on cache for power-save and resume.
2258 * The array must be terminated with NID=0.
2260 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2261 const struct hda_verb *seq)
2263 for (; seq->nid; seq++)
2264 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2267 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2268 #endif /* SND_HDA_NEEDS_RESUME */
2271 * set power state of the codec
2273 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2274 unsigned int power_state)
2279 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2281 msleep(10); /* partial workaround for "azx_get_response timeout" */
2283 nid = codec->start_nid;
2284 for (i = 0; i < codec->num_nodes; i++, nid++) {
2285 unsigned int wcaps = get_wcaps(codec, nid);
2286 if (wcaps & AC_WCAP_POWER) {
2287 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2289 if (wid_type == AC_WID_PIN) {
2290 unsigned int pincap;
2292 * don't power down the widget if it controls
2293 * eapd and EAPD_BTLENABLE is set.
2295 pincap = snd_hda_param_read(codec, nid,
2297 if (pincap & AC_PINCAP_EAPD) {
2298 int eapd = snd_hda_codec_read(codec,
2300 AC_VERB_GET_EAPD_BTLENABLE, 0);
2302 if (power_state == AC_PWRST_D3 && eapd)
2306 snd_hda_codec_write(codec, nid, 0,
2307 AC_VERB_SET_POWER_STATE,
2312 if (power_state == AC_PWRST_D0) {
2313 unsigned long end_time;
2316 /* wait until the codec reachs to D0 */
2317 end_time = jiffies + msecs_to_jiffies(500);
2319 state = snd_hda_codec_read(codec, fg, 0,
2320 AC_VERB_GET_POWER_STATE, 0);
2321 if (state == power_state)
2324 } while (time_after_eq(end_time, jiffies));
2328 #ifdef CONFIG_SND_HDA_HWDEP
2329 /* execute additional init verbs */
2330 static void hda_exec_init_verbs(struct hda_codec *codec)
2332 if (codec->init_verbs.list)
2333 snd_hda_sequence_write(codec, codec->init_verbs.list);
2336 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2339 #ifdef SND_HDA_NEEDS_RESUME
2341 * call suspend and power-down; used both from PM and power-save
2343 static void hda_call_codec_suspend(struct hda_codec *codec)
2345 if (codec->patch_ops.suspend)
2346 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2347 hda_set_power_state(codec,
2348 codec->afg ? codec->afg : codec->mfg,
2350 #ifdef CONFIG_SND_HDA_POWER_SAVE
2351 cancel_delayed_work(&codec->power_work);
2352 codec->power_on = 0;
2353 codec->power_transition = 0;
2358 * kick up codec; used both from PM and power-save
2360 static void hda_call_codec_resume(struct hda_codec *codec)
2362 hda_set_power_state(codec,
2363 codec->afg ? codec->afg : codec->mfg,
2365 restore_pincfgs(codec); /* restore all current pin configs */
2366 hda_exec_init_verbs(codec);
2367 if (codec->patch_ops.resume)
2368 codec->patch_ops.resume(codec);
2370 if (codec->patch_ops.init)
2371 codec->patch_ops.init(codec);
2372 snd_hda_codec_resume_amp(codec);
2373 snd_hda_codec_resume_cache(codec);
2376 #endif /* SND_HDA_NEEDS_RESUME */
2380 * snd_hda_build_controls - build mixer controls
2383 * Creates mixer controls for each codec included in the bus.
2385 * Returns 0 if successful, otherwise a negative error code.
2387 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2389 struct hda_codec *codec;
2391 list_for_each_entry(codec, &bus->codec_list, list) {
2392 int err = snd_hda_codec_build_controls(codec);
2394 printk(KERN_ERR "hda_codec: cannot build controls"
2395 "for #%d (error %d)\n", codec->addr, err);
2396 err = snd_hda_codec_reset(codec);
2399 "hda_codec: cannot revert codec\n");
2406 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2408 int snd_hda_codec_build_controls(struct hda_codec *codec)
2411 /* fake as if already powered-on */
2412 hda_keep_power_on(codec);
2414 hda_set_power_state(codec,
2415 codec->afg ? codec->afg : codec->mfg,
2417 hda_exec_init_verbs(codec);
2418 /* continue to initialize... */
2419 if (codec->patch_ops.init)
2420 err = codec->patch_ops.init(codec);
2421 if (!err && codec->patch_ops.build_controls)
2422 err = codec->patch_ops.build_controls(codec);
2423 snd_hda_power_down(codec);
2432 struct hda_rate_tbl {
2434 unsigned int alsa_bits;
2435 unsigned int hda_fmt;
2438 static struct hda_rate_tbl rate_bits[] = {
2439 /* rate in Hz, ALSA rate bitmask, HDA format value */
2441 /* autodetected value used in snd_hda_query_supported_pcm */
2442 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2443 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2444 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2445 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2446 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2447 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2448 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2449 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2450 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2451 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2452 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2453 #define AC_PAR_PCM_RATE_BITS 11
2454 /* up to bits 10, 384kHZ isn't supported properly */
2456 /* not autodetected value */
2457 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2459 { 0 } /* terminator */
2463 * snd_hda_calc_stream_format - calculate format bitset
2464 * @rate: the sample rate
2465 * @channels: the number of channels
2466 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2467 * @maxbps: the max. bps
2469 * Calculate the format bitset from the given rate, channels and th PCM format.
2471 * Return zero if invalid.
2473 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2474 unsigned int channels,
2475 unsigned int format,
2476 unsigned int maxbps)
2479 unsigned int val = 0;
2481 for (i = 0; rate_bits[i].hz; i++)
2482 if (rate_bits[i].hz == rate) {
2483 val = rate_bits[i].hda_fmt;
2486 if (!rate_bits[i].hz) {
2487 snd_printdd("invalid rate %d\n", rate);
2491 if (channels == 0 || channels > 8) {
2492 snd_printdd("invalid channels %d\n", channels);
2495 val |= channels - 1;
2497 switch (snd_pcm_format_width(format)) {
2498 case 8: val |= 0x00; break;
2499 case 16: val |= 0x10; break;
2505 else if (maxbps >= 24)
2511 snd_printdd("invalid format width %d\n",
2512 snd_pcm_format_width(format));
2518 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2521 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2522 * @codec: the HDA codec
2523 * @nid: NID to query
2524 * @ratesp: the pointer to store the detected rate bitflags
2525 * @formatsp: the pointer to store the detected formats
2526 * @bpsp: the pointer to store the detected format widths
2528 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2529 * or @bsps argument is ignored.
2531 * Returns 0 if successful, otherwise a negative error code.
2533 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2534 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2537 unsigned int val, streams;
2540 if (nid != codec->afg &&
2541 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2542 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2547 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2551 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2553 rates |= rate_bits[i].alsa_bits;
2558 if (formatsp || bpsp) {
2563 wcaps = get_wcaps(codec, nid);
2564 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2568 streams = snd_hda_param_read(codec, codec->afg,
2575 if (streams & AC_SUPFMT_PCM) {
2576 if (val & AC_SUPPCM_BITS_8) {
2577 formats |= SNDRV_PCM_FMTBIT_U8;
2580 if (val & AC_SUPPCM_BITS_16) {
2581 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2584 if (wcaps & AC_WCAP_DIGITAL) {
2585 if (val & AC_SUPPCM_BITS_32)
2586 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2587 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2588 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2589 if (val & AC_SUPPCM_BITS_24)
2591 else if (val & AC_SUPPCM_BITS_20)
2593 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2594 AC_SUPPCM_BITS_32)) {
2595 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2596 if (val & AC_SUPPCM_BITS_32)
2598 else if (val & AC_SUPPCM_BITS_24)
2600 else if (val & AC_SUPPCM_BITS_20)
2604 else if (streams == AC_SUPFMT_FLOAT32) {
2605 /* should be exclusive */
2606 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2608 } else if (streams == AC_SUPFMT_AC3) {
2609 /* should be exclusive */
2610 /* temporary hack: we have still no proper support
2611 * for the direct AC3 stream...
2613 formats |= SNDRV_PCM_FMTBIT_U8;
2617 *formatsp = formats;
2626 * snd_hda_is_supported_format - check whether the given node supports
2629 * Returns 1 if supported, 0 if not.
2631 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2632 unsigned int format)
2635 unsigned int val = 0, rate, stream;
2637 if (nid != codec->afg &&
2638 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2639 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2644 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2649 rate = format & 0xff00;
2650 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2651 if (rate_bits[i].hda_fmt == rate) {
2656 if (i >= AC_PAR_PCM_RATE_BITS)
2659 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2662 if (!stream && nid != codec->afg)
2663 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2664 if (!stream || stream == -1)
2667 if (stream & AC_SUPFMT_PCM) {
2668 switch (format & 0xf0) {
2670 if (!(val & AC_SUPPCM_BITS_8))
2674 if (!(val & AC_SUPPCM_BITS_16))
2678 if (!(val & AC_SUPPCM_BITS_20))
2682 if (!(val & AC_SUPPCM_BITS_24))
2686 if (!(val & AC_SUPPCM_BITS_32))
2693 /* FIXME: check for float32 and AC3? */
2698 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2703 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2704 struct hda_codec *codec,
2705 struct snd_pcm_substream *substream)
2710 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2711 struct hda_codec *codec,
2712 unsigned int stream_tag,
2713 unsigned int format,
2714 struct snd_pcm_substream *substream)
2716 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2720 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2721 struct hda_codec *codec,
2722 struct snd_pcm_substream *substream)
2724 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2728 static int set_pcm_default_values(struct hda_codec *codec,
2729 struct hda_pcm_stream *info)
2731 /* query support PCM information from the given NID */
2732 if (info->nid && (!info->rates || !info->formats)) {
2733 snd_hda_query_supported_pcm(codec, info->nid,
2734 info->rates ? NULL : &info->rates,
2735 info->formats ? NULL : &info->formats,
2736 info->maxbps ? NULL : &info->maxbps);
2738 if (info->ops.open == NULL)
2739 info->ops.open = hda_pcm_default_open_close;
2740 if (info->ops.close == NULL)
2741 info->ops.close = hda_pcm_default_open_close;
2742 if (info->ops.prepare == NULL) {
2743 if (snd_BUG_ON(!info->nid))
2745 info->ops.prepare = hda_pcm_default_prepare;
2747 if (info->ops.cleanup == NULL) {
2748 if (snd_BUG_ON(!info->nid))
2750 info->ops.cleanup = hda_pcm_default_cleanup;
2756 * get the empty PCM device number to assign
2758 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2760 static const char *dev_name[HDA_PCM_NTYPES] = {
2761 "Audio", "SPDIF", "HDMI", "Modem"
2763 /* starting device index for each PCM type */
2764 static int dev_idx[HDA_PCM_NTYPES] = {
2765 [HDA_PCM_TYPE_AUDIO] = 0,
2766 [HDA_PCM_TYPE_SPDIF] = 1,
2767 [HDA_PCM_TYPE_HDMI] = 3,
2768 [HDA_PCM_TYPE_MODEM] = 6
2770 /* normal audio device indices; not linear to keep compatibility */
2771 static int audio_idx[4] = { 0, 2, 4, 5 };
2775 case HDA_PCM_TYPE_AUDIO:
2776 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2778 if (!test_bit(dev, bus->pcm_dev_bits))
2781 if (i >= ARRAY_SIZE(audio_idx)) {
2782 snd_printk(KERN_WARNING "Too many audio devices\n");
2786 case HDA_PCM_TYPE_SPDIF:
2787 case HDA_PCM_TYPE_HDMI:
2788 case HDA_PCM_TYPE_MODEM:
2789 dev = dev_idx[type];
2790 if (test_bit(dev, bus->pcm_dev_bits)) {
2791 snd_printk(KERN_WARNING "%s already defined\n",
2797 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2800 set_bit(dev, bus->pcm_dev_bits);
2805 * attach a new PCM stream
2807 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2809 struct hda_bus *bus = codec->bus;
2810 struct hda_pcm_stream *info;
2813 if (snd_BUG_ON(!pcm->name))
2815 for (stream = 0; stream < 2; stream++) {
2816 info = &pcm->stream[stream];
2817 if (info->substreams) {
2818 err = set_pcm_default_values(codec, info);
2823 return bus->ops.attach_pcm(bus, codec, pcm);
2826 /* assign all PCMs of the given codec */
2827 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2832 if (!codec->num_pcms) {
2833 if (!codec->patch_ops.build_pcms)
2835 err = codec->patch_ops.build_pcms(codec);
2837 printk(KERN_ERR "hda_codec: cannot build PCMs"
2838 "for #%d (error %d)\n", codec->addr, err);
2839 err = snd_hda_codec_reset(codec);
2842 "hda_codec: cannot revert codec\n");
2847 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2848 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2851 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2852 continue; /* no substreams assigned */
2855 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2857 continue; /* no fatal error */
2859 err = snd_hda_attach_pcm(codec, cpcm);
2861 printk(KERN_ERR "hda_codec: cannot attach "
2862 "PCM stream %d for codec #%d\n",
2864 continue; /* no fatal error */
2872 * snd_hda_build_pcms - build PCM information
2875 * Create PCM information for each codec included in the bus.
2877 * The build_pcms codec patch is requested to set up codec->num_pcms and
2878 * codec->pcm_info properly. The array is referred by the top-level driver
2879 * to create its PCM instances.
2880 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2883 * At least, substreams, channels_min and channels_max must be filled for
2884 * each stream. substreams = 0 indicates that the stream doesn't exist.
2885 * When rates and/or formats are zero, the supported values are queried
2886 * from the given nid. The nid is used also by the default ops.prepare
2887 * and ops.cleanup callbacks.
2889 * The driver needs to call ops.open in its open callback. Similarly,
2890 * ops.close is supposed to be called in the close callback.
2891 * ops.prepare should be called in the prepare or hw_params callback
2892 * with the proper parameters for set up.
2893 * ops.cleanup should be called in hw_free for clean up of streams.
2895 * This function returns 0 if successfull, or a negative error code.
2897 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2899 struct hda_codec *codec;
2901 list_for_each_entry(codec, &bus->codec_list, list) {
2902 int err = snd_hda_codec_build_pcms(codec);
2908 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2911 * snd_hda_check_board_config - compare the current codec with the config table
2912 * @codec: the HDA codec
2913 * @num_configs: number of config enums
2914 * @models: array of model name strings
2915 * @tbl: configuration table, terminated by null entries
2917 * Compares the modelname or PCI subsystem id of the current codec with the
2918 * given configuration table. If a matching entry is found, returns its
2919 * config value (supposed to be 0 or positive).
2921 * If no entries are matching, the function returns a negative value.
2923 int snd_hda_check_board_config(struct hda_codec *codec,
2924 int num_configs, const char **models,
2925 const struct snd_pci_quirk *tbl)
2927 if (codec->modelname && models) {
2929 for (i = 0; i < num_configs; i++) {
2931 !strcmp(codec->modelname, models[i])) {
2932 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2933 "selected\n", models[i]);
2939 if (!codec->bus->pci || !tbl)
2942 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2945 if (tbl->value >= 0 && tbl->value < num_configs) {
2946 #ifdef CONFIG_SND_DEBUG_VERBOSE
2948 const char *model = NULL;
2950 model = models[tbl->value];
2952 sprintf(tmp, "#%d", tbl->value);
2955 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2956 "for config %x:%x (%s)\n",
2957 model, tbl->subvendor, tbl->subdevice,
2958 (tbl->name ? tbl->name : "Unknown device"));
2964 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
2967 * snd_hda_check_board_codec_sid_config - compare the current codec
2968 subsystem ID with the
2971 This is important for Gateway notebooks with SB450 HDA Audio
2972 where the vendor ID of the PCI device is:
2973 ATI Technologies Inc SB450 HDA Audio [1002:437b]
2974 and the vendor/subvendor are found only at the codec.
2976 * @codec: the HDA codec
2977 * @num_configs: number of config enums
2978 * @models: array of model name strings
2979 * @tbl: configuration table, terminated by null entries
2981 * Compares the modelname or PCI subsystem id of the current codec with the
2982 * given configuration table. If a matching entry is found, returns its
2983 * config value (supposed to be 0 or positive).
2985 * If no entries are matching, the function returns a negative value.
2987 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
2988 int num_configs, const char **models,
2989 const struct snd_pci_quirk *tbl)
2991 const struct snd_pci_quirk *q;
2993 /* Search for codec ID */
2994 for (q = tbl; q->subvendor; q++) {
2995 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
2997 if (vendorid == codec->subsystem_id)
3006 if (tbl->value >= 0 && tbl->value < num_configs) {
3007 #ifdef CONFIG_SND_DEBUG_DETECT
3009 const char *model = NULL;
3011 model = models[tbl->value];
3013 sprintf(tmp, "#%d", tbl->value);
3016 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3017 "for config %x:%x (%s)\n",
3018 model, tbl->subvendor, tbl->subdevice,
3019 (tbl->name ? tbl->name : "Unknown device"));
3025 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3028 * snd_hda_add_new_ctls - create controls from the array
3029 * @codec: the HDA codec
3030 * @knew: the array of struct snd_kcontrol_new
3032 * This helper function creates and add new controls in the given array.
3033 * The array must be terminated with an empty entry as terminator.
3035 * Returns 0 if successful, or a negative error code.
3037 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3041 for (; knew->name; knew++) {
3042 struct snd_kcontrol *kctl;
3043 kctl = snd_ctl_new1(knew, codec);
3046 err = snd_hda_ctl_add(codec, kctl);
3050 kctl = snd_ctl_new1(knew, codec);
3053 kctl->id.device = codec->addr;
3054 err = snd_hda_ctl_add(codec, kctl);
3061 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3063 #ifdef CONFIG_SND_HDA_POWER_SAVE
3064 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3065 unsigned int power_state);
3067 static void hda_power_work(struct work_struct *work)
3069 struct hda_codec *codec =
3070 container_of(work, struct hda_codec, power_work.work);
3071 struct hda_bus *bus = codec->bus;
3073 if (!codec->power_on || codec->power_count) {
3074 codec->power_transition = 0;
3078 hda_call_codec_suspend(codec);
3079 if (bus->ops.pm_notify)
3080 bus->ops.pm_notify(bus);
3083 static void hda_keep_power_on(struct hda_codec *codec)
3085 codec->power_count++;
3086 codec->power_on = 1;
3089 void snd_hda_power_up(struct hda_codec *codec)
3091 struct hda_bus *bus = codec->bus;
3093 codec->power_count++;
3094 if (codec->power_on || codec->power_transition)
3097 codec->power_on = 1;
3098 if (bus->ops.pm_notify)
3099 bus->ops.pm_notify(bus);
3100 hda_call_codec_resume(codec);
3101 cancel_delayed_work(&codec->power_work);
3102 codec->power_transition = 0;
3104 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3106 #define power_save(codec) \
3107 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3109 #define power_save(codec) \
3110 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3112 void snd_hda_power_down(struct hda_codec *codec)
3114 --codec->power_count;
3115 if (!codec->power_on || codec->power_count || codec->power_transition)
3117 if (power_save(codec)) {
3118 codec->power_transition = 1; /* avoid reentrance */
3119 queue_delayed_work(codec->bus->workq, &codec->power_work,
3120 msecs_to_jiffies(power_save(codec) * 1000));
3123 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3125 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3126 struct hda_loopback_check *check,
3129 struct hda_amp_list *p;
3132 if (!check->amplist)
3134 for (p = check->amplist; p->nid; p++) {
3139 return 0; /* nothing changed */
3141 for (p = check->amplist; p->nid; p++) {
3142 for (ch = 0; ch < 2; ch++) {
3143 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3145 if (!(v & HDA_AMP_MUTE) && v > 0) {
3146 if (!check->power_on) {
3147 check->power_on = 1;
3148 snd_hda_power_up(codec);
3154 if (check->power_on) {
3155 check->power_on = 0;
3156 snd_hda_power_down(codec);
3160 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3164 * Channel mode helper
3166 int snd_hda_ch_mode_info(struct hda_codec *codec,
3167 struct snd_ctl_elem_info *uinfo,
3168 const struct hda_channel_mode *chmode,
3171 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3173 uinfo->value.enumerated.items = num_chmodes;
3174 if (uinfo->value.enumerated.item >= num_chmodes)
3175 uinfo->value.enumerated.item = num_chmodes - 1;
3176 sprintf(uinfo->value.enumerated.name, "%dch",
3177 chmode[uinfo->value.enumerated.item].channels);
3180 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3182 int snd_hda_ch_mode_get(struct hda_codec *codec,
3183 struct snd_ctl_elem_value *ucontrol,
3184 const struct hda_channel_mode *chmode,
3190 for (i = 0; i < num_chmodes; i++) {
3191 if (max_channels == chmode[i].channels) {
3192 ucontrol->value.enumerated.item[0] = i;
3198 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3200 int snd_hda_ch_mode_put(struct hda_codec *codec,
3201 struct snd_ctl_elem_value *ucontrol,
3202 const struct hda_channel_mode *chmode,
3208 mode = ucontrol->value.enumerated.item[0];
3209 if (mode >= num_chmodes)
3211 if (*max_channelsp == chmode[mode].channels)
3213 /* change the current channel setting */
3214 *max_channelsp = chmode[mode].channels;
3215 if (chmode[mode].sequence)
3216 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3219 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3224 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3225 struct snd_ctl_elem_info *uinfo)
3229 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3231 uinfo->value.enumerated.items = imux->num_items;
3232 if (!imux->num_items)
3234 index = uinfo->value.enumerated.item;
3235 if (index >= imux->num_items)
3236 index = imux->num_items - 1;
3237 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3240 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3242 int snd_hda_input_mux_put(struct hda_codec *codec,
3243 const struct hda_input_mux *imux,
3244 struct snd_ctl_elem_value *ucontrol,
3246 unsigned int *cur_val)
3250 if (!imux->num_items)
3252 idx = ucontrol->value.enumerated.item[0];
3253 if (idx >= imux->num_items)
3254 idx = imux->num_items - 1;
3255 if (*cur_val == idx)
3257 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3258 imux->items[idx].index);
3262 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3266 * Multi-channel / digital-out PCM helper functions
3269 /* setup SPDIF output stream */
3270 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3271 unsigned int stream_tag, unsigned int format)
3273 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3274 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3275 set_dig_out_convert(codec, nid,
3276 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3278 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3279 if (codec->slave_dig_outs) {
3281 for (d = codec->slave_dig_outs; *d; d++)
3282 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3285 /* turn on again (if needed) */
3286 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3287 set_dig_out_convert(codec, nid,
3288 codec->spdif_ctls & 0xff, -1);
3291 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3293 snd_hda_codec_cleanup_stream(codec, nid);
3294 if (codec->slave_dig_outs) {
3296 for (d = codec->slave_dig_outs; *d; d++)
3297 snd_hda_codec_cleanup_stream(codec, *d);
3302 * open the digital out in the exclusive mode
3304 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3305 struct hda_multi_out *mout)
3307 mutex_lock(&codec->spdif_mutex);
3308 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3309 /* already opened as analog dup; reset it once */
3310 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3311 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3312 mutex_unlock(&codec->spdif_mutex);
3315 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3317 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3318 struct hda_multi_out *mout,
3319 unsigned int stream_tag,
3320 unsigned int format,
3321 struct snd_pcm_substream *substream)
3323 mutex_lock(&codec->spdif_mutex);
3324 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3325 mutex_unlock(&codec->spdif_mutex);
3328 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3330 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3331 struct hda_multi_out *mout)
3333 mutex_lock(&codec->spdif_mutex);
3334 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3335 mutex_unlock(&codec->spdif_mutex);
3338 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3341 * release the digital out
3343 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3344 struct hda_multi_out *mout)
3346 mutex_lock(&codec->spdif_mutex);
3347 mout->dig_out_used = 0;
3348 mutex_unlock(&codec->spdif_mutex);
3351 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3354 * set up more restrictions for analog out
3356 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3357 struct hda_multi_out *mout,
3358 struct snd_pcm_substream *substream,
3359 struct hda_pcm_stream *hinfo)
3361 struct snd_pcm_runtime *runtime = substream->runtime;
3362 runtime->hw.channels_max = mout->max_channels;
3363 if (mout->dig_out_nid) {
3364 if (!mout->analog_rates) {
3365 mout->analog_rates = hinfo->rates;
3366 mout->analog_formats = hinfo->formats;
3367 mout->analog_maxbps = hinfo->maxbps;
3369 runtime->hw.rates = mout->analog_rates;
3370 runtime->hw.formats = mout->analog_formats;
3371 hinfo->maxbps = mout->analog_maxbps;
3373 if (!mout->spdif_rates) {
3374 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3376 &mout->spdif_formats,
3377 &mout->spdif_maxbps);
3379 mutex_lock(&codec->spdif_mutex);
3380 if (mout->share_spdif) {
3381 runtime->hw.rates &= mout->spdif_rates;
3382 runtime->hw.formats &= mout->spdif_formats;
3383 if (mout->spdif_maxbps < hinfo->maxbps)
3384 hinfo->maxbps = mout->spdif_maxbps;
3386 mutex_unlock(&codec->spdif_mutex);
3388 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3389 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3391 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3394 * set up the i/o for analog out
3395 * when the digital out is available, copy the front out to digital out, too.
3397 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3398 struct hda_multi_out *mout,
3399 unsigned int stream_tag,
3400 unsigned int format,
3401 struct snd_pcm_substream *substream)
3403 hda_nid_t *nids = mout->dac_nids;
3404 int chs = substream->runtime->channels;
3407 mutex_lock(&codec->spdif_mutex);
3408 if (mout->dig_out_nid && mout->share_spdif &&
3409 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3411 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3413 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3414 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3415 setup_dig_out_stream(codec, mout->dig_out_nid,
3416 stream_tag, format);
3418 mout->dig_out_used = 0;
3419 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3422 mutex_unlock(&codec->spdif_mutex);
3425 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3427 if (!mout->no_share_stream &&
3428 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3429 /* headphone out will just decode front left/right (stereo) */
3430 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3432 /* extra outputs copied from front */
3433 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3434 if (!mout->no_share_stream && mout->extra_out_nid[i])
3435 snd_hda_codec_setup_stream(codec,
3436 mout->extra_out_nid[i],
3437 stream_tag, 0, format);
3440 for (i = 1; i < mout->num_dacs; i++) {
3441 if (chs >= (i + 1) * 2) /* independent out */
3442 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3444 else if (!mout->no_share_stream) /* copy front */
3445 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3450 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3453 * clean up the setting for analog out
3455 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3456 struct hda_multi_out *mout)
3458 hda_nid_t *nids = mout->dac_nids;
3461 for (i = 0; i < mout->num_dacs; i++)
3462 snd_hda_codec_cleanup_stream(codec, nids[i]);
3464 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3465 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3466 if (mout->extra_out_nid[i])
3467 snd_hda_codec_cleanup_stream(codec,
3468 mout->extra_out_nid[i]);
3469 mutex_lock(&codec->spdif_mutex);
3470 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3471 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3472 mout->dig_out_used = 0;
3474 mutex_unlock(&codec->spdif_mutex);
3477 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3480 * Helper for automatic pin configuration
3483 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3485 for (; *list; list++)
3493 * Sort an associated group of pins according to their sequence numbers.
3495 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3502 for (i = 0; i < num_pins; i++) {
3503 for (j = i + 1; j < num_pins; j++) {
3504 if (sequences[i] > sequences[j]) {
3506 sequences[i] = sequences[j];
3518 * Parse all pin widgets and store the useful pin nids to cfg
3520 * The number of line-outs or any primary output is stored in line_outs,
3521 * and the corresponding output pins are assigned to line_out_pins[],
3522 * in the order of front, rear, CLFE, side, ...
3524 * If more extra outputs (speaker and headphone) are found, the pins are
3525 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3526 * is detected, one of speaker of HP pins is assigned as the primary
3527 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3528 * if any analog output exists.
3530 * The analog input pins are assigned to input_pins array.
3531 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3534 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3535 struct auto_pin_cfg *cfg,
3536 hda_nid_t *ignore_nids)
3538 hda_nid_t nid, end_nid;
3539 short seq, assoc_line_out, assoc_speaker;
3540 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3541 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3542 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3544 memset(cfg, 0, sizeof(*cfg));
3546 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3547 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3548 memset(sequences_hp, 0, sizeof(sequences_hp));
3549 assoc_line_out = assoc_speaker = 0;
3551 end_nid = codec->start_nid + codec->num_nodes;
3552 for (nid = codec->start_nid; nid < end_nid; nid++) {
3553 unsigned int wid_caps = get_wcaps(codec, nid);
3554 unsigned int wid_type =
3555 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3556 unsigned int def_conf;
3559 /* read all default configuration for pin complex */
3560 if (wid_type != AC_WID_PIN)
3562 /* ignore the given nids (e.g. pc-beep returns error) */
3563 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3566 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3567 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3569 loc = get_defcfg_location(def_conf);
3570 switch (get_defcfg_device(def_conf)) {
3571 case AC_JACK_LINE_OUT:
3572 seq = get_defcfg_sequence(def_conf);
3573 assoc = get_defcfg_association(def_conf);
3575 if (!(wid_caps & AC_WCAP_STEREO))
3576 if (!cfg->mono_out_pin)
3577 cfg->mono_out_pin = nid;
3580 if (!assoc_line_out)
3581 assoc_line_out = assoc;
3582 else if (assoc_line_out != assoc)
3584 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3586 cfg->line_out_pins[cfg->line_outs] = nid;
3587 sequences_line_out[cfg->line_outs] = seq;
3590 case AC_JACK_SPEAKER:
3591 seq = get_defcfg_sequence(def_conf);
3592 assoc = get_defcfg_association(def_conf);
3595 if (! assoc_speaker)
3596 assoc_speaker = assoc;
3597 else if (assoc_speaker != assoc)
3599 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3601 cfg->speaker_pins[cfg->speaker_outs] = nid;
3602 sequences_speaker[cfg->speaker_outs] = seq;
3603 cfg->speaker_outs++;
3605 case AC_JACK_HP_OUT:
3606 seq = get_defcfg_sequence(def_conf);
3607 assoc = get_defcfg_association(def_conf);
3608 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3610 cfg->hp_pins[cfg->hp_outs] = nid;
3611 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3614 case AC_JACK_MIC_IN: {
3616 if (loc == AC_JACK_LOC_FRONT) {
3617 preferred = AUTO_PIN_FRONT_MIC;
3620 preferred = AUTO_PIN_MIC;
3621 alt = AUTO_PIN_FRONT_MIC;
3623 if (!cfg->input_pins[preferred])
3624 cfg->input_pins[preferred] = nid;
3625 else if (!cfg->input_pins[alt])
3626 cfg->input_pins[alt] = nid;
3629 case AC_JACK_LINE_IN:
3630 if (loc == AC_JACK_LOC_FRONT)
3631 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3633 cfg->input_pins[AUTO_PIN_LINE] = nid;
3636 cfg->input_pins[AUTO_PIN_CD] = nid;
3639 cfg->input_pins[AUTO_PIN_AUX] = nid;
3641 case AC_JACK_SPDIF_OUT:
3642 case AC_JACK_DIG_OTHER_OUT:
3643 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3645 cfg->dig_out_pins[cfg->dig_outs] = nid;
3646 cfg->dig_out_type[cfg->dig_outs] =
3647 (loc == AC_JACK_LOC_HDMI) ?
3648 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3651 case AC_JACK_SPDIF_IN:
3652 case AC_JACK_DIG_OTHER_IN:
3653 cfg->dig_in_pin = nid;
3654 if (loc == AC_JACK_LOC_HDMI)
3655 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3657 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
3663 * If no line-out is defined but multiple HPs are found,
3664 * some of them might be the real line-outs.
3666 if (!cfg->line_outs && cfg->hp_outs > 1) {
3668 while (i < cfg->hp_outs) {
3669 /* The real HPs should have the sequence 0x0f */
3670 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3674 /* Move it to the line-out table */
3675 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3676 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3679 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3680 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3681 memmove(sequences_hp + i - 1, sequences_hp + i,
3682 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3686 /* sort by sequence */
3687 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3689 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3691 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3694 /* if we have only one mic, make it AUTO_PIN_MIC */
3695 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3696 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3697 cfg->input_pins[AUTO_PIN_MIC] =
3698 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3699 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3701 /* ditto for line-in */
3702 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3703 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3704 cfg->input_pins[AUTO_PIN_LINE] =
3705 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3706 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3710 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3711 * as a primary output
3713 if (!cfg->line_outs) {
3714 if (cfg->speaker_outs) {
3715 cfg->line_outs = cfg->speaker_outs;
3716 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3717 sizeof(cfg->speaker_pins));
3718 cfg->speaker_outs = 0;
3719 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3720 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3721 } else if (cfg->hp_outs) {
3722 cfg->line_outs = cfg->hp_outs;
3723 memcpy(cfg->line_out_pins, cfg->hp_pins,
3724 sizeof(cfg->hp_pins));
3726 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3727 cfg->line_out_type = AUTO_PIN_HP_OUT;
3731 /* Reorder the surround channels
3732 * ALSA sequence is front/surr/clfe/side
3734 * 4-ch: front/surr => OK as it is
3735 * 6-ch: front/clfe/surr
3736 * 8-ch: front/clfe/rear/side|fc
3738 switch (cfg->line_outs) {
3741 nid = cfg->line_out_pins[1];
3742 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3743 cfg->line_out_pins[2] = nid;
3748 * debug prints of the parsed results
3750 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3751 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3752 cfg->line_out_pins[2], cfg->line_out_pins[3],
3753 cfg->line_out_pins[4]);
3754 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3755 cfg->speaker_outs, cfg->speaker_pins[0],
3756 cfg->speaker_pins[1], cfg->speaker_pins[2],
3757 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3758 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3759 cfg->hp_outs, cfg->hp_pins[0],
3760 cfg->hp_pins[1], cfg->hp_pins[2],
3761 cfg->hp_pins[3], cfg->hp_pins[4]);
3762 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3764 snd_printd(" dig-out=0x%x/0x%x\n",
3765 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
3766 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3767 " cd=0x%x, aux=0x%x\n",
3768 cfg->input_pins[AUTO_PIN_MIC],
3769 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3770 cfg->input_pins[AUTO_PIN_LINE],
3771 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3772 cfg->input_pins[AUTO_PIN_CD],
3773 cfg->input_pins[AUTO_PIN_AUX]);
3774 if (cfg->dig_in_pin)
3775 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
3779 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3781 /* labels for input pins */
3782 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3783 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3785 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3794 * snd_hda_suspend - suspend the codecs
3796 * @state: suspsend state
3798 * Returns 0 if successful.
3800 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3802 struct hda_codec *codec;
3804 list_for_each_entry(codec, &bus->codec_list, list) {
3805 #ifdef CONFIG_SND_HDA_POWER_SAVE
3806 if (!codec->power_on)
3809 hda_call_codec_suspend(codec);
3813 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3816 * snd_hda_resume - resume the codecs
3819 * Returns 0 if successful.
3821 * This fucntion is defined only when POWER_SAVE isn't set.
3822 * In the power-save mode, the codec is resumed dynamically.
3824 int snd_hda_resume(struct hda_bus *bus)
3826 struct hda_codec *codec;
3828 list_for_each_entry(codec, &bus->codec_list, list) {
3829 if (snd_hda_codec_needs_resume(codec))
3830 hda_call_codec_resume(codec);
3834 EXPORT_SYMBOL_HDA(snd_hda_resume);
3835 #endif /* CONFIG_PM */
3841 /* get a new element from the given array
3842 * if it exceeds the pre-allocated array size, re-allocate the array
3844 void *snd_array_new(struct snd_array *array)
3846 if (array->used >= array->alloced) {
3847 int num = array->alloced + array->alloc_align;
3849 if (snd_BUG_ON(num >= 4096))
3851 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3855 memcpy(nlist, array->list,
3856 array->elem_size * array->alloced);
3859 array->list = nlist;
3860 array->alloced = num;
3862 return snd_array_elem(array, array->used++);
3864 EXPORT_SYMBOL_HDA(snd_array_new);
3866 /* free the given array elements */
3867 void snd_array_free(struct snd_array *array)
3874 EXPORT_SYMBOL_HDA(snd_array_free);
3877 * used by hda_proc.c and hda_eld.c
3879 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3881 static unsigned int rates[] = {
3882 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3883 96000, 176400, 192000, 384000
3887 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3889 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3891 buf[j] = '\0'; /* necessary when j == 0 */
3893 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3895 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3897 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3900 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3901 if (pcm & (AC_SUPPCM_BITS_8 << i))
3902 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3904 buf[j] = '\0'; /* necessary when j == 0 */
3906 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
3908 MODULE_DESCRIPTION("HDA codec core");
3909 MODULE_LICENSE("GPL");