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);
845 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
846 unsigned int power_state);
849 * snd_hda_codec_new - create a HDA codec
850 * @bus: the bus to assign
851 * @codec_addr: the codec address
852 * @codecp: the pointer to store the generated codec
854 * Returns 0 if successful, or a negative error code.
856 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
857 int do_init, struct hda_codec **codecp)
859 struct hda_codec *codec;
863 if (snd_BUG_ON(!bus))
865 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
868 if (bus->caddr_tbl[codec_addr]) {
869 snd_printk(KERN_ERR "hda_codec: "
870 "address 0x%x is already occupied\n", codec_addr);
874 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
876 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
881 codec->addr = codec_addr;
882 mutex_init(&codec->spdif_mutex);
883 mutex_init(&codec->control_mutex);
884 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
885 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
886 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
887 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
888 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
889 if (codec->bus->modelname) {
890 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
891 if (!codec->modelname) {
892 snd_hda_codec_free(codec);
897 #ifdef CONFIG_SND_HDA_POWER_SAVE
898 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
899 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
900 * the caller has to power down appropriatley after initialization
903 hda_keep_power_on(codec);
906 list_add_tail(&codec->list, &bus->codec_list);
907 bus->caddr_tbl[codec_addr] = codec;
909 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
911 if (codec->vendor_id == -1)
912 /* read again, hopefully the access method was corrected
913 * in the last read...
915 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
917 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
918 AC_PAR_SUBSYSTEM_ID);
919 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
922 setup_fg_nodes(codec);
923 if (!codec->afg && !codec->mfg) {
924 snd_printdd("hda_codec: no AFG or MFG node found\n");
929 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
931 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
934 err = read_pin_defaults(codec);
938 if (!codec->subsystem_id) {
939 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
940 codec->subsystem_id =
941 snd_hda_codec_read(codec, nid, 0,
942 AC_VERB_GET_SUBSYSTEM_ID, 0);
945 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
947 /* power-up all before initialization */
948 hda_set_power_state(codec,
949 codec->afg ? codec->afg : codec->mfg,
953 err = snd_hda_codec_configure(codec);
957 snd_hda_codec_proc_new(codec);
959 snd_hda_create_hwdep(codec);
961 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
962 codec->subsystem_id, codec->revision_id);
963 snd_component_add(codec->bus->card, component);
970 snd_hda_codec_free(codec);
973 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
975 int snd_hda_codec_configure(struct hda_codec *codec)
979 codec->preset = find_codec_preset(codec);
981 err = get_codec_name(codec);
985 /* audio codec should override the mixer name */
986 if (codec->afg || !*codec->bus->card->mixername)
987 strlcpy(codec->bus->card->mixername, codec->name,
988 sizeof(codec->bus->card->mixername));
990 if (is_generic_config(codec)) {
991 err = snd_hda_parse_generic_codec(codec);
994 if (codec->preset && codec->preset->patch) {
995 err = codec->preset->patch(codec);
999 /* call the default parser */
1000 err = snd_hda_parse_generic_codec(codec);
1002 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1005 if (!err && codec->patch_ops.unsol_event)
1006 err = init_unsol_queue(codec->bus);
1011 * snd_hda_codec_setup_stream - set up the codec for streaming
1012 * @codec: the CODEC to set up
1013 * @nid: the NID to set up
1014 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1015 * @channel_id: channel id to pass, zero based.
1016 * @format: stream format.
1018 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1020 int channel_id, int format)
1025 snd_printdd("hda_codec_setup_stream: "
1026 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1027 nid, stream_tag, channel_id, format);
1028 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1029 (stream_tag << 4) | channel_id);
1031 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1033 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1035 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1040 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1041 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1042 #if 0 /* keep the format */
1044 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1047 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
1050 * amp access functions
1053 /* FIXME: more better hash key? */
1054 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1055 #define INFO_AMP_CAPS (1<<0)
1056 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1058 /* initialize the hash table */
1059 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1060 unsigned int record_size)
1062 memset(cache, 0, sizeof(*cache));
1063 memset(cache->hash, 0xff, sizeof(cache->hash));
1064 snd_array_init(&cache->buf, record_size, 64);
1067 static void free_hda_cache(struct hda_cache_rec *cache)
1069 snd_array_free(&cache->buf);
1072 /* query the hash. allocate an entry if not found. */
1073 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1076 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1077 u16 cur = cache->hash[idx];
1078 struct hda_cache_head *info;
1080 while (cur != 0xffff) {
1081 info = snd_array_elem(&cache->buf, cur);
1082 if (info->key == key)
1087 /* add a new hash entry */
1088 info = snd_array_new(&cache->buf);
1091 cur = snd_array_index(&cache->buf, info);
1094 info->next = cache->hash[idx];
1095 cache->hash[idx] = cur;
1100 /* query and allocate an amp hash entry */
1101 static inline struct hda_amp_info *
1102 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1104 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1108 * query AMP capabilities for the given widget and direction
1110 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1112 struct hda_amp_info *info;
1114 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1117 if (!(info->head.val & INFO_AMP_CAPS)) {
1118 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1120 info->amp_caps = snd_hda_param_read(codec, nid,
1121 direction == HDA_OUTPUT ?
1122 AC_PAR_AMP_OUT_CAP :
1125 info->head.val |= INFO_AMP_CAPS;
1127 return info->amp_caps;
1129 EXPORT_SYMBOL_HDA(query_amp_caps);
1131 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1134 struct hda_amp_info *info;
1136 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1139 info->amp_caps = caps;
1140 info->head.val |= INFO_AMP_CAPS;
1143 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1146 * read the current volume to info
1147 * if the cache exists, read the cache value.
1149 static unsigned int get_vol_mute(struct hda_codec *codec,
1150 struct hda_amp_info *info, hda_nid_t nid,
1151 int ch, int direction, int index)
1155 if (info->head.val & INFO_AMP_VOL(ch))
1156 return info->vol[ch];
1158 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1159 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1161 val = snd_hda_codec_read(codec, nid, 0,
1162 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1163 info->vol[ch] = val & 0xff;
1164 info->head.val |= INFO_AMP_VOL(ch);
1165 return info->vol[ch];
1169 * write the current volume in info to the h/w and update the cache
1171 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1172 hda_nid_t nid, int ch, int direction, int index,
1177 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1178 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1179 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1181 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1182 info->vol[ch] = val;
1186 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1188 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1189 int direction, int index)
1191 struct hda_amp_info *info;
1192 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1195 return get_vol_mute(codec, info, nid, ch, direction, index);
1197 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1200 * update the AMP value, mask = bit mask to set, val = the value
1202 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1203 int direction, int idx, int mask, int val)
1205 struct hda_amp_info *info;
1207 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1211 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1212 if (info->vol[ch] == val)
1214 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1217 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1220 * update the AMP stereo with the same mask and value
1222 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1223 int direction, int idx, int mask, int val)
1226 for (ch = 0; ch < 2; ch++)
1227 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1231 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1233 #ifdef SND_HDA_NEEDS_RESUME
1234 /* resume the all amp commands from the cache */
1235 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1237 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1240 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1241 u32 key = buffer->head.key;
1243 unsigned int idx, dir, ch;
1247 idx = (key >> 16) & 0xff;
1248 dir = (key >> 24) & 0xff;
1249 for (ch = 0; ch < 2; ch++) {
1250 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1252 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1257 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1258 #endif /* SND_HDA_NEEDS_RESUME */
1261 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1262 struct snd_ctl_elem_info *uinfo)
1264 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1265 u16 nid = get_amp_nid(kcontrol);
1266 u8 chs = get_amp_channels(kcontrol);
1267 int dir = get_amp_direction(kcontrol);
1268 unsigned int ofs = get_amp_offset(kcontrol);
1271 caps = query_amp_caps(codec, nid, dir);
1273 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1275 printk(KERN_WARNING "hda_codec: "
1276 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1282 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1283 uinfo->count = chs == 3 ? 2 : 1;
1284 uinfo->value.integer.min = 0;
1285 uinfo->value.integer.max = caps;
1288 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1291 static inline unsigned int
1292 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1293 int ch, int dir, int idx, unsigned int ofs)
1296 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1297 val &= HDA_AMP_VOLMASK;
1306 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1307 int ch, int dir, int idx, unsigned int ofs,
1312 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1313 HDA_AMP_VOLMASK, val);
1316 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1317 struct snd_ctl_elem_value *ucontrol)
1319 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1320 hda_nid_t nid = get_amp_nid(kcontrol);
1321 int chs = get_amp_channels(kcontrol);
1322 int dir = get_amp_direction(kcontrol);
1323 int idx = get_amp_index(kcontrol);
1324 unsigned int ofs = get_amp_offset(kcontrol);
1325 long *valp = ucontrol->value.integer.value;
1328 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1330 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1333 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1335 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1336 struct snd_ctl_elem_value *ucontrol)
1338 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1339 hda_nid_t nid = get_amp_nid(kcontrol);
1340 int chs = get_amp_channels(kcontrol);
1341 int dir = get_amp_direction(kcontrol);
1342 int idx = get_amp_index(kcontrol);
1343 unsigned int ofs = get_amp_offset(kcontrol);
1344 long *valp = ucontrol->value.integer.value;
1347 snd_hda_power_up(codec);
1349 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1353 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1354 snd_hda_power_down(codec);
1357 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1359 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1360 unsigned int size, unsigned int __user *_tlv)
1362 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1363 hda_nid_t nid = get_amp_nid(kcontrol);
1364 int dir = get_amp_direction(kcontrol);
1365 unsigned int ofs = get_amp_offset(kcontrol);
1366 u32 caps, val1, val2;
1368 if (size < 4 * sizeof(unsigned int))
1370 caps = query_amp_caps(codec, nid, dir);
1371 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1372 val2 = (val2 + 1) * 25;
1373 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1375 val1 = ((int)val1) * ((int)val2);
1376 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1378 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1380 if (put_user(val1, _tlv + 2))
1382 if (put_user(val2, _tlv + 3))
1386 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1389 * set (static) TLV for virtual master volume; recalculated as max 0dB
1391 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1397 caps = query_amp_caps(codec, nid, dir);
1398 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1399 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1400 step = (step + 1) * 25;
1401 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1402 tlv[1] = 2 * sizeof(unsigned int);
1403 tlv[2] = -nums * step;
1406 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1408 /* find a mixer control element with the given name */
1409 static struct snd_kcontrol *
1410 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1411 const char *name, int idx)
1413 struct snd_ctl_elem_id id;
1414 memset(&id, 0, sizeof(id));
1415 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1417 strcpy(id.name, name);
1418 return snd_ctl_find_id(codec->bus->card, &id);
1421 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1424 return _snd_hda_find_mixer_ctl(codec, name, 0);
1426 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1428 /* Add a control element and assign to the codec */
1429 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1432 struct snd_kcontrol **knewp;
1434 err = snd_ctl_add(codec->bus->card, kctl);
1437 knewp = snd_array_new(&codec->mixers);
1443 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1445 /* Clear all controls assigned to the given codec */
1446 void snd_hda_ctls_clear(struct hda_codec *codec)
1449 struct snd_kcontrol **kctls = codec->mixers.list;
1450 for (i = 0; i < codec->mixers.used; i++)
1451 snd_ctl_remove(codec->bus->card, kctls[i]);
1452 snd_array_free(&codec->mixers);
1455 /* pseudo device locking
1456 * toggle card->shutdown to allow/disallow the device access (as a hack)
1458 static int hda_lock_devices(struct snd_card *card)
1460 spin_lock(&card->files_lock);
1461 if (card->shutdown) {
1462 spin_unlock(&card->files_lock);
1466 spin_unlock(&card->files_lock);
1470 static void hda_unlock_devices(struct snd_card *card)
1472 spin_lock(&card->files_lock);
1474 spin_unlock(&card->files_lock);
1477 int snd_hda_codec_reset(struct hda_codec *codec)
1479 struct snd_card *card = codec->bus->card;
1482 if (hda_lock_devices(card) < 0)
1484 /* check whether the codec isn't used by any mixer or PCM streams */
1485 if (!list_empty(&card->ctl_files)) {
1486 hda_unlock_devices(card);
1489 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1490 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1493 if (cpcm->pcm->streams[0].substream_opened ||
1494 cpcm->pcm->streams[1].substream_opened) {
1495 hda_unlock_devices(card);
1500 /* OK, let it free */
1502 #ifdef CONFIG_SND_HDA_POWER_SAVE
1503 cancel_delayed_work(&codec->power_work);
1504 flush_workqueue(codec->bus->workq);
1506 snd_hda_ctls_clear(codec);
1508 for (i = 0; i < codec->num_pcms; i++) {
1509 if (codec->pcm_info[i].pcm) {
1510 snd_device_free(card, codec->pcm_info[i].pcm);
1511 clear_bit(codec->pcm_info[i].device,
1512 codec->bus->pcm_dev_bits);
1515 if (codec->patch_ops.free)
1516 codec->patch_ops.free(codec);
1517 codec->proc_widget_hook = NULL;
1519 free_hda_cache(&codec->amp_cache);
1520 free_hda_cache(&codec->cmd_cache);
1521 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1522 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1523 /* free only driver_pins so that init_pins + user_pins are restored */
1524 snd_array_free(&codec->driver_pins);
1525 restore_pincfgs(codec);
1526 codec->num_pcms = 0;
1527 codec->pcm_info = NULL;
1528 codec->preset = NULL;
1529 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1530 codec->slave_dig_outs = NULL;
1531 codec->spdif_status_reset = 0;
1532 module_put(codec->owner);
1533 codec->owner = NULL;
1535 /* allow device access again */
1536 hda_unlock_devices(card);
1540 /* create a virtual master control and add slaves */
1541 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1542 unsigned int *tlv, const char **slaves)
1544 struct snd_kcontrol *kctl;
1548 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1551 snd_printdd("No slave found for %s\n", name);
1554 kctl = snd_ctl_make_virtual_master(name, tlv);
1557 err = snd_hda_ctl_add(codec, kctl);
1561 for (s = slaves; *s; s++) {
1562 struct snd_kcontrol *sctl;
1565 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1568 snd_printdd("Cannot find slave %s, "
1572 err = snd_ctl_add_slave(kctl, sctl);
1580 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1583 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1584 struct snd_ctl_elem_info *uinfo)
1586 int chs = get_amp_channels(kcontrol);
1588 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1589 uinfo->count = chs == 3 ? 2 : 1;
1590 uinfo->value.integer.min = 0;
1591 uinfo->value.integer.max = 1;
1594 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1596 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1597 struct snd_ctl_elem_value *ucontrol)
1599 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1600 hda_nid_t nid = get_amp_nid(kcontrol);
1601 int chs = get_amp_channels(kcontrol);
1602 int dir = get_amp_direction(kcontrol);
1603 int idx = get_amp_index(kcontrol);
1604 long *valp = ucontrol->value.integer.value;
1607 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1608 HDA_AMP_MUTE) ? 0 : 1;
1610 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1611 HDA_AMP_MUTE) ? 0 : 1;
1614 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1616 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1617 struct snd_ctl_elem_value *ucontrol)
1619 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1620 hda_nid_t nid = get_amp_nid(kcontrol);
1621 int chs = get_amp_channels(kcontrol);
1622 int dir = get_amp_direction(kcontrol);
1623 int idx = get_amp_index(kcontrol);
1624 long *valp = ucontrol->value.integer.value;
1627 snd_hda_power_up(codec);
1629 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1631 *valp ? 0 : HDA_AMP_MUTE);
1635 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1637 *valp ? 0 : HDA_AMP_MUTE);
1638 #ifdef CONFIG_SND_HDA_POWER_SAVE
1639 if (codec->patch_ops.check_power_status)
1640 codec->patch_ops.check_power_status(codec, nid);
1642 snd_hda_power_down(codec);
1645 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1648 * bound volume controls
1650 * bind multiple volumes (# indices, from 0)
1653 #define AMP_VAL_IDX_SHIFT 19
1654 #define AMP_VAL_IDX_MASK (0x0f<<19)
1656 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1657 struct snd_ctl_elem_value *ucontrol)
1659 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1663 mutex_lock(&codec->control_mutex);
1664 pval = kcontrol->private_value;
1665 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1666 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1667 kcontrol->private_value = pval;
1668 mutex_unlock(&codec->control_mutex);
1671 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1673 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1674 struct snd_ctl_elem_value *ucontrol)
1676 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1678 int i, indices, err = 0, change = 0;
1680 mutex_lock(&codec->control_mutex);
1681 pval = kcontrol->private_value;
1682 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1683 for (i = 0; i < indices; i++) {
1684 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1685 (i << AMP_VAL_IDX_SHIFT);
1686 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1691 kcontrol->private_value = pval;
1692 mutex_unlock(&codec->control_mutex);
1693 return err < 0 ? err : change;
1695 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1698 * generic bound volume/swtich controls
1700 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1701 struct snd_ctl_elem_info *uinfo)
1703 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1704 struct hda_bind_ctls *c;
1707 mutex_lock(&codec->control_mutex);
1708 c = (struct hda_bind_ctls *)kcontrol->private_value;
1709 kcontrol->private_value = *c->values;
1710 err = c->ops->info(kcontrol, uinfo);
1711 kcontrol->private_value = (long)c;
1712 mutex_unlock(&codec->control_mutex);
1715 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1717 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1718 struct snd_ctl_elem_value *ucontrol)
1720 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1721 struct hda_bind_ctls *c;
1724 mutex_lock(&codec->control_mutex);
1725 c = (struct hda_bind_ctls *)kcontrol->private_value;
1726 kcontrol->private_value = *c->values;
1727 err = c->ops->get(kcontrol, ucontrol);
1728 kcontrol->private_value = (long)c;
1729 mutex_unlock(&codec->control_mutex);
1732 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1734 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1735 struct snd_ctl_elem_value *ucontrol)
1737 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1738 struct hda_bind_ctls *c;
1739 unsigned long *vals;
1740 int err = 0, change = 0;
1742 mutex_lock(&codec->control_mutex);
1743 c = (struct hda_bind_ctls *)kcontrol->private_value;
1744 for (vals = c->values; *vals; vals++) {
1745 kcontrol->private_value = *vals;
1746 err = c->ops->put(kcontrol, ucontrol);
1751 kcontrol->private_value = (long)c;
1752 mutex_unlock(&codec->control_mutex);
1753 return err < 0 ? err : change;
1755 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1757 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1758 unsigned int size, unsigned int __user *tlv)
1760 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1761 struct hda_bind_ctls *c;
1764 mutex_lock(&codec->control_mutex);
1765 c = (struct hda_bind_ctls *)kcontrol->private_value;
1766 kcontrol->private_value = *c->values;
1767 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1768 kcontrol->private_value = (long)c;
1769 mutex_unlock(&codec->control_mutex);
1772 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1774 struct hda_ctl_ops snd_hda_bind_vol = {
1775 .info = snd_hda_mixer_amp_volume_info,
1776 .get = snd_hda_mixer_amp_volume_get,
1777 .put = snd_hda_mixer_amp_volume_put,
1778 .tlv = snd_hda_mixer_amp_tlv
1780 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1782 struct hda_ctl_ops snd_hda_bind_sw = {
1783 .info = snd_hda_mixer_amp_switch_info,
1784 .get = snd_hda_mixer_amp_switch_get,
1785 .put = snd_hda_mixer_amp_switch_put,
1786 .tlv = snd_hda_mixer_amp_tlv
1788 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1791 * SPDIF out controls
1794 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1795 struct snd_ctl_elem_info *uinfo)
1797 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1802 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1803 struct snd_ctl_elem_value *ucontrol)
1805 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1806 IEC958_AES0_NONAUDIO |
1807 IEC958_AES0_CON_EMPHASIS_5015 |
1808 IEC958_AES0_CON_NOT_COPYRIGHT;
1809 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1810 IEC958_AES1_CON_ORIGINAL;
1814 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1815 struct snd_ctl_elem_value *ucontrol)
1817 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1818 IEC958_AES0_NONAUDIO |
1819 IEC958_AES0_PRO_EMPHASIS_5015;
1823 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1824 struct snd_ctl_elem_value *ucontrol)
1826 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1828 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1829 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1830 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1831 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1836 /* convert from SPDIF status bits to HDA SPDIF bits
1837 * bit 0 (DigEn) is always set zero (to be filled later)
1839 static unsigned short convert_from_spdif_status(unsigned int sbits)
1841 unsigned short val = 0;
1843 if (sbits & IEC958_AES0_PROFESSIONAL)
1844 val |= AC_DIG1_PROFESSIONAL;
1845 if (sbits & IEC958_AES0_NONAUDIO)
1846 val |= AC_DIG1_NONAUDIO;
1847 if (sbits & IEC958_AES0_PROFESSIONAL) {
1848 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1849 IEC958_AES0_PRO_EMPHASIS_5015)
1850 val |= AC_DIG1_EMPHASIS;
1852 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1853 IEC958_AES0_CON_EMPHASIS_5015)
1854 val |= AC_DIG1_EMPHASIS;
1855 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1856 val |= AC_DIG1_COPYRIGHT;
1857 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1858 val |= AC_DIG1_LEVEL;
1859 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1864 /* convert to SPDIF status bits from HDA SPDIF bits
1866 static unsigned int convert_to_spdif_status(unsigned short val)
1868 unsigned int sbits = 0;
1870 if (val & AC_DIG1_NONAUDIO)
1871 sbits |= IEC958_AES0_NONAUDIO;
1872 if (val & AC_DIG1_PROFESSIONAL)
1873 sbits |= IEC958_AES0_PROFESSIONAL;
1874 if (sbits & IEC958_AES0_PROFESSIONAL) {
1875 if (sbits & AC_DIG1_EMPHASIS)
1876 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1878 if (val & AC_DIG1_EMPHASIS)
1879 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1880 if (!(val & AC_DIG1_COPYRIGHT))
1881 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1882 if (val & AC_DIG1_LEVEL)
1883 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1884 sbits |= val & (0x7f << 8);
1889 /* set digital convert verbs both for the given NID and its slaves */
1890 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1895 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1896 d = codec->slave_dig_outs;
1900 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1903 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1907 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1909 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1912 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1913 struct snd_ctl_elem_value *ucontrol)
1915 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1916 hda_nid_t nid = kcontrol->private_value;
1920 mutex_lock(&codec->spdif_mutex);
1921 codec->spdif_status = ucontrol->value.iec958.status[0] |
1922 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1923 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1924 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1925 val = convert_from_spdif_status(codec->spdif_status);
1926 val |= codec->spdif_ctls & 1;
1927 change = codec->spdif_ctls != val;
1928 codec->spdif_ctls = val;
1931 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1933 mutex_unlock(&codec->spdif_mutex);
1937 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1939 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1940 struct snd_ctl_elem_value *ucontrol)
1942 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1944 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1948 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1949 struct snd_ctl_elem_value *ucontrol)
1951 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1952 hda_nid_t nid = kcontrol->private_value;
1956 mutex_lock(&codec->spdif_mutex);
1957 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1958 if (ucontrol->value.integer.value[0])
1959 val |= AC_DIG1_ENABLE;
1960 change = codec->spdif_ctls != val;
1962 codec->spdif_ctls = val;
1963 set_dig_out_convert(codec, nid, val & 0xff, -1);
1964 /* unmute amp switch (if any) */
1965 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1966 (val & AC_DIG1_ENABLE))
1967 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1970 mutex_unlock(&codec->spdif_mutex);
1974 static struct snd_kcontrol_new dig_mixes[] = {
1976 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1977 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1978 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1979 .info = snd_hda_spdif_mask_info,
1980 .get = snd_hda_spdif_cmask_get,
1983 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1984 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1985 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1986 .info = snd_hda_spdif_mask_info,
1987 .get = snd_hda_spdif_pmask_get,
1990 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1991 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1992 .info = snd_hda_spdif_mask_info,
1993 .get = snd_hda_spdif_default_get,
1994 .put = snd_hda_spdif_default_put,
1997 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1998 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1999 .info = snd_hda_spdif_out_switch_info,
2000 .get = snd_hda_spdif_out_switch_get,
2001 .put = snd_hda_spdif_out_switch_put,
2006 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2009 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2010 * @codec: the HDA codec
2011 * @nid: audio out widget NID
2013 * Creates controls related with the SPDIF output.
2014 * Called from each patch supporting the SPDIF out.
2016 * Returns 0 if successful, or a negative error code.
2018 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2021 struct snd_kcontrol *kctl;
2022 struct snd_kcontrol_new *dig_mix;
2025 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2026 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2030 if (idx >= SPDIF_MAX_IDX) {
2031 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2034 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2035 kctl = snd_ctl_new1(dig_mix, codec);
2038 kctl->id.index = idx;
2039 kctl->private_value = nid;
2040 err = snd_hda_ctl_add(codec, kctl);
2045 snd_hda_codec_read(codec, nid, 0,
2046 AC_VERB_GET_DIGI_CONVERT_1, 0);
2047 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2050 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2053 * SPDIF sharing with analog output
2055 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2056 struct snd_ctl_elem_value *ucontrol)
2058 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2059 ucontrol->value.integer.value[0] = mout->share_spdif;
2063 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2064 struct snd_ctl_elem_value *ucontrol)
2066 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2067 mout->share_spdif = !!ucontrol->value.integer.value[0];
2071 static struct snd_kcontrol_new spdif_share_sw = {
2072 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2073 .name = "IEC958 Default PCM Playback Switch",
2074 .info = snd_ctl_boolean_mono_info,
2075 .get = spdif_share_sw_get,
2076 .put = spdif_share_sw_put,
2079 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2080 struct hda_multi_out *mout)
2082 if (!mout->dig_out_nid)
2084 /* ATTENTION: here mout is passed as private_data, instead of codec */
2085 return snd_hda_ctl_add(codec,
2086 snd_ctl_new1(&spdif_share_sw, mout));
2088 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2094 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2096 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2097 struct snd_ctl_elem_value *ucontrol)
2099 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2101 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2105 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2106 struct snd_ctl_elem_value *ucontrol)
2108 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2109 hda_nid_t nid = kcontrol->private_value;
2110 unsigned int val = !!ucontrol->value.integer.value[0];
2113 mutex_lock(&codec->spdif_mutex);
2114 change = codec->spdif_in_enable != val;
2116 codec->spdif_in_enable = val;
2117 snd_hda_codec_write_cache(codec, nid, 0,
2118 AC_VERB_SET_DIGI_CONVERT_1, val);
2120 mutex_unlock(&codec->spdif_mutex);
2124 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2125 struct snd_ctl_elem_value *ucontrol)
2127 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2128 hda_nid_t nid = kcontrol->private_value;
2132 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2133 sbits = convert_to_spdif_status(val);
2134 ucontrol->value.iec958.status[0] = sbits;
2135 ucontrol->value.iec958.status[1] = sbits >> 8;
2136 ucontrol->value.iec958.status[2] = sbits >> 16;
2137 ucontrol->value.iec958.status[3] = sbits >> 24;
2141 static struct snd_kcontrol_new dig_in_ctls[] = {
2143 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2144 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2145 .info = snd_hda_spdif_in_switch_info,
2146 .get = snd_hda_spdif_in_switch_get,
2147 .put = snd_hda_spdif_in_switch_put,
2150 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2151 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2152 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2153 .info = snd_hda_spdif_mask_info,
2154 .get = snd_hda_spdif_in_status_get,
2160 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2161 * @codec: the HDA codec
2162 * @nid: audio in widget NID
2164 * Creates controls related with the SPDIF input.
2165 * Called from each patch supporting the SPDIF in.
2167 * Returns 0 if successful, or a negative error code.
2169 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2172 struct snd_kcontrol *kctl;
2173 struct snd_kcontrol_new *dig_mix;
2176 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2177 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2181 if (idx >= SPDIF_MAX_IDX) {
2182 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2185 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2186 kctl = snd_ctl_new1(dig_mix, codec);
2189 kctl->private_value = nid;
2190 err = snd_hda_ctl_add(codec, kctl);
2194 codec->spdif_in_enable =
2195 snd_hda_codec_read(codec, nid, 0,
2196 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2200 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2202 #ifdef SND_HDA_NEEDS_RESUME
2207 /* build a 32bit cache key with the widget id and the command parameter */
2208 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2209 #define get_cmd_cache_nid(key) ((key) & 0xff)
2210 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2213 * snd_hda_codec_write_cache - send a single command with caching
2214 * @codec: the HDA codec
2215 * @nid: NID to send the command
2216 * @direct: direct flag
2217 * @verb: the verb to send
2218 * @parm: the parameter for the verb
2220 * Send a single command without waiting for response.
2222 * Returns 0 if successful, or a negative error code.
2224 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2225 int direct, unsigned int verb, unsigned int parm)
2227 struct hda_bus *bus = codec->bus;
2231 res = make_codec_cmd(codec, nid, direct, verb, parm);
2232 snd_hda_power_up(codec);
2233 mutex_lock(&bus->cmd_mutex);
2234 err = bus->ops.command(bus, res);
2236 struct hda_cache_head *c;
2237 u32 key = build_cmd_cache_key(nid, verb);
2238 c = get_alloc_hash(&codec->cmd_cache, key);
2242 mutex_unlock(&bus->cmd_mutex);
2243 snd_hda_power_down(codec);
2246 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2248 /* resume the all commands from the cache */
2249 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2251 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2254 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2255 u32 key = buffer->key;
2258 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2259 get_cmd_cache_cmd(key), buffer->val);
2262 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2265 * snd_hda_sequence_write_cache - sequence writes with caching
2266 * @codec: the HDA codec
2267 * @seq: VERB array to send
2269 * Send the commands sequentially from the given array.
2270 * Thte commands are recorded on cache for power-save and resume.
2271 * The array must be terminated with NID=0.
2273 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2274 const struct hda_verb *seq)
2276 for (; seq->nid; seq++)
2277 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2280 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2281 #endif /* SND_HDA_NEEDS_RESUME */
2284 * set power state of the codec
2286 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2287 unsigned int power_state)
2292 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2294 msleep(10); /* partial workaround for "azx_get_response timeout" */
2296 nid = codec->start_nid;
2297 for (i = 0; i < codec->num_nodes; i++, nid++) {
2298 unsigned int wcaps = get_wcaps(codec, nid);
2299 if (wcaps & AC_WCAP_POWER) {
2300 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2302 if (wid_type == AC_WID_PIN) {
2303 unsigned int pincap;
2305 * don't power down the widget if it controls
2306 * eapd and EAPD_BTLENABLE is set.
2308 pincap = snd_hda_param_read(codec, nid,
2310 if (pincap & AC_PINCAP_EAPD) {
2311 int eapd = snd_hda_codec_read(codec,
2313 AC_VERB_GET_EAPD_BTLENABLE, 0);
2315 if (power_state == AC_PWRST_D3 && eapd)
2319 snd_hda_codec_write(codec, nid, 0,
2320 AC_VERB_SET_POWER_STATE,
2325 if (power_state == AC_PWRST_D0) {
2326 unsigned long end_time;
2329 /* wait until the codec reachs to D0 */
2330 end_time = jiffies + msecs_to_jiffies(500);
2332 state = snd_hda_codec_read(codec, fg, 0,
2333 AC_VERB_GET_POWER_STATE, 0);
2334 if (state == power_state)
2337 } while (time_after_eq(end_time, jiffies));
2341 #ifdef CONFIG_SND_HDA_HWDEP
2342 /* execute additional init verbs */
2343 static void hda_exec_init_verbs(struct hda_codec *codec)
2345 if (codec->init_verbs.list)
2346 snd_hda_sequence_write(codec, codec->init_verbs.list);
2349 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2352 #ifdef SND_HDA_NEEDS_RESUME
2354 * call suspend and power-down; used both from PM and power-save
2356 static void hda_call_codec_suspend(struct hda_codec *codec)
2358 if (codec->patch_ops.suspend)
2359 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2360 hda_set_power_state(codec,
2361 codec->afg ? codec->afg : codec->mfg,
2363 #ifdef CONFIG_SND_HDA_POWER_SAVE
2364 cancel_delayed_work(&codec->power_work);
2365 codec->power_on = 0;
2366 codec->power_transition = 0;
2371 * kick up codec; used both from PM and power-save
2373 static void hda_call_codec_resume(struct hda_codec *codec)
2375 hda_set_power_state(codec,
2376 codec->afg ? codec->afg : codec->mfg,
2378 restore_pincfgs(codec); /* restore all current pin configs */
2379 hda_exec_init_verbs(codec);
2380 if (codec->patch_ops.resume)
2381 codec->patch_ops.resume(codec);
2383 if (codec->patch_ops.init)
2384 codec->patch_ops.init(codec);
2385 snd_hda_codec_resume_amp(codec);
2386 snd_hda_codec_resume_cache(codec);
2389 #endif /* SND_HDA_NEEDS_RESUME */
2393 * snd_hda_build_controls - build mixer controls
2396 * Creates mixer controls for each codec included in the bus.
2398 * Returns 0 if successful, otherwise a negative error code.
2400 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2402 struct hda_codec *codec;
2404 list_for_each_entry(codec, &bus->codec_list, list) {
2405 int err = snd_hda_codec_build_controls(codec);
2407 printk(KERN_ERR "hda_codec: cannot build controls"
2408 "for #%d (error %d)\n", codec->addr, err);
2409 err = snd_hda_codec_reset(codec);
2412 "hda_codec: cannot revert codec\n");
2419 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2421 int snd_hda_codec_build_controls(struct hda_codec *codec)
2424 hda_exec_init_verbs(codec);
2425 /* continue to initialize... */
2426 if (codec->patch_ops.init)
2427 err = codec->patch_ops.init(codec);
2428 if (!err && codec->patch_ops.build_controls)
2429 err = codec->patch_ops.build_controls(codec);
2438 struct hda_rate_tbl {
2440 unsigned int alsa_bits;
2441 unsigned int hda_fmt;
2444 static struct hda_rate_tbl rate_bits[] = {
2445 /* rate in Hz, ALSA rate bitmask, HDA format value */
2447 /* autodetected value used in snd_hda_query_supported_pcm */
2448 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2449 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2450 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2451 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2452 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2453 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2454 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2455 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2456 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2457 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2458 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2459 #define AC_PAR_PCM_RATE_BITS 11
2460 /* up to bits 10, 384kHZ isn't supported properly */
2462 /* not autodetected value */
2463 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2465 { 0 } /* terminator */
2469 * snd_hda_calc_stream_format - calculate format bitset
2470 * @rate: the sample rate
2471 * @channels: the number of channels
2472 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2473 * @maxbps: the max. bps
2475 * Calculate the format bitset from the given rate, channels and th PCM format.
2477 * Return zero if invalid.
2479 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2480 unsigned int channels,
2481 unsigned int format,
2482 unsigned int maxbps)
2485 unsigned int val = 0;
2487 for (i = 0; rate_bits[i].hz; i++)
2488 if (rate_bits[i].hz == rate) {
2489 val = rate_bits[i].hda_fmt;
2492 if (!rate_bits[i].hz) {
2493 snd_printdd("invalid rate %d\n", rate);
2497 if (channels == 0 || channels > 8) {
2498 snd_printdd("invalid channels %d\n", channels);
2501 val |= channels - 1;
2503 switch (snd_pcm_format_width(format)) {
2504 case 8: val |= 0x00; break;
2505 case 16: val |= 0x10; break;
2511 else if (maxbps >= 24)
2517 snd_printdd("invalid format width %d\n",
2518 snd_pcm_format_width(format));
2524 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2527 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2528 * @codec: the HDA codec
2529 * @nid: NID to query
2530 * @ratesp: the pointer to store the detected rate bitflags
2531 * @formatsp: the pointer to store the detected formats
2532 * @bpsp: the pointer to store the detected format widths
2534 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2535 * or @bsps argument is ignored.
2537 * Returns 0 if successful, otherwise a negative error code.
2539 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2540 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2543 unsigned int val, streams;
2546 if (nid != codec->afg &&
2547 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2548 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2553 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2557 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2559 rates |= rate_bits[i].alsa_bits;
2564 if (formatsp || bpsp) {
2569 wcaps = get_wcaps(codec, nid);
2570 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2574 streams = snd_hda_param_read(codec, codec->afg,
2581 if (streams & AC_SUPFMT_PCM) {
2582 if (val & AC_SUPPCM_BITS_8) {
2583 formats |= SNDRV_PCM_FMTBIT_U8;
2586 if (val & AC_SUPPCM_BITS_16) {
2587 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2590 if (wcaps & AC_WCAP_DIGITAL) {
2591 if (val & AC_SUPPCM_BITS_32)
2592 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2593 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2594 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2595 if (val & AC_SUPPCM_BITS_24)
2597 else if (val & AC_SUPPCM_BITS_20)
2599 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2600 AC_SUPPCM_BITS_32)) {
2601 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2602 if (val & AC_SUPPCM_BITS_32)
2604 else if (val & AC_SUPPCM_BITS_24)
2606 else if (val & AC_SUPPCM_BITS_20)
2610 else if (streams == AC_SUPFMT_FLOAT32) {
2611 /* should be exclusive */
2612 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2614 } else if (streams == AC_SUPFMT_AC3) {
2615 /* should be exclusive */
2616 /* temporary hack: we have still no proper support
2617 * for the direct AC3 stream...
2619 formats |= SNDRV_PCM_FMTBIT_U8;
2623 *formatsp = formats;
2632 * snd_hda_is_supported_format - check whether the given node supports
2635 * Returns 1 if supported, 0 if not.
2637 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2638 unsigned int format)
2641 unsigned int val = 0, rate, stream;
2643 if (nid != codec->afg &&
2644 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2645 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2650 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2655 rate = format & 0xff00;
2656 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2657 if (rate_bits[i].hda_fmt == rate) {
2662 if (i >= AC_PAR_PCM_RATE_BITS)
2665 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2668 if (!stream && nid != codec->afg)
2669 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2670 if (!stream || stream == -1)
2673 if (stream & AC_SUPFMT_PCM) {
2674 switch (format & 0xf0) {
2676 if (!(val & AC_SUPPCM_BITS_8))
2680 if (!(val & AC_SUPPCM_BITS_16))
2684 if (!(val & AC_SUPPCM_BITS_20))
2688 if (!(val & AC_SUPPCM_BITS_24))
2692 if (!(val & AC_SUPPCM_BITS_32))
2699 /* FIXME: check for float32 and AC3? */
2704 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2709 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2710 struct hda_codec *codec,
2711 struct snd_pcm_substream *substream)
2716 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2717 struct hda_codec *codec,
2718 unsigned int stream_tag,
2719 unsigned int format,
2720 struct snd_pcm_substream *substream)
2722 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2726 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2727 struct hda_codec *codec,
2728 struct snd_pcm_substream *substream)
2730 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2734 static int set_pcm_default_values(struct hda_codec *codec,
2735 struct hda_pcm_stream *info)
2737 /* query support PCM information from the given NID */
2738 if (info->nid && (!info->rates || !info->formats)) {
2739 snd_hda_query_supported_pcm(codec, info->nid,
2740 info->rates ? NULL : &info->rates,
2741 info->formats ? NULL : &info->formats,
2742 info->maxbps ? NULL : &info->maxbps);
2744 if (info->ops.open == NULL)
2745 info->ops.open = hda_pcm_default_open_close;
2746 if (info->ops.close == NULL)
2747 info->ops.close = hda_pcm_default_open_close;
2748 if (info->ops.prepare == NULL) {
2749 if (snd_BUG_ON(!info->nid))
2751 info->ops.prepare = hda_pcm_default_prepare;
2753 if (info->ops.cleanup == NULL) {
2754 if (snd_BUG_ON(!info->nid))
2756 info->ops.cleanup = hda_pcm_default_cleanup;
2762 * get the empty PCM device number to assign
2764 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2766 static const char *dev_name[HDA_PCM_NTYPES] = {
2767 "Audio", "SPDIF", "HDMI", "Modem"
2769 /* starting device index for each PCM type */
2770 static int dev_idx[HDA_PCM_NTYPES] = {
2771 [HDA_PCM_TYPE_AUDIO] = 0,
2772 [HDA_PCM_TYPE_SPDIF] = 1,
2773 [HDA_PCM_TYPE_HDMI] = 3,
2774 [HDA_PCM_TYPE_MODEM] = 6
2776 /* normal audio device indices; not linear to keep compatibility */
2777 static int audio_idx[4] = { 0, 2, 4, 5 };
2781 case HDA_PCM_TYPE_AUDIO:
2782 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2784 if (!test_bit(dev, bus->pcm_dev_bits))
2787 snd_printk(KERN_WARNING "Too many audio devices\n");
2789 case HDA_PCM_TYPE_SPDIF:
2790 case HDA_PCM_TYPE_HDMI:
2791 case HDA_PCM_TYPE_MODEM:
2792 dev = dev_idx[type];
2793 if (test_bit(dev, bus->pcm_dev_bits)) {
2794 snd_printk(KERN_WARNING "%s already defined\n",
2800 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2804 set_bit(dev, bus->pcm_dev_bits);
2809 * attach a new PCM stream
2811 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2813 struct hda_bus *bus = codec->bus;
2814 struct hda_pcm_stream *info;
2817 if (snd_BUG_ON(!pcm->name))
2819 for (stream = 0; stream < 2; stream++) {
2820 info = &pcm->stream[stream];
2821 if (info->substreams) {
2822 err = set_pcm_default_values(codec, info);
2827 return bus->ops.attach_pcm(bus, codec, pcm);
2830 /* assign all PCMs of the given codec */
2831 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2836 if (!codec->num_pcms) {
2837 if (!codec->patch_ops.build_pcms)
2839 err = codec->patch_ops.build_pcms(codec);
2841 printk(KERN_ERR "hda_codec: cannot build PCMs"
2842 "for #%d (error %d)\n", codec->addr, err);
2843 err = snd_hda_codec_reset(codec);
2846 "hda_codec: cannot revert codec\n");
2851 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2852 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2855 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2856 continue; /* no substreams assigned */
2859 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2861 continue; /* no fatal error */
2863 err = snd_hda_attach_pcm(codec, cpcm);
2865 printk(KERN_ERR "hda_codec: cannot attach "
2866 "PCM stream %d for codec #%d\n",
2868 continue; /* no fatal error */
2876 * snd_hda_build_pcms - build PCM information
2879 * Create PCM information for each codec included in the bus.
2881 * The build_pcms codec patch is requested to set up codec->num_pcms and
2882 * codec->pcm_info properly. The array is referred by the top-level driver
2883 * to create its PCM instances.
2884 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2887 * At least, substreams, channels_min and channels_max must be filled for
2888 * each stream. substreams = 0 indicates that the stream doesn't exist.
2889 * When rates and/or formats are zero, the supported values are queried
2890 * from the given nid. The nid is used also by the default ops.prepare
2891 * and ops.cleanup callbacks.
2893 * The driver needs to call ops.open in its open callback. Similarly,
2894 * ops.close is supposed to be called in the close callback.
2895 * ops.prepare should be called in the prepare or hw_params callback
2896 * with the proper parameters for set up.
2897 * ops.cleanup should be called in hw_free for clean up of streams.
2899 * This function returns 0 if successfull, or a negative error code.
2901 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2903 struct hda_codec *codec;
2905 list_for_each_entry(codec, &bus->codec_list, list) {
2906 int err = snd_hda_codec_build_pcms(codec);
2912 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2915 * snd_hda_check_board_config - compare the current codec with the config table
2916 * @codec: the HDA codec
2917 * @num_configs: number of config enums
2918 * @models: array of model name strings
2919 * @tbl: configuration table, terminated by null entries
2921 * Compares the modelname or PCI subsystem id of the current codec with the
2922 * given configuration table. If a matching entry is found, returns its
2923 * config value (supposed to be 0 or positive).
2925 * If no entries are matching, the function returns a negative value.
2927 int snd_hda_check_board_config(struct hda_codec *codec,
2928 int num_configs, const char **models,
2929 const struct snd_pci_quirk *tbl)
2931 if (codec->modelname && models) {
2933 for (i = 0; i < num_configs; i++) {
2935 !strcmp(codec->modelname, models[i])) {
2936 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2937 "selected\n", models[i]);
2943 if (!codec->bus->pci || !tbl)
2946 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2949 if (tbl->value >= 0 && tbl->value < num_configs) {
2950 #ifdef CONFIG_SND_DEBUG_VERBOSE
2952 const char *model = NULL;
2954 model = models[tbl->value];
2956 sprintf(tmp, "#%d", tbl->value);
2959 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2960 "for config %x:%x (%s)\n",
2961 model, tbl->subvendor, tbl->subdevice,
2962 (tbl->name ? tbl->name : "Unknown device"));
2968 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
2971 * snd_hda_check_board_codec_sid_config - compare the current codec
2972 subsystem ID with the
2975 This is important for Gateway notebooks with SB450 HDA Audio
2976 where the vendor ID of the PCI device is:
2977 ATI Technologies Inc SB450 HDA Audio [1002:437b]
2978 and the vendor/subvendor are found only at the codec.
2980 * @codec: the HDA codec
2981 * @num_configs: number of config enums
2982 * @models: array of model name strings
2983 * @tbl: configuration table, terminated by null entries
2985 * Compares the modelname or PCI subsystem id of the current codec with the
2986 * given configuration table. If a matching entry is found, returns its
2987 * config value (supposed to be 0 or positive).
2989 * If no entries are matching, the function returns a negative value.
2991 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
2992 int num_configs, const char **models,
2993 const struct snd_pci_quirk *tbl)
2995 const struct snd_pci_quirk *q;
2997 /* Search for codec ID */
2998 for (q = tbl; q->subvendor; q++) {
2999 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3001 if (vendorid == codec->subsystem_id)
3010 if (tbl->value >= 0 && tbl->value < num_configs) {
3011 #ifdef CONFIG_SND_DEBUG_DETECT
3013 const char *model = NULL;
3015 model = models[tbl->value];
3017 sprintf(tmp, "#%d", tbl->value);
3020 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3021 "for config %x:%x (%s)\n",
3022 model, tbl->subvendor, tbl->subdevice,
3023 (tbl->name ? tbl->name : "Unknown device"));
3029 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3032 * snd_hda_add_new_ctls - create controls from the array
3033 * @codec: the HDA codec
3034 * @knew: the array of struct snd_kcontrol_new
3036 * This helper function creates and add new controls in the given array.
3037 * The array must be terminated with an empty entry as terminator.
3039 * Returns 0 if successful, or a negative error code.
3041 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3045 for (; knew->name; knew++) {
3046 struct snd_kcontrol *kctl;
3047 kctl = snd_ctl_new1(knew, codec);
3050 err = snd_hda_ctl_add(codec, kctl);
3054 kctl = snd_ctl_new1(knew, codec);
3057 kctl->id.device = codec->addr;
3058 err = snd_hda_ctl_add(codec, kctl);
3065 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3067 #ifdef CONFIG_SND_HDA_POWER_SAVE
3068 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3069 unsigned int power_state);
3071 static void hda_power_work(struct work_struct *work)
3073 struct hda_codec *codec =
3074 container_of(work, struct hda_codec, power_work.work);
3075 struct hda_bus *bus = codec->bus;
3077 if (!codec->power_on || codec->power_count) {
3078 codec->power_transition = 0;
3082 hda_call_codec_suspend(codec);
3083 if (bus->ops.pm_notify)
3084 bus->ops.pm_notify(bus);
3087 static void hda_keep_power_on(struct hda_codec *codec)
3089 codec->power_count++;
3090 codec->power_on = 1;
3093 void snd_hda_power_up(struct hda_codec *codec)
3095 struct hda_bus *bus = codec->bus;
3097 codec->power_count++;
3098 if (codec->power_on || codec->power_transition)
3101 codec->power_on = 1;
3102 if (bus->ops.pm_notify)
3103 bus->ops.pm_notify(bus);
3104 hda_call_codec_resume(codec);
3105 cancel_delayed_work(&codec->power_work);
3106 codec->power_transition = 0;
3108 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3110 #define power_save(codec) \
3111 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3113 #define power_save(codec) \
3114 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3116 void snd_hda_power_down(struct hda_codec *codec)
3118 --codec->power_count;
3119 if (!codec->power_on || codec->power_count || codec->power_transition)
3121 if (power_save(codec)) {
3122 codec->power_transition = 1; /* avoid reentrance */
3123 queue_delayed_work(codec->bus->workq, &codec->power_work,
3124 msecs_to_jiffies(power_save(codec) * 1000));
3127 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3129 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3130 struct hda_loopback_check *check,
3133 struct hda_amp_list *p;
3136 if (!check->amplist)
3138 for (p = check->amplist; p->nid; p++) {
3143 return 0; /* nothing changed */
3145 for (p = check->amplist; p->nid; p++) {
3146 for (ch = 0; ch < 2; ch++) {
3147 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3149 if (!(v & HDA_AMP_MUTE) && v > 0) {
3150 if (!check->power_on) {
3151 check->power_on = 1;
3152 snd_hda_power_up(codec);
3158 if (check->power_on) {
3159 check->power_on = 0;
3160 snd_hda_power_down(codec);
3164 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3168 * Channel mode helper
3170 int snd_hda_ch_mode_info(struct hda_codec *codec,
3171 struct snd_ctl_elem_info *uinfo,
3172 const struct hda_channel_mode *chmode,
3175 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3177 uinfo->value.enumerated.items = num_chmodes;
3178 if (uinfo->value.enumerated.item >= num_chmodes)
3179 uinfo->value.enumerated.item = num_chmodes - 1;
3180 sprintf(uinfo->value.enumerated.name, "%dch",
3181 chmode[uinfo->value.enumerated.item].channels);
3184 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3186 int snd_hda_ch_mode_get(struct hda_codec *codec,
3187 struct snd_ctl_elem_value *ucontrol,
3188 const struct hda_channel_mode *chmode,
3194 for (i = 0; i < num_chmodes; i++) {
3195 if (max_channels == chmode[i].channels) {
3196 ucontrol->value.enumerated.item[0] = i;
3202 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
3204 int snd_hda_ch_mode_put(struct hda_codec *codec,
3205 struct snd_ctl_elem_value *ucontrol,
3206 const struct hda_channel_mode *chmode,
3212 mode = ucontrol->value.enumerated.item[0];
3213 if (mode >= num_chmodes)
3215 if (*max_channelsp == chmode[mode].channels)
3217 /* change the current channel setting */
3218 *max_channelsp = chmode[mode].channels;
3219 if (chmode[mode].sequence)
3220 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3223 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3228 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3229 struct snd_ctl_elem_info *uinfo)
3233 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3235 uinfo->value.enumerated.items = imux->num_items;
3236 if (!imux->num_items)
3238 index = uinfo->value.enumerated.item;
3239 if (index >= imux->num_items)
3240 index = imux->num_items - 1;
3241 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3244 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3246 int snd_hda_input_mux_put(struct hda_codec *codec,
3247 const struct hda_input_mux *imux,
3248 struct snd_ctl_elem_value *ucontrol,
3250 unsigned int *cur_val)
3254 if (!imux->num_items)
3256 idx = ucontrol->value.enumerated.item[0];
3257 if (idx >= imux->num_items)
3258 idx = imux->num_items - 1;
3259 if (*cur_val == idx)
3261 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3262 imux->items[idx].index);
3266 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3270 * Multi-channel / digital-out PCM helper functions
3273 /* setup SPDIF output stream */
3274 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3275 unsigned int stream_tag, unsigned int format)
3277 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3278 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3279 set_dig_out_convert(codec, nid,
3280 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3282 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3283 if (codec->slave_dig_outs) {
3285 for (d = codec->slave_dig_outs; *d; d++)
3286 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3289 /* turn on again (if needed) */
3290 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3291 set_dig_out_convert(codec, nid,
3292 codec->spdif_ctls & 0xff, -1);
3295 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3297 snd_hda_codec_cleanup_stream(codec, nid);
3298 if (codec->slave_dig_outs) {
3300 for (d = codec->slave_dig_outs; *d; d++)
3301 snd_hda_codec_cleanup_stream(codec, *d);
3306 * open the digital out in the exclusive mode
3308 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3309 struct hda_multi_out *mout)
3311 mutex_lock(&codec->spdif_mutex);
3312 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3313 /* already opened as analog dup; reset it once */
3314 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3315 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3316 mutex_unlock(&codec->spdif_mutex);
3319 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3321 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3322 struct hda_multi_out *mout,
3323 unsigned int stream_tag,
3324 unsigned int format,
3325 struct snd_pcm_substream *substream)
3327 mutex_lock(&codec->spdif_mutex);
3328 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3329 mutex_unlock(&codec->spdif_mutex);
3332 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3334 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3335 struct hda_multi_out *mout)
3337 mutex_lock(&codec->spdif_mutex);
3338 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3339 mutex_unlock(&codec->spdif_mutex);
3342 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3345 * release the digital out
3347 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3348 struct hda_multi_out *mout)
3350 mutex_lock(&codec->spdif_mutex);
3351 mout->dig_out_used = 0;
3352 mutex_unlock(&codec->spdif_mutex);
3355 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3358 * set up more restrictions for analog out
3360 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3361 struct hda_multi_out *mout,
3362 struct snd_pcm_substream *substream,
3363 struct hda_pcm_stream *hinfo)
3365 struct snd_pcm_runtime *runtime = substream->runtime;
3366 runtime->hw.channels_max = mout->max_channels;
3367 if (mout->dig_out_nid) {
3368 if (!mout->analog_rates) {
3369 mout->analog_rates = hinfo->rates;
3370 mout->analog_formats = hinfo->formats;
3371 mout->analog_maxbps = hinfo->maxbps;
3373 runtime->hw.rates = mout->analog_rates;
3374 runtime->hw.formats = mout->analog_formats;
3375 hinfo->maxbps = mout->analog_maxbps;
3377 if (!mout->spdif_rates) {
3378 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3380 &mout->spdif_formats,
3381 &mout->spdif_maxbps);
3383 mutex_lock(&codec->spdif_mutex);
3384 if (mout->share_spdif) {
3385 runtime->hw.rates &= mout->spdif_rates;
3386 runtime->hw.formats &= mout->spdif_formats;
3387 if (mout->spdif_maxbps < hinfo->maxbps)
3388 hinfo->maxbps = mout->spdif_maxbps;
3390 mutex_unlock(&codec->spdif_mutex);
3392 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3393 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3395 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3398 * set up the i/o for analog out
3399 * when the digital out is available, copy the front out to digital out, too.
3401 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3402 struct hda_multi_out *mout,
3403 unsigned int stream_tag,
3404 unsigned int format,
3405 struct snd_pcm_substream *substream)
3407 hda_nid_t *nids = mout->dac_nids;
3408 int chs = substream->runtime->channels;
3411 mutex_lock(&codec->spdif_mutex);
3412 if (mout->dig_out_nid && mout->share_spdif &&
3413 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3415 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3417 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3418 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3419 setup_dig_out_stream(codec, mout->dig_out_nid,
3420 stream_tag, format);
3422 mout->dig_out_used = 0;
3423 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3426 mutex_unlock(&codec->spdif_mutex);
3429 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3431 if (!mout->no_share_stream &&
3432 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3433 /* headphone out will just decode front left/right (stereo) */
3434 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3436 /* extra outputs copied from front */
3437 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3438 if (!mout->no_share_stream && mout->extra_out_nid[i])
3439 snd_hda_codec_setup_stream(codec,
3440 mout->extra_out_nid[i],
3441 stream_tag, 0, format);
3444 for (i = 1; i < mout->num_dacs; i++) {
3445 if (chs >= (i + 1) * 2) /* independent out */
3446 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3448 else if (!mout->no_share_stream) /* copy front */
3449 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3454 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3457 * clean up the setting for analog out
3459 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3460 struct hda_multi_out *mout)
3462 hda_nid_t *nids = mout->dac_nids;
3465 for (i = 0; i < mout->num_dacs; i++)
3466 snd_hda_codec_cleanup_stream(codec, nids[i]);
3468 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3469 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3470 if (mout->extra_out_nid[i])
3471 snd_hda_codec_cleanup_stream(codec,
3472 mout->extra_out_nid[i]);
3473 mutex_lock(&codec->spdif_mutex);
3474 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3475 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3476 mout->dig_out_used = 0;
3478 mutex_unlock(&codec->spdif_mutex);
3481 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3484 * Helper for automatic pin configuration
3487 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3489 for (; *list; list++)
3497 * Sort an associated group of pins according to their sequence numbers.
3499 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3506 for (i = 0; i < num_pins; i++) {
3507 for (j = i + 1; j < num_pins; j++) {
3508 if (sequences[i] > sequences[j]) {
3510 sequences[i] = sequences[j];
3522 * Parse all pin widgets and store the useful pin nids to cfg
3524 * The number of line-outs or any primary output is stored in line_outs,
3525 * and the corresponding output pins are assigned to line_out_pins[],
3526 * in the order of front, rear, CLFE, side, ...
3528 * If more extra outputs (speaker and headphone) are found, the pins are
3529 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3530 * is detected, one of speaker of HP pins is assigned as the primary
3531 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3532 * if any analog output exists.
3534 * The analog input pins are assigned to input_pins array.
3535 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3538 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3539 struct auto_pin_cfg *cfg,
3540 hda_nid_t *ignore_nids)
3542 hda_nid_t nid, end_nid;
3543 short seq, assoc_line_out, assoc_speaker;
3544 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3545 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3546 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3548 memset(cfg, 0, sizeof(*cfg));
3550 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3551 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3552 memset(sequences_hp, 0, sizeof(sequences_hp));
3553 assoc_line_out = assoc_speaker = 0;
3555 end_nid = codec->start_nid + codec->num_nodes;
3556 for (nid = codec->start_nid; nid < end_nid; nid++) {
3557 unsigned int wid_caps = get_wcaps(codec, nid);
3558 unsigned int wid_type =
3559 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3560 unsigned int def_conf;
3563 /* read all default configuration for pin complex */
3564 if (wid_type != AC_WID_PIN)
3566 /* ignore the given nids (e.g. pc-beep returns error) */
3567 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3570 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3571 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3573 loc = get_defcfg_location(def_conf);
3574 switch (get_defcfg_device(def_conf)) {
3575 case AC_JACK_LINE_OUT:
3576 seq = get_defcfg_sequence(def_conf);
3577 assoc = get_defcfg_association(def_conf);
3579 if (!(wid_caps & AC_WCAP_STEREO))
3580 if (!cfg->mono_out_pin)
3581 cfg->mono_out_pin = nid;
3584 if (!assoc_line_out)
3585 assoc_line_out = assoc;
3586 else if (assoc_line_out != assoc)
3588 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3590 cfg->line_out_pins[cfg->line_outs] = nid;
3591 sequences_line_out[cfg->line_outs] = seq;
3594 case AC_JACK_SPEAKER:
3595 seq = get_defcfg_sequence(def_conf);
3596 assoc = get_defcfg_association(def_conf);
3599 if (! assoc_speaker)
3600 assoc_speaker = assoc;
3601 else if (assoc_speaker != assoc)
3603 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3605 cfg->speaker_pins[cfg->speaker_outs] = nid;
3606 sequences_speaker[cfg->speaker_outs] = seq;
3607 cfg->speaker_outs++;
3609 case AC_JACK_HP_OUT:
3610 seq = get_defcfg_sequence(def_conf);
3611 assoc = get_defcfg_association(def_conf);
3612 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3614 cfg->hp_pins[cfg->hp_outs] = nid;
3615 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3618 case AC_JACK_MIC_IN: {
3620 if (loc == AC_JACK_LOC_FRONT) {
3621 preferred = AUTO_PIN_FRONT_MIC;
3624 preferred = AUTO_PIN_MIC;
3625 alt = AUTO_PIN_FRONT_MIC;
3627 if (!cfg->input_pins[preferred])
3628 cfg->input_pins[preferred] = nid;
3629 else if (!cfg->input_pins[alt])
3630 cfg->input_pins[alt] = nid;
3633 case AC_JACK_LINE_IN:
3634 if (loc == AC_JACK_LOC_FRONT)
3635 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3637 cfg->input_pins[AUTO_PIN_LINE] = nid;
3640 cfg->input_pins[AUTO_PIN_CD] = nid;
3643 cfg->input_pins[AUTO_PIN_AUX] = nid;
3645 case AC_JACK_SPDIF_OUT:
3646 case AC_JACK_DIG_OTHER_OUT:
3647 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3649 cfg->dig_out_pins[cfg->dig_outs] = nid;
3650 cfg->dig_out_type[cfg->dig_outs] =
3651 (loc == AC_JACK_LOC_HDMI) ?
3652 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3655 case AC_JACK_SPDIF_IN:
3656 case AC_JACK_DIG_OTHER_IN:
3657 cfg->dig_in_pin = nid;
3658 if (loc == AC_JACK_LOC_HDMI)
3659 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3661 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
3667 * If no line-out is defined but multiple HPs are found,
3668 * some of them might be the real line-outs.
3670 if (!cfg->line_outs && cfg->hp_outs > 1) {
3672 while (i < cfg->hp_outs) {
3673 /* The real HPs should have the sequence 0x0f */
3674 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3678 /* Move it to the line-out table */
3679 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3680 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3683 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3684 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3685 memmove(sequences_hp + i - 1, sequences_hp + i,
3686 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3690 /* sort by sequence */
3691 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3693 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3695 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3698 /* if we have only one mic, make it AUTO_PIN_MIC */
3699 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3700 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3701 cfg->input_pins[AUTO_PIN_MIC] =
3702 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3703 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3705 /* ditto for line-in */
3706 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3707 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3708 cfg->input_pins[AUTO_PIN_LINE] =
3709 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3710 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3714 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3715 * as a primary output
3717 if (!cfg->line_outs) {
3718 if (cfg->speaker_outs) {
3719 cfg->line_outs = cfg->speaker_outs;
3720 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3721 sizeof(cfg->speaker_pins));
3722 cfg->speaker_outs = 0;
3723 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3724 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3725 } else if (cfg->hp_outs) {
3726 cfg->line_outs = cfg->hp_outs;
3727 memcpy(cfg->line_out_pins, cfg->hp_pins,
3728 sizeof(cfg->hp_pins));
3730 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3731 cfg->line_out_type = AUTO_PIN_HP_OUT;
3735 /* Reorder the surround channels
3736 * ALSA sequence is front/surr/clfe/side
3738 * 4-ch: front/surr => OK as it is
3739 * 6-ch: front/clfe/surr
3740 * 8-ch: front/clfe/rear/side|fc
3742 switch (cfg->line_outs) {
3745 nid = cfg->line_out_pins[1];
3746 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3747 cfg->line_out_pins[2] = nid;
3752 * debug prints of the parsed results
3754 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3755 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3756 cfg->line_out_pins[2], cfg->line_out_pins[3],
3757 cfg->line_out_pins[4]);
3758 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3759 cfg->speaker_outs, cfg->speaker_pins[0],
3760 cfg->speaker_pins[1], cfg->speaker_pins[2],
3761 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3762 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3763 cfg->hp_outs, cfg->hp_pins[0],
3764 cfg->hp_pins[1], cfg->hp_pins[2],
3765 cfg->hp_pins[3], cfg->hp_pins[4]);
3766 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3768 snd_printd(" dig-out=0x%x/0x%x\n",
3769 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
3770 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3771 " cd=0x%x, aux=0x%x\n",
3772 cfg->input_pins[AUTO_PIN_MIC],
3773 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3774 cfg->input_pins[AUTO_PIN_LINE],
3775 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3776 cfg->input_pins[AUTO_PIN_CD],
3777 cfg->input_pins[AUTO_PIN_AUX]);
3778 if (cfg->dig_in_pin)
3779 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
3783 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3785 /* labels for input pins */
3786 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3787 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3789 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3798 * snd_hda_suspend - suspend the codecs
3800 * @state: suspsend state
3802 * Returns 0 if successful.
3804 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3806 struct hda_codec *codec;
3808 list_for_each_entry(codec, &bus->codec_list, list) {
3809 #ifdef CONFIG_SND_HDA_POWER_SAVE
3810 if (!codec->power_on)
3813 hda_call_codec_suspend(codec);
3817 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3820 * snd_hda_resume - resume the codecs
3823 * Returns 0 if successful.
3825 * This fucntion is defined only when POWER_SAVE isn't set.
3826 * In the power-save mode, the codec is resumed dynamically.
3828 int snd_hda_resume(struct hda_bus *bus)
3830 struct hda_codec *codec;
3832 list_for_each_entry(codec, &bus->codec_list, list) {
3833 if (snd_hda_codec_needs_resume(codec))
3834 hda_call_codec_resume(codec);
3838 EXPORT_SYMBOL_HDA(snd_hda_resume);
3839 #endif /* CONFIG_PM */
3845 /* get a new element from the given array
3846 * if it exceeds the pre-allocated array size, re-allocate the array
3848 void *snd_array_new(struct snd_array *array)
3850 if (array->used >= array->alloced) {
3851 int num = array->alloced + array->alloc_align;
3853 if (snd_BUG_ON(num >= 4096))
3855 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3859 memcpy(nlist, array->list,
3860 array->elem_size * array->alloced);
3863 array->list = nlist;
3864 array->alloced = num;
3866 return snd_array_elem(array, array->used++);
3868 EXPORT_SYMBOL_HDA(snd_array_new);
3870 /* free the given array elements */
3871 void snd_array_free(struct snd_array *array)
3878 EXPORT_SYMBOL_HDA(snd_array_free);
3881 * used by hda_proc.c and hda_eld.c
3883 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3885 static unsigned int rates[] = {
3886 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3887 96000, 176400, 192000, 384000
3891 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3893 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3895 buf[j] = '\0'; /* necessary when j == 0 */
3897 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3899 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3901 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3904 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3905 if (pcm & (AC_SUPPCM_BITS_8 << i))
3906 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3908 buf[j] = '\0'; /* necessary when j == 0 */
3910 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
3912 MODULE_DESCRIPTION("HDA codec core");
3913 MODULE_LICENSE("GPL");