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
);
686 static void init_hda_cache(struct hda_cache_rec
*cache
,
687 unsigned int record_size
);
688 static void free_hda_cache(struct hda_cache_rec
*cache
);
693 static void snd_hda_codec_free(struct hda_codec
*codec
)
697 #ifdef CONFIG_SND_HDA_POWER_SAVE
698 cancel_delayed_work(&codec
->power_work
);
699 flush_workqueue(codec
->bus
->workq
);
701 list_del(&codec
->list
);
702 snd_array_free(&codec
->mixers
);
703 codec
->bus
->caddr_tbl
[codec
->addr
] = NULL
;
704 if (codec
->patch_ops
.free
)
705 codec
->patch_ops
.free(codec
);
706 module_put(codec
->owner
);
707 free_hda_cache(&codec
->amp_cache
);
708 free_hda_cache(&codec
->cmd_cache
);
710 kfree(codec
->modelname
);
716 * snd_hda_codec_new - create a HDA codec
717 * @bus: the bus to assign
718 * @codec_addr: the codec address
719 * @codecp: the pointer to store the generated codec
721 * Returns 0 if successful, or a negative error code.
723 int /*__devinit*/ snd_hda_codec_new(struct hda_bus
*bus
, unsigned int codec_addr
,
724 int do_init
, struct hda_codec
**codecp
)
726 struct hda_codec
*codec
;
730 if (snd_BUG_ON(!bus
))
732 if (snd_BUG_ON(codec_addr
> HDA_MAX_CODEC_ADDRESS
))
735 if (bus
->caddr_tbl
[codec_addr
]) {
736 snd_printk(KERN_ERR
"hda_codec: "
737 "address 0x%x is already occupied\n", codec_addr
);
741 codec
= kzalloc(sizeof(*codec
), GFP_KERNEL
);
743 snd_printk(KERN_ERR
"can't allocate struct hda_codec\n");
748 codec
->addr
= codec_addr
;
749 mutex_init(&codec
->spdif_mutex
);
750 mutex_init(&codec
->control_mutex
);
751 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
752 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
753 snd_array_init(&codec
->mixers
, sizeof(struct snd_kcontrol
*), 32);
754 if (codec
->bus
->modelname
) {
755 codec
->modelname
= kstrdup(codec
->bus
->modelname
, GFP_KERNEL
);
756 if (!codec
->modelname
) {
757 snd_hda_codec_free(codec
);
762 #ifdef CONFIG_SND_HDA_POWER_SAVE
763 INIT_DELAYED_WORK(&codec
->power_work
, hda_power_work
);
764 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
765 * the caller has to power down appropriatley after initialization
768 hda_keep_power_on(codec
);
771 list_add_tail(&codec
->list
, &bus
->codec_list
);
772 bus
->caddr_tbl
[codec_addr
] = codec
;
774 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
776 if (codec
->vendor_id
== -1)
777 /* read again, hopefully the access method was corrected
778 * in the last read...
780 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
782 codec
->subsystem_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
783 AC_PAR_SUBSYSTEM_ID
);
784 codec
->revision_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
787 setup_fg_nodes(codec
);
788 if (!codec
->afg
&& !codec
->mfg
) {
789 snd_printdd("hda_codec: no AFG or MFG node found\n");
790 snd_hda_codec_free(codec
);
794 if (read_widget_caps(codec
, codec
->afg
? codec
->afg
: codec
->mfg
) < 0) {
795 snd_printk(KERN_ERR
"hda_codec: cannot malloc\n");
796 snd_hda_codec_free(codec
);
800 if (!codec
->subsystem_id
) {
801 hda_nid_t nid
= codec
->afg
? codec
->afg
: codec
->mfg
;
802 codec
->subsystem_id
=
803 snd_hda_codec_read(codec
, nid
, 0,
804 AC_VERB_GET_SUBSYSTEM_ID
, 0);
807 codec
->modelname
= kstrdup(bus
->modelname
, GFP_KERNEL
);
810 err
= snd_hda_codec_configure(codec
);
812 snd_hda_codec_free(codec
);
816 snd_hda_codec_proc_new(codec
);
818 snd_hda_create_hwdep(codec
);
820 sprintf(component
, "HDA:%08x,%08x,%08x", codec
->vendor_id
,
821 codec
->subsystem_id
, codec
->revision_id
);
822 snd_component_add(codec
->bus
->card
, component
);
828 EXPORT_SYMBOL_HDA(snd_hda_codec_new
);
830 int snd_hda_codec_configure(struct hda_codec
*codec
)
834 codec
->preset
= find_codec_preset(codec
);
836 err
= get_codec_name(codec
);
840 /* audio codec should override the mixer name */
841 if (codec
->afg
|| !*codec
->bus
->card
->mixername
)
842 strlcpy(codec
->bus
->card
->mixername
, codec
->name
,
843 sizeof(codec
->bus
->card
->mixername
));
845 if (is_generic_config(codec
)) {
846 err
= snd_hda_parse_generic_codec(codec
);
849 if (codec
->preset
&& codec
->preset
->patch
) {
850 err
= codec
->preset
->patch(codec
);
854 /* call the default parser */
855 err
= snd_hda_parse_generic_codec(codec
);
857 printk(KERN_ERR
"hda-codec: No codec parser is available\n");
860 if (!err
&& codec
->patch_ops
.unsol_event
)
861 err
= init_unsol_queue(codec
->bus
);
866 * snd_hda_codec_setup_stream - set up the codec for streaming
867 * @codec: the CODEC to set up
868 * @nid: the NID to set up
869 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
870 * @channel_id: channel id to pass, zero based.
871 * @format: stream format.
873 void snd_hda_codec_setup_stream(struct hda_codec
*codec
, hda_nid_t nid
,
875 int channel_id
, int format
)
880 snd_printdd("hda_codec_setup_stream: "
881 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
882 nid
, stream_tag
, channel_id
, format
);
883 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CHANNEL_STREAMID
,
884 (stream_tag
<< 4) | channel_id
);
886 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_STREAM_FORMAT
, format
);
888 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream
);
890 void snd_hda_codec_cleanup_stream(struct hda_codec
*codec
, hda_nid_t nid
)
895 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid
);
896 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CHANNEL_STREAMID
, 0);
897 #if 0 /* keep the format */
899 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_STREAM_FORMAT
, 0);
902 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream
);
905 * amp access functions
908 /* FIXME: more better hash key? */
909 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
910 #define INFO_AMP_CAPS (1<<0)
911 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
913 /* initialize the hash table */
914 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec
*cache
,
915 unsigned int record_size
)
917 memset(cache
, 0, sizeof(*cache
));
918 memset(cache
->hash
, 0xff, sizeof(cache
->hash
));
919 snd_array_init(&cache
->buf
, record_size
, 64);
922 static void free_hda_cache(struct hda_cache_rec
*cache
)
924 snd_array_free(&cache
->buf
);
927 /* query the hash. allocate an entry if not found. */
928 static struct hda_cache_head
*get_alloc_hash(struct hda_cache_rec
*cache
,
931 u16 idx
= key
% (u16
)ARRAY_SIZE(cache
->hash
);
932 u16 cur
= cache
->hash
[idx
];
933 struct hda_cache_head
*info
;
935 while (cur
!= 0xffff) {
936 info
= snd_array_elem(&cache
->buf
, cur
);
937 if (info
->key
== key
)
942 /* add a new hash entry */
943 info
= snd_array_new(&cache
->buf
);
946 cur
= snd_array_index(&cache
->buf
, info
);
949 info
->next
= cache
->hash
[idx
];
950 cache
->hash
[idx
] = cur
;
955 /* query and allocate an amp hash entry */
956 static inline struct hda_amp_info
*
957 get_alloc_amp_hash(struct hda_codec
*codec
, u32 key
)
959 return (struct hda_amp_info
*)get_alloc_hash(&codec
->amp_cache
, key
);
963 * query AMP capabilities for the given widget and direction
965 u32
query_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int direction
)
967 struct hda_amp_info
*info
;
969 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, 0));
972 if (!(info
->head
.val
& INFO_AMP_CAPS
)) {
973 if (!(get_wcaps(codec
, nid
) & AC_WCAP_AMP_OVRD
))
975 info
->amp_caps
= snd_hda_param_read(codec
, nid
,
976 direction
== HDA_OUTPUT
?
980 info
->head
.val
|= INFO_AMP_CAPS
;
982 return info
->amp_caps
;
984 EXPORT_SYMBOL_HDA(query_amp_caps
);
986 int snd_hda_override_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
989 struct hda_amp_info
*info
;
991 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, dir
, 0));
994 info
->amp_caps
= caps
;
995 info
->head
.val
|= INFO_AMP_CAPS
;
998 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps
);
1001 * read the current volume to info
1002 * if the cache exists, read the cache value.
1004 static unsigned int get_vol_mute(struct hda_codec
*codec
,
1005 struct hda_amp_info
*info
, hda_nid_t nid
,
1006 int ch
, int direction
, int index
)
1010 if (info
->head
.val
& INFO_AMP_VOL(ch
))
1011 return info
->vol
[ch
];
1013 parm
= ch
? AC_AMP_GET_RIGHT
: AC_AMP_GET_LEFT
;
1014 parm
|= direction
== HDA_OUTPUT
? AC_AMP_GET_OUTPUT
: AC_AMP_GET_INPUT
;
1016 val
= snd_hda_codec_read(codec
, nid
, 0,
1017 AC_VERB_GET_AMP_GAIN_MUTE
, parm
);
1018 info
->vol
[ch
] = val
& 0xff;
1019 info
->head
.val
|= INFO_AMP_VOL(ch
);
1020 return info
->vol
[ch
];
1024 * write the current volume in info to the h/w and update the cache
1026 static void put_vol_mute(struct hda_codec
*codec
, struct hda_amp_info
*info
,
1027 hda_nid_t nid
, int ch
, int direction
, int index
,
1032 parm
= ch
? AC_AMP_SET_RIGHT
: AC_AMP_SET_LEFT
;
1033 parm
|= direction
== HDA_OUTPUT
? AC_AMP_SET_OUTPUT
: AC_AMP_SET_INPUT
;
1034 parm
|= index
<< AC_AMP_SET_INDEX_SHIFT
;
1036 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, parm
);
1037 info
->vol
[ch
] = val
;
1041 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1043 int snd_hda_codec_amp_read(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1044 int direction
, int index
)
1046 struct hda_amp_info
*info
;
1047 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, index
));
1050 return get_vol_mute(codec
, info
, nid
, ch
, direction
, index
);
1052 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read
);
1055 * update the AMP value, mask = bit mask to set, val = the value
1057 int snd_hda_codec_amp_update(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1058 int direction
, int idx
, int mask
, int val
)
1060 struct hda_amp_info
*info
;
1062 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, idx
));
1066 val
|= get_vol_mute(codec
, info
, nid
, ch
, direction
, idx
) & ~mask
;
1067 if (info
->vol
[ch
] == val
)
1069 put_vol_mute(codec
, info
, nid
, ch
, direction
, idx
, val
);
1072 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update
);
1075 * update the AMP stereo with the same mask and value
1077 int snd_hda_codec_amp_stereo(struct hda_codec
*codec
, hda_nid_t nid
,
1078 int direction
, int idx
, int mask
, int val
)
1081 for (ch
= 0; ch
< 2; ch
++)
1082 ret
|= snd_hda_codec_amp_update(codec
, nid
, ch
, direction
,
1086 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo
);
1088 #ifdef SND_HDA_NEEDS_RESUME
1089 /* resume the all amp commands from the cache */
1090 void snd_hda_codec_resume_amp(struct hda_codec
*codec
)
1092 struct hda_amp_info
*buffer
= codec
->amp_cache
.buf
.list
;
1095 for (i
= 0; i
< codec
->amp_cache
.buf
.used
; i
++, buffer
++) {
1096 u32 key
= buffer
->head
.key
;
1098 unsigned int idx
, dir
, ch
;
1102 idx
= (key
>> 16) & 0xff;
1103 dir
= (key
>> 24) & 0xff;
1104 for (ch
= 0; ch
< 2; ch
++) {
1105 if (!(buffer
->head
.val
& INFO_AMP_VOL(ch
)))
1107 put_vol_mute(codec
, buffer
, nid
, ch
, dir
, idx
,
1112 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp
);
1113 #endif /* SND_HDA_NEEDS_RESUME */
1116 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol
*kcontrol
,
1117 struct snd_ctl_elem_info
*uinfo
)
1119 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1120 u16 nid
= get_amp_nid(kcontrol
);
1121 u8 chs
= get_amp_channels(kcontrol
);
1122 int dir
= get_amp_direction(kcontrol
);
1125 caps
= query_amp_caps(codec
, nid
, dir
);
1127 caps
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1129 printk(KERN_WARNING
"hda_codec: "
1130 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid
,
1134 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1135 uinfo
->count
= chs
== 3 ? 2 : 1;
1136 uinfo
->value
.integer
.min
= 0;
1137 uinfo
->value
.integer
.max
= caps
;
1140 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info
);
1142 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol
*kcontrol
,
1143 struct snd_ctl_elem_value
*ucontrol
)
1145 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1146 hda_nid_t nid
= get_amp_nid(kcontrol
);
1147 int chs
= get_amp_channels(kcontrol
);
1148 int dir
= get_amp_direction(kcontrol
);
1149 int idx
= get_amp_index(kcontrol
);
1150 long *valp
= ucontrol
->value
.integer
.value
;
1153 *valp
++ = snd_hda_codec_amp_read(codec
, nid
, 0, dir
, idx
)
1156 *valp
= snd_hda_codec_amp_read(codec
, nid
, 1, dir
, idx
)
1160 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get
);
1162 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol
*kcontrol
,
1163 struct snd_ctl_elem_value
*ucontrol
)
1165 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1166 hda_nid_t nid
= get_amp_nid(kcontrol
);
1167 int chs
= get_amp_channels(kcontrol
);
1168 int dir
= get_amp_direction(kcontrol
);
1169 int idx
= get_amp_index(kcontrol
);
1170 long *valp
= ucontrol
->value
.integer
.value
;
1173 snd_hda_power_up(codec
);
1175 change
= snd_hda_codec_amp_update(codec
, nid
, 0, dir
, idx
,
1180 change
|= snd_hda_codec_amp_update(codec
, nid
, 1, dir
, idx
,
1182 snd_hda_power_down(codec
);
1185 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put
);
1187 int snd_hda_mixer_amp_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
1188 unsigned int size
, unsigned int __user
*_tlv
)
1190 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1191 hda_nid_t nid
= get_amp_nid(kcontrol
);
1192 int dir
= get_amp_direction(kcontrol
);
1193 u32 caps
, val1
, val2
;
1195 if (size
< 4 * sizeof(unsigned int))
1197 caps
= query_amp_caps(codec
, nid
, dir
);
1198 val2
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1199 val2
= (val2
+ 1) * 25;
1200 val1
= -((caps
& AC_AMPCAP_OFFSET
) >> AC_AMPCAP_OFFSET_SHIFT
);
1201 val1
= ((int)val1
) * ((int)val2
);
1202 if (put_user(SNDRV_CTL_TLVT_DB_SCALE
, _tlv
))
1204 if (put_user(2 * sizeof(unsigned int), _tlv
+ 1))
1206 if (put_user(val1
, _tlv
+ 2))
1208 if (put_user(val2
, _tlv
+ 3))
1212 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv
);
1215 * set (static) TLV for virtual master volume; recalculated as max 0dB
1217 void snd_hda_set_vmaster_tlv(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1223 caps
= query_amp_caps(codec
, nid
, dir
);
1224 nums
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1225 step
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1226 step
= (step
+ 1) * 25;
1227 tlv
[0] = SNDRV_CTL_TLVT_DB_SCALE
;
1228 tlv
[1] = 2 * sizeof(unsigned int);
1229 tlv
[2] = -nums
* step
;
1232 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv
);
1234 /* find a mixer control element with the given name */
1235 static struct snd_kcontrol
*
1236 _snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
1237 const char *name
, int idx
)
1239 struct snd_ctl_elem_id id
;
1240 memset(&id
, 0, sizeof(id
));
1241 id
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1243 strcpy(id
.name
, name
);
1244 return snd_ctl_find_id(codec
->bus
->card
, &id
);
1247 struct snd_kcontrol
*snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
1250 return _snd_hda_find_mixer_ctl(codec
, name
, 0);
1252 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl
);
1254 /* Add a control element and assign to the codec */
1255 int snd_hda_ctl_add(struct hda_codec
*codec
, struct snd_kcontrol
*kctl
)
1258 struct snd_kcontrol
**knewp
;
1260 err
= snd_ctl_add(codec
->bus
->card
, kctl
);
1263 knewp
= snd_array_new(&codec
->mixers
);
1269 EXPORT_SYMBOL_HDA(snd_hda_ctl_add
);
1271 #ifdef CONFIG_SND_HDA_RECONFIG
1272 /* Clear all controls assigned to the given codec */
1273 void snd_hda_ctls_clear(struct hda_codec
*codec
)
1276 struct snd_kcontrol
**kctls
= codec
->mixers
.list
;
1277 for (i
= 0; i
< codec
->mixers
.used
; i
++)
1278 snd_ctl_remove(codec
->bus
->card
, kctls
[i
]);
1279 snd_array_free(&codec
->mixers
);
1282 void snd_hda_codec_reset(struct hda_codec
*codec
)
1286 #ifdef CONFIG_SND_HDA_POWER_SAVE
1287 cancel_delayed_work(&codec
->power_work
);
1288 flush_workqueue(codec
->bus
->workq
);
1290 snd_hda_ctls_clear(codec
);
1292 for (i
= 0; i
< codec
->num_pcms
; i
++) {
1293 if (codec
->pcm_info
[i
].pcm
) {
1294 snd_device_free(codec
->bus
->card
,
1295 codec
->pcm_info
[i
].pcm
);
1296 clear_bit(codec
->pcm_info
[i
].device
,
1297 codec
->bus
->pcm_dev_bits
);
1300 if (codec
->patch_ops
.free
)
1301 codec
->patch_ops
.free(codec
);
1302 codec
->proc_widget_hook
= NULL
;
1304 free_hda_cache(&codec
->amp_cache
);
1305 free_hda_cache(&codec
->cmd_cache
);
1306 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
1307 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
1308 codec
->num_pcms
= 0;
1309 codec
->pcm_info
= NULL
;
1310 codec
->preset
= NULL
;
1311 module_put(codec
->owner
);
1312 codec
->owner
= NULL
;
1314 #endif /* CONFIG_SND_HDA_RECONFIG */
1316 /* create a virtual master control and add slaves */
1317 int snd_hda_add_vmaster(struct hda_codec
*codec
, char *name
,
1318 unsigned int *tlv
, const char **slaves
)
1320 struct snd_kcontrol
*kctl
;
1324 for (s
= slaves
; *s
&& !snd_hda_find_mixer_ctl(codec
, *s
); s
++)
1327 snd_printdd("No slave found for %s\n", name
);
1330 kctl
= snd_ctl_make_virtual_master(name
, tlv
);
1333 err
= snd_hda_ctl_add(codec
, kctl
);
1337 for (s
= slaves
; *s
; s
++) {
1338 struct snd_kcontrol
*sctl
;
1340 sctl
= snd_hda_find_mixer_ctl(codec
, *s
);
1342 snd_printdd("Cannot find slave %s, skipped\n", *s
);
1345 err
= snd_ctl_add_slave(kctl
, sctl
);
1351 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster
);
1354 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol
*kcontrol
,
1355 struct snd_ctl_elem_info
*uinfo
)
1357 int chs
= get_amp_channels(kcontrol
);
1359 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
1360 uinfo
->count
= chs
== 3 ? 2 : 1;
1361 uinfo
->value
.integer
.min
= 0;
1362 uinfo
->value
.integer
.max
= 1;
1365 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info
);
1367 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol
*kcontrol
,
1368 struct snd_ctl_elem_value
*ucontrol
)
1370 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1371 hda_nid_t nid
= get_amp_nid(kcontrol
);
1372 int chs
= get_amp_channels(kcontrol
);
1373 int dir
= get_amp_direction(kcontrol
);
1374 int idx
= get_amp_index(kcontrol
);
1375 long *valp
= ucontrol
->value
.integer
.value
;
1378 *valp
++ = (snd_hda_codec_amp_read(codec
, nid
, 0, dir
, idx
) &
1379 HDA_AMP_MUTE
) ? 0 : 1;
1381 *valp
= (snd_hda_codec_amp_read(codec
, nid
, 1, dir
, idx
) &
1382 HDA_AMP_MUTE
) ? 0 : 1;
1385 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get
);
1387 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol
*kcontrol
,
1388 struct snd_ctl_elem_value
*ucontrol
)
1390 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1391 hda_nid_t nid
= get_amp_nid(kcontrol
);
1392 int chs
= get_amp_channels(kcontrol
);
1393 int dir
= get_amp_direction(kcontrol
);
1394 int idx
= get_amp_index(kcontrol
);
1395 long *valp
= ucontrol
->value
.integer
.value
;
1398 snd_hda_power_up(codec
);
1400 change
= snd_hda_codec_amp_update(codec
, nid
, 0, dir
, idx
,
1402 *valp
? 0 : HDA_AMP_MUTE
);
1406 change
|= snd_hda_codec_amp_update(codec
, nid
, 1, dir
, idx
,
1408 *valp
? 0 : HDA_AMP_MUTE
);
1409 #ifdef CONFIG_SND_HDA_POWER_SAVE
1410 if (codec
->patch_ops
.check_power_status
)
1411 codec
->patch_ops
.check_power_status(codec
, nid
);
1413 snd_hda_power_down(codec
);
1416 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put
);
1419 * bound volume controls
1421 * bind multiple volumes (# indices, from 0)
1424 #define AMP_VAL_IDX_SHIFT 19
1425 #define AMP_VAL_IDX_MASK (0x0f<<19)
1427 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol
*kcontrol
,
1428 struct snd_ctl_elem_value
*ucontrol
)
1430 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1434 mutex_lock(&codec
->control_mutex
);
1435 pval
= kcontrol
->private_value
;
1436 kcontrol
->private_value
= pval
& ~AMP_VAL_IDX_MASK
; /* index 0 */
1437 err
= snd_hda_mixer_amp_switch_get(kcontrol
, ucontrol
);
1438 kcontrol
->private_value
= pval
;
1439 mutex_unlock(&codec
->control_mutex
);
1442 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get
);
1444 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol
*kcontrol
,
1445 struct snd_ctl_elem_value
*ucontrol
)
1447 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1449 int i
, indices
, err
= 0, change
= 0;
1451 mutex_lock(&codec
->control_mutex
);
1452 pval
= kcontrol
->private_value
;
1453 indices
= (pval
& AMP_VAL_IDX_MASK
) >> AMP_VAL_IDX_SHIFT
;
1454 for (i
= 0; i
< indices
; i
++) {
1455 kcontrol
->private_value
= (pval
& ~AMP_VAL_IDX_MASK
) |
1456 (i
<< AMP_VAL_IDX_SHIFT
);
1457 err
= snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
1462 kcontrol
->private_value
= pval
;
1463 mutex_unlock(&codec
->control_mutex
);
1464 return err
< 0 ? err
: change
;
1466 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put
);
1469 * generic bound volume/swtich controls
1471 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol
*kcontrol
,
1472 struct snd_ctl_elem_info
*uinfo
)
1474 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1475 struct hda_bind_ctls
*c
;
1478 mutex_lock(&codec
->control_mutex
);
1479 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1480 kcontrol
->private_value
= *c
->values
;
1481 err
= c
->ops
->info(kcontrol
, uinfo
);
1482 kcontrol
->private_value
= (long)c
;
1483 mutex_unlock(&codec
->control_mutex
);
1486 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info
);
1488 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol
*kcontrol
,
1489 struct snd_ctl_elem_value
*ucontrol
)
1491 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1492 struct hda_bind_ctls
*c
;
1495 mutex_lock(&codec
->control_mutex
);
1496 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1497 kcontrol
->private_value
= *c
->values
;
1498 err
= c
->ops
->get(kcontrol
, ucontrol
);
1499 kcontrol
->private_value
= (long)c
;
1500 mutex_unlock(&codec
->control_mutex
);
1503 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get
);
1505 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol
*kcontrol
,
1506 struct snd_ctl_elem_value
*ucontrol
)
1508 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1509 struct hda_bind_ctls
*c
;
1510 unsigned long *vals
;
1511 int err
= 0, change
= 0;
1513 mutex_lock(&codec
->control_mutex
);
1514 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1515 for (vals
= c
->values
; *vals
; vals
++) {
1516 kcontrol
->private_value
= *vals
;
1517 err
= c
->ops
->put(kcontrol
, ucontrol
);
1522 kcontrol
->private_value
= (long)c
;
1523 mutex_unlock(&codec
->control_mutex
);
1524 return err
< 0 ? err
: change
;
1526 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put
);
1528 int snd_hda_mixer_bind_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
1529 unsigned int size
, unsigned int __user
*tlv
)
1531 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1532 struct hda_bind_ctls
*c
;
1535 mutex_lock(&codec
->control_mutex
);
1536 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1537 kcontrol
->private_value
= *c
->values
;
1538 err
= c
->ops
->tlv(kcontrol
, op_flag
, size
, tlv
);
1539 kcontrol
->private_value
= (long)c
;
1540 mutex_unlock(&codec
->control_mutex
);
1543 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv
);
1545 struct hda_ctl_ops snd_hda_bind_vol
= {
1546 .info
= snd_hda_mixer_amp_volume_info
,
1547 .get
= snd_hda_mixer_amp_volume_get
,
1548 .put
= snd_hda_mixer_amp_volume_put
,
1549 .tlv
= snd_hda_mixer_amp_tlv
1551 EXPORT_SYMBOL_HDA(snd_hda_bind_vol
);
1553 struct hda_ctl_ops snd_hda_bind_sw
= {
1554 .info
= snd_hda_mixer_amp_switch_info
,
1555 .get
= snd_hda_mixer_amp_switch_get
,
1556 .put
= snd_hda_mixer_amp_switch_put
,
1557 .tlv
= snd_hda_mixer_amp_tlv
1559 EXPORT_SYMBOL_HDA(snd_hda_bind_sw
);
1562 * SPDIF out controls
1565 static int snd_hda_spdif_mask_info(struct snd_kcontrol
*kcontrol
,
1566 struct snd_ctl_elem_info
*uinfo
)
1568 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
1573 static int snd_hda_spdif_cmask_get(struct snd_kcontrol
*kcontrol
,
1574 struct snd_ctl_elem_value
*ucontrol
)
1576 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
1577 IEC958_AES0_NONAUDIO
|
1578 IEC958_AES0_CON_EMPHASIS_5015
|
1579 IEC958_AES0_CON_NOT_COPYRIGHT
;
1580 ucontrol
->value
.iec958
.status
[1] = IEC958_AES1_CON_CATEGORY
|
1581 IEC958_AES1_CON_ORIGINAL
;
1585 static int snd_hda_spdif_pmask_get(struct snd_kcontrol
*kcontrol
,
1586 struct snd_ctl_elem_value
*ucontrol
)
1588 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
1589 IEC958_AES0_NONAUDIO
|
1590 IEC958_AES0_PRO_EMPHASIS_5015
;
1594 static int snd_hda_spdif_default_get(struct snd_kcontrol
*kcontrol
,
1595 struct snd_ctl_elem_value
*ucontrol
)
1597 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1599 ucontrol
->value
.iec958
.status
[0] = codec
->spdif_status
& 0xff;
1600 ucontrol
->value
.iec958
.status
[1] = (codec
->spdif_status
>> 8) & 0xff;
1601 ucontrol
->value
.iec958
.status
[2] = (codec
->spdif_status
>> 16) & 0xff;
1602 ucontrol
->value
.iec958
.status
[3] = (codec
->spdif_status
>> 24) & 0xff;
1607 /* convert from SPDIF status bits to HDA SPDIF bits
1608 * bit 0 (DigEn) is always set zero (to be filled later)
1610 static unsigned short convert_from_spdif_status(unsigned int sbits
)
1612 unsigned short val
= 0;
1614 if (sbits
& IEC958_AES0_PROFESSIONAL
)
1615 val
|= AC_DIG1_PROFESSIONAL
;
1616 if (sbits
& IEC958_AES0_NONAUDIO
)
1617 val
|= AC_DIG1_NONAUDIO
;
1618 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
1619 if ((sbits
& IEC958_AES0_PRO_EMPHASIS
) ==
1620 IEC958_AES0_PRO_EMPHASIS_5015
)
1621 val
|= AC_DIG1_EMPHASIS
;
1623 if ((sbits
& IEC958_AES0_CON_EMPHASIS
) ==
1624 IEC958_AES0_CON_EMPHASIS_5015
)
1625 val
|= AC_DIG1_EMPHASIS
;
1626 if (!(sbits
& IEC958_AES0_CON_NOT_COPYRIGHT
))
1627 val
|= AC_DIG1_COPYRIGHT
;
1628 if (sbits
& (IEC958_AES1_CON_ORIGINAL
<< 8))
1629 val
|= AC_DIG1_LEVEL
;
1630 val
|= sbits
& (IEC958_AES1_CON_CATEGORY
<< 8);
1635 /* convert to SPDIF status bits from HDA SPDIF bits
1637 static unsigned int convert_to_spdif_status(unsigned short val
)
1639 unsigned int sbits
= 0;
1641 if (val
& AC_DIG1_NONAUDIO
)
1642 sbits
|= IEC958_AES0_NONAUDIO
;
1643 if (val
& AC_DIG1_PROFESSIONAL
)
1644 sbits
|= IEC958_AES0_PROFESSIONAL
;
1645 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
1646 if (sbits
& AC_DIG1_EMPHASIS
)
1647 sbits
|= IEC958_AES0_PRO_EMPHASIS_5015
;
1649 if (val
& AC_DIG1_EMPHASIS
)
1650 sbits
|= IEC958_AES0_CON_EMPHASIS_5015
;
1651 if (!(val
& AC_DIG1_COPYRIGHT
))
1652 sbits
|= IEC958_AES0_CON_NOT_COPYRIGHT
;
1653 if (val
& AC_DIG1_LEVEL
)
1654 sbits
|= (IEC958_AES1_CON_ORIGINAL
<< 8);
1655 sbits
|= val
& (0x7f << 8);
1660 /* set digital convert verbs both for the given NID and its slaves */
1661 static void set_dig_out(struct hda_codec
*codec
, hda_nid_t nid
,
1666 snd_hda_codec_write_cache(codec
, nid
, 0, verb
, val
);
1667 d
= codec
->slave_dig_outs
;
1671 snd_hda_codec_write_cache(codec
, *d
, 0, verb
, val
);
1674 static inline void set_dig_out_convert(struct hda_codec
*codec
, hda_nid_t nid
,
1678 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_1
, dig1
);
1680 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_2
, dig2
);
1683 static int snd_hda_spdif_default_put(struct snd_kcontrol
*kcontrol
,
1684 struct snd_ctl_elem_value
*ucontrol
)
1686 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1687 hda_nid_t nid
= kcontrol
->private_value
;
1691 mutex_lock(&codec
->spdif_mutex
);
1692 codec
->spdif_status
= ucontrol
->value
.iec958
.status
[0] |
1693 ((unsigned int)ucontrol
->value
.iec958
.status
[1] << 8) |
1694 ((unsigned int)ucontrol
->value
.iec958
.status
[2] << 16) |
1695 ((unsigned int)ucontrol
->value
.iec958
.status
[3] << 24);
1696 val
= convert_from_spdif_status(codec
->spdif_status
);
1697 val
|= codec
->spdif_ctls
& 1;
1698 change
= codec
->spdif_ctls
!= val
;
1699 codec
->spdif_ctls
= val
;
1702 set_dig_out_convert(codec
, nid
, val
& 0xff, (val
>> 8) & 0xff);
1704 mutex_unlock(&codec
->spdif_mutex
);
1708 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1710 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol
*kcontrol
,
1711 struct snd_ctl_elem_value
*ucontrol
)
1713 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1715 ucontrol
->value
.integer
.value
[0] = codec
->spdif_ctls
& AC_DIG1_ENABLE
;
1719 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol
*kcontrol
,
1720 struct snd_ctl_elem_value
*ucontrol
)
1722 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1723 hda_nid_t nid
= kcontrol
->private_value
;
1727 mutex_lock(&codec
->spdif_mutex
);
1728 val
= codec
->spdif_ctls
& ~AC_DIG1_ENABLE
;
1729 if (ucontrol
->value
.integer
.value
[0])
1730 val
|= AC_DIG1_ENABLE
;
1731 change
= codec
->spdif_ctls
!= val
;
1733 codec
->spdif_ctls
= val
;
1734 set_dig_out_convert(codec
, nid
, val
& 0xff, -1);
1735 /* unmute amp switch (if any) */
1736 if ((get_wcaps(codec
, nid
) & AC_WCAP_OUT_AMP
) &&
1737 (val
& AC_DIG1_ENABLE
))
1738 snd_hda_codec_amp_stereo(codec
, nid
, HDA_OUTPUT
, 0,
1741 mutex_unlock(&codec
->spdif_mutex
);
1745 static struct snd_kcontrol_new dig_mixes
[] = {
1747 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
1748 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1749 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,CON_MASK
),
1750 .info
= snd_hda_spdif_mask_info
,
1751 .get
= snd_hda_spdif_cmask_get
,
1754 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
1755 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1756 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,PRO_MASK
),
1757 .info
= snd_hda_spdif_mask_info
,
1758 .get
= snd_hda_spdif_pmask_get
,
1761 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1762 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,DEFAULT
),
1763 .info
= snd_hda_spdif_mask_info
,
1764 .get
= snd_hda_spdif_default_get
,
1765 .put
= snd_hda_spdif_default_put
,
1768 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1769 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,SWITCH
),
1770 .info
= snd_hda_spdif_out_switch_info
,
1771 .get
= snd_hda_spdif_out_switch_get
,
1772 .put
= snd_hda_spdif_out_switch_put
,
1777 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1780 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1781 * @codec: the HDA codec
1782 * @nid: audio out widget NID
1784 * Creates controls related with the SPDIF output.
1785 * Called from each patch supporting the SPDIF out.
1787 * Returns 0 if successful, or a negative error code.
1789 int snd_hda_create_spdif_out_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
1792 struct snd_kcontrol
*kctl
;
1793 struct snd_kcontrol_new
*dig_mix
;
1796 for (idx
= 0; idx
< SPDIF_MAX_IDX
; idx
++) {
1797 if (!_snd_hda_find_mixer_ctl(codec
, "IEC958 Playback Switch",
1801 if (idx
>= SPDIF_MAX_IDX
) {
1802 printk(KERN_ERR
"hda_codec: too many IEC958 outputs\n");
1805 for (dig_mix
= dig_mixes
; dig_mix
->name
; dig_mix
++) {
1806 kctl
= snd_ctl_new1(dig_mix
, codec
);
1809 kctl
->id
.index
= idx
;
1810 kctl
->private_value
= nid
;
1811 err
= snd_hda_ctl_add(codec
, kctl
);
1816 snd_hda_codec_read(codec
, nid
, 0,
1817 AC_VERB_GET_DIGI_CONVERT_1
, 0);
1818 codec
->spdif_status
= convert_to_spdif_status(codec
->spdif_ctls
);
1821 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls
);
1824 * SPDIF sharing with analog output
1826 static int spdif_share_sw_get(struct snd_kcontrol
*kcontrol
,
1827 struct snd_ctl_elem_value
*ucontrol
)
1829 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
1830 ucontrol
->value
.integer
.value
[0] = mout
->share_spdif
;
1834 static int spdif_share_sw_put(struct snd_kcontrol
*kcontrol
,
1835 struct snd_ctl_elem_value
*ucontrol
)
1837 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
1838 mout
->share_spdif
= !!ucontrol
->value
.integer
.value
[0];
1842 static struct snd_kcontrol_new spdif_share_sw
= {
1843 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1844 .name
= "IEC958 Default PCM Playback Switch",
1845 .info
= snd_ctl_boolean_mono_info
,
1846 .get
= spdif_share_sw_get
,
1847 .put
= spdif_share_sw_put
,
1850 int snd_hda_create_spdif_share_sw(struct hda_codec
*codec
,
1851 struct hda_multi_out
*mout
)
1853 if (!mout
->dig_out_nid
)
1855 /* ATTENTION: here mout is passed as private_data, instead of codec */
1856 return snd_hda_ctl_add(codec
,
1857 snd_ctl_new1(&spdif_share_sw
, mout
));
1859 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw
);
1865 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
1867 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol
*kcontrol
,
1868 struct snd_ctl_elem_value
*ucontrol
)
1870 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1872 ucontrol
->value
.integer
.value
[0] = codec
->spdif_in_enable
;
1876 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol
*kcontrol
,
1877 struct snd_ctl_elem_value
*ucontrol
)
1879 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1880 hda_nid_t nid
= kcontrol
->private_value
;
1881 unsigned int val
= !!ucontrol
->value
.integer
.value
[0];
1884 mutex_lock(&codec
->spdif_mutex
);
1885 change
= codec
->spdif_in_enable
!= val
;
1887 codec
->spdif_in_enable
= val
;
1888 snd_hda_codec_write_cache(codec
, nid
, 0,
1889 AC_VERB_SET_DIGI_CONVERT_1
, val
);
1891 mutex_unlock(&codec
->spdif_mutex
);
1895 static int snd_hda_spdif_in_status_get(struct snd_kcontrol
*kcontrol
,
1896 struct snd_ctl_elem_value
*ucontrol
)
1898 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1899 hda_nid_t nid
= kcontrol
->private_value
;
1903 val
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_DIGI_CONVERT_1
, 0);
1904 sbits
= convert_to_spdif_status(val
);
1905 ucontrol
->value
.iec958
.status
[0] = sbits
;
1906 ucontrol
->value
.iec958
.status
[1] = sbits
>> 8;
1907 ucontrol
->value
.iec958
.status
[2] = sbits
>> 16;
1908 ucontrol
->value
.iec958
.status
[3] = sbits
>> 24;
1912 static struct snd_kcontrol_new dig_in_ctls
[] = {
1914 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1915 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,SWITCH
),
1916 .info
= snd_hda_spdif_in_switch_info
,
1917 .get
= snd_hda_spdif_in_switch_get
,
1918 .put
= snd_hda_spdif_in_switch_put
,
1921 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
1922 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1923 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,DEFAULT
),
1924 .info
= snd_hda_spdif_mask_info
,
1925 .get
= snd_hda_spdif_in_status_get
,
1931 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1932 * @codec: the HDA codec
1933 * @nid: audio in widget NID
1935 * Creates controls related with the SPDIF input.
1936 * Called from each patch supporting the SPDIF in.
1938 * Returns 0 if successful, or a negative error code.
1940 int snd_hda_create_spdif_in_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
1943 struct snd_kcontrol
*kctl
;
1944 struct snd_kcontrol_new
*dig_mix
;
1947 for (idx
= 0; idx
< SPDIF_MAX_IDX
; idx
++) {
1948 if (!_snd_hda_find_mixer_ctl(codec
, "IEC958 Capture Switch",
1952 if (idx
>= SPDIF_MAX_IDX
) {
1953 printk(KERN_ERR
"hda_codec: too many IEC958 inputs\n");
1956 for (dig_mix
= dig_in_ctls
; dig_mix
->name
; dig_mix
++) {
1957 kctl
= snd_ctl_new1(dig_mix
, codec
);
1958 kctl
->private_value
= nid
;
1959 err
= snd_hda_ctl_add(codec
, kctl
);
1963 codec
->spdif_in_enable
=
1964 snd_hda_codec_read(codec
, nid
, 0,
1965 AC_VERB_GET_DIGI_CONVERT_1
, 0) &
1969 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls
);
1971 #ifdef SND_HDA_NEEDS_RESUME
1976 /* build a 32bit cache key with the widget id and the command parameter */
1977 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
1978 #define get_cmd_cache_nid(key) ((key) & 0xff)
1979 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
1982 * snd_hda_codec_write_cache - send a single command with caching
1983 * @codec: the HDA codec
1984 * @nid: NID to send the command
1985 * @direct: direct flag
1986 * @verb: the verb to send
1987 * @parm: the parameter for the verb
1989 * Send a single command without waiting for response.
1991 * Returns 0 if successful, or a negative error code.
1993 int snd_hda_codec_write_cache(struct hda_codec
*codec
, hda_nid_t nid
,
1994 int direct
, unsigned int verb
, unsigned int parm
)
1996 struct hda_bus
*bus
= codec
->bus
;
2000 res
= make_codec_cmd(codec
, nid
, direct
, verb
, parm
);
2001 snd_hda_power_up(codec
);
2002 mutex_lock(&bus
->cmd_mutex
);
2003 err
= bus
->ops
.command(bus
, res
);
2005 struct hda_cache_head
*c
;
2006 u32 key
= build_cmd_cache_key(nid
, verb
);
2007 c
= get_alloc_hash(&codec
->cmd_cache
, key
);
2011 mutex_unlock(&bus
->cmd_mutex
);
2012 snd_hda_power_down(codec
);
2015 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache
);
2017 /* resume the all commands from the cache */
2018 void snd_hda_codec_resume_cache(struct hda_codec
*codec
)
2020 struct hda_cache_head
*buffer
= codec
->cmd_cache
.buf
.list
;
2023 for (i
= 0; i
< codec
->cmd_cache
.buf
.used
; i
++, buffer
++) {
2024 u32 key
= buffer
->key
;
2027 snd_hda_codec_write(codec
, get_cmd_cache_nid(key
), 0,
2028 get_cmd_cache_cmd(key
), buffer
->val
);
2031 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache
);
2034 * snd_hda_sequence_write_cache - sequence writes with caching
2035 * @codec: the HDA codec
2036 * @seq: VERB array to send
2038 * Send the commands sequentially from the given array.
2039 * Thte commands are recorded on cache for power-save and resume.
2040 * The array must be terminated with NID=0.
2042 void snd_hda_sequence_write_cache(struct hda_codec
*codec
,
2043 const struct hda_verb
*seq
)
2045 for (; seq
->nid
; seq
++)
2046 snd_hda_codec_write_cache(codec
, seq
->nid
, 0, seq
->verb
,
2049 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache
);
2050 #endif /* SND_HDA_NEEDS_RESUME */
2053 * set power state of the codec
2055 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
2056 unsigned int power_state
)
2061 snd_hda_codec_write(codec
, fg
, 0, AC_VERB_SET_POWER_STATE
,
2063 msleep(10); /* partial workaround for "azx_get_response timeout" */
2065 nid
= codec
->start_nid
;
2066 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
2067 unsigned int wcaps
= get_wcaps(codec
, nid
);
2068 if (wcaps
& AC_WCAP_POWER
) {
2069 unsigned int wid_type
= (wcaps
& AC_WCAP_TYPE
) >>
2071 if (wid_type
== AC_WID_PIN
) {
2072 unsigned int pincap
;
2074 * don't power down the widget if it controls
2075 * eapd and EAPD_BTLENABLE is set.
2077 pincap
= snd_hda_param_read(codec
, nid
,
2079 if (pincap
& AC_PINCAP_EAPD
) {
2080 int eapd
= snd_hda_codec_read(codec
,
2082 AC_VERB_GET_EAPD_BTLENABLE
, 0);
2084 if (power_state
== AC_PWRST_D3
&& eapd
)
2088 snd_hda_codec_write(codec
, nid
, 0,
2089 AC_VERB_SET_POWER_STATE
,
2094 if (power_state
== AC_PWRST_D0
) {
2095 unsigned long end_time
;
2098 /* wait until the codec reachs to D0 */
2099 end_time
= jiffies
+ msecs_to_jiffies(500);
2101 state
= snd_hda_codec_read(codec
, fg
, 0,
2102 AC_VERB_GET_POWER_STATE
, 0);
2103 if (state
== power_state
)
2106 } while (time_after_eq(end_time
, jiffies
));
2110 #ifdef CONFIG_SND_HDA_HWDEP
2111 /* execute additional init verbs */
2112 static void hda_exec_init_verbs(struct hda_codec
*codec
)
2114 if (codec
->init_verbs
.list
)
2115 snd_hda_sequence_write(codec
, codec
->init_verbs
.list
);
2118 static inline void hda_exec_init_verbs(struct hda_codec
*codec
) {}
2121 #ifdef SND_HDA_NEEDS_RESUME
2123 * call suspend and power-down; used both from PM and power-save
2125 static void hda_call_codec_suspend(struct hda_codec
*codec
)
2127 if (codec
->patch_ops
.suspend
)
2128 codec
->patch_ops
.suspend(codec
, PMSG_SUSPEND
);
2129 hda_set_power_state(codec
,
2130 codec
->afg
? codec
->afg
: codec
->mfg
,
2132 #ifdef CONFIG_SND_HDA_POWER_SAVE
2133 cancel_delayed_work(&codec
->power_work
);
2134 codec
->power_on
= 0;
2135 codec
->power_transition
= 0;
2140 * kick up codec; used both from PM and power-save
2142 static void hda_call_codec_resume(struct hda_codec
*codec
)
2144 hda_set_power_state(codec
,
2145 codec
->afg
? codec
->afg
: codec
->mfg
,
2147 hda_exec_init_verbs(codec
);
2148 if (codec
->patch_ops
.resume
)
2149 codec
->patch_ops
.resume(codec
);
2151 if (codec
->patch_ops
.init
)
2152 codec
->patch_ops
.init(codec
);
2153 snd_hda_codec_resume_amp(codec
);
2154 snd_hda_codec_resume_cache(codec
);
2157 #endif /* SND_HDA_NEEDS_RESUME */
2161 * snd_hda_build_controls - build mixer controls
2164 * Creates mixer controls for each codec included in the bus.
2166 * Returns 0 if successful, otherwise a negative error code.
2168 int /*__devinit*/ snd_hda_build_controls(struct hda_bus
*bus
)
2170 struct hda_codec
*codec
;
2172 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
2173 int err
= snd_hda_codec_build_controls(codec
);
2179 EXPORT_SYMBOL_HDA(snd_hda_build_controls
);
2181 int snd_hda_codec_build_controls(struct hda_codec
*codec
)
2184 /* fake as if already powered-on */
2185 hda_keep_power_on(codec
);
2187 hda_set_power_state(codec
,
2188 codec
->afg
? codec
->afg
: codec
->mfg
,
2190 hda_exec_init_verbs(codec
);
2191 /* continue to initialize... */
2192 if (codec
->patch_ops
.init
)
2193 err
= codec
->patch_ops
.init(codec
);
2194 if (!err
&& codec
->patch_ops
.build_controls
)
2195 err
= codec
->patch_ops
.build_controls(codec
);
2196 snd_hda_power_down(codec
);
2205 struct hda_rate_tbl
{
2207 unsigned int alsa_bits
;
2208 unsigned int hda_fmt
;
2211 static struct hda_rate_tbl rate_bits
[] = {
2212 /* rate in Hz, ALSA rate bitmask, HDA format value */
2214 /* autodetected value used in snd_hda_query_supported_pcm */
2215 { 8000, SNDRV_PCM_RATE_8000
, 0x0500 }, /* 1/6 x 48 */
2216 { 11025, SNDRV_PCM_RATE_11025
, 0x4300 }, /* 1/4 x 44 */
2217 { 16000, SNDRV_PCM_RATE_16000
, 0x0200 }, /* 1/3 x 48 */
2218 { 22050, SNDRV_PCM_RATE_22050
, 0x4100 }, /* 1/2 x 44 */
2219 { 32000, SNDRV_PCM_RATE_32000
, 0x0a00 }, /* 2/3 x 48 */
2220 { 44100, SNDRV_PCM_RATE_44100
, 0x4000 }, /* 44 */
2221 { 48000, SNDRV_PCM_RATE_48000
, 0x0000 }, /* 48 */
2222 { 88200, SNDRV_PCM_RATE_88200
, 0x4800 }, /* 2 x 44 */
2223 { 96000, SNDRV_PCM_RATE_96000
, 0x0800 }, /* 2 x 48 */
2224 { 176400, SNDRV_PCM_RATE_176400
, 0x5800 },/* 4 x 44 */
2225 { 192000, SNDRV_PCM_RATE_192000
, 0x1800 }, /* 4 x 48 */
2226 #define AC_PAR_PCM_RATE_BITS 11
2227 /* up to bits 10, 384kHZ isn't supported properly */
2229 /* not autodetected value */
2230 { 9600, SNDRV_PCM_RATE_KNOT
, 0x0400 }, /* 1/5 x 48 */
2232 { 0 } /* terminator */
2236 * snd_hda_calc_stream_format - calculate format bitset
2237 * @rate: the sample rate
2238 * @channels: the number of channels
2239 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2240 * @maxbps: the max. bps
2242 * Calculate the format bitset from the given rate, channels and th PCM format.
2244 * Return zero if invalid.
2246 unsigned int snd_hda_calc_stream_format(unsigned int rate
,
2247 unsigned int channels
,
2248 unsigned int format
,
2249 unsigned int maxbps
)
2252 unsigned int val
= 0;
2254 for (i
= 0; rate_bits
[i
].hz
; i
++)
2255 if (rate_bits
[i
].hz
== rate
) {
2256 val
= rate_bits
[i
].hda_fmt
;
2259 if (!rate_bits
[i
].hz
) {
2260 snd_printdd("invalid rate %d\n", rate
);
2264 if (channels
== 0 || channels
> 8) {
2265 snd_printdd("invalid channels %d\n", channels
);
2268 val
|= channels
- 1;
2270 switch (snd_pcm_format_width(format
)) {
2271 case 8: val
|= 0x00; break;
2272 case 16: val
|= 0x10; break;
2278 else if (maxbps
>= 24)
2284 snd_printdd("invalid format width %d\n",
2285 snd_pcm_format_width(format
));
2291 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format
);
2294 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2295 * @codec: the HDA codec
2296 * @nid: NID to query
2297 * @ratesp: the pointer to store the detected rate bitflags
2298 * @formatsp: the pointer to store the detected formats
2299 * @bpsp: the pointer to store the detected format widths
2301 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2302 * or @bsps argument is ignored.
2304 * Returns 0 if successful, otherwise a negative error code.
2306 static int snd_hda_query_supported_pcm(struct hda_codec
*codec
, hda_nid_t nid
,
2307 u32
*ratesp
, u64
*formatsp
, unsigned int *bpsp
)
2310 unsigned int val
, streams
;
2313 if (nid
!= codec
->afg
&&
2314 (get_wcaps(codec
, nid
) & AC_WCAP_FORMAT_OVRD
)) {
2315 val
= snd_hda_param_read(codec
, nid
, AC_PAR_PCM
);
2320 val
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_PCM
);
2324 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++) {
2326 rates
|= rate_bits
[i
].alsa_bits
;
2331 if (formatsp
|| bpsp
) {
2336 wcaps
= get_wcaps(codec
, nid
);
2337 streams
= snd_hda_param_read(codec
, nid
, AC_PAR_STREAM
);
2341 streams
= snd_hda_param_read(codec
, codec
->afg
,
2348 if (streams
& AC_SUPFMT_PCM
) {
2349 if (val
& AC_SUPPCM_BITS_8
) {
2350 formats
|= SNDRV_PCM_FMTBIT_U8
;
2353 if (val
& AC_SUPPCM_BITS_16
) {
2354 formats
|= SNDRV_PCM_FMTBIT_S16_LE
;
2357 if (wcaps
& AC_WCAP_DIGITAL
) {
2358 if (val
& AC_SUPPCM_BITS_32
)
2359 formats
|= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
;
2360 if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
))
2361 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
2362 if (val
& AC_SUPPCM_BITS_24
)
2364 else if (val
& AC_SUPPCM_BITS_20
)
2366 } else if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
|
2367 AC_SUPPCM_BITS_32
)) {
2368 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
2369 if (val
& AC_SUPPCM_BITS_32
)
2371 else if (val
& AC_SUPPCM_BITS_24
)
2373 else if (val
& AC_SUPPCM_BITS_20
)
2377 else if (streams
== AC_SUPFMT_FLOAT32
) {
2378 /* should be exclusive */
2379 formats
|= SNDRV_PCM_FMTBIT_FLOAT_LE
;
2381 } else if (streams
== AC_SUPFMT_AC3
) {
2382 /* should be exclusive */
2383 /* temporary hack: we have still no proper support
2384 * for the direct AC3 stream...
2386 formats
|= SNDRV_PCM_FMTBIT_U8
;
2390 *formatsp
= formats
;
2399 * snd_hda_is_supported_format - check whether the given node supports
2402 * Returns 1 if supported, 0 if not.
2404 int snd_hda_is_supported_format(struct hda_codec
*codec
, hda_nid_t nid
,
2405 unsigned int format
)
2408 unsigned int val
= 0, rate
, stream
;
2410 if (nid
!= codec
->afg
&&
2411 (get_wcaps(codec
, nid
) & AC_WCAP_FORMAT_OVRD
)) {
2412 val
= snd_hda_param_read(codec
, nid
, AC_PAR_PCM
);
2417 val
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_PCM
);
2422 rate
= format
& 0xff00;
2423 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++)
2424 if (rate_bits
[i
].hda_fmt
== rate
) {
2429 if (i
>= AC_PAR_PCM_RATE_BITS
)
2432 stream
= snd_hda_param_read(codec
, nid
, AC_PAR_STREAM
);
2435 if (!stream
&& nid
!= codec
->afg
)
2436 stream
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_STREAM
);
2437 if (!stream
|| stream
== -1)
2440 if (stream
& AC_SUPFMT_PCM
) {
2441 switch (format
& 0xf0) {
2443 if (!(val
& AC_SUPPCM_BITS_8
))
2447 if (!(val
& AC_SUPPCM_BITS_16
))
2451 if (!(val
& AC_SUPPCM_BITS_20
))
2455 if (!(val
& AC_SUPPCM_BITS_24
))
2459 if (!(val
& AC_SUPPCM_BITS_32
))
2466 /* FIXME: check for float32 and AC3? */
2471 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format
);
2476 static int hda_pcm_default_open_close(struct hda_pcm_stream
*hinfo
,
2477 struct hda_codec
*codec
,
2478 struct snd_pcm_substream
*substream
)
2483 static int hda_pcm_default_prepare(struct hda_pcm_stream
*hinfo
,
2484 struct hda_codec
*codec
,
2485 unsigned int stream_tag
,
2486 unsigned int format
,
2487 struct snd_pcm_substream
*substream
)
2489 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, stream_tag
, 0, format
);
2493 static int hda_pcm_default_cleanup(struct hda_pcm_stream
*hinfo
,
2494 struct hda_codec
*codec
,
2495 struct snd_pcm_substream
*substream
)
2497 snd_hda_codec_cleanup_stream(codec
, hinfo
->nid
);
2501 static int set_pcm_default_values(struct hda_codec
*codec
,
2502 struct hda_pcm_stream
*info
)
2504 /* query support PCM information from the given NID */
2505 if (info
->nid
&& (!info
->rates
|| !info
->formats
)) {
2506 snd_hda_query_supported_pcm(codec
, info
->nid
,
2507 info
->rates
? NULL
: &info
->rates
,
2508 info
->formats
? NULL
: &info
->formats
,
2509 info
->maxbps
? NULL
: &info
->maxbps
);
2511 if (info
->ops
.open
== NULL
)
2512 info
->ops
.open
= hda_pcm_default_open_close
;
2513 if (info
->ops
.close
== NULL
)
2514 info
->ops
.close
= hda_pcm_default_open_close
;
2515 if (info
->ops
.prepare
== NULL
) {
2516 if (snd_BUG_ON(!info
->nid
))
2518 info
->ops
.prepare
= hda_pcm_default_prepare
;
2520 if (info
->ops
.cleanup
== NULL
) {
2521 if (snd_BUG_ON(!info
->nid
))
2523 info
->ops
.cleanup
= hda_pcm_default_cleanup
;
2529 * get the empty PCM device number to assign
2531 static int get_empty_pcm_device(struct hda_bus
*bus
, int type
)
2533 static const char *dev_name
[HDA_PCM_NTYPES
] = {
2534 "Audio", "SPDIF", "HDMI", "Modem"
2536 /* starting device index for each PCM type */
2537 static int dev_idx
[HDA_PCM_NTYPES
] = {
2538 [HDA_PCM_TYPE_AUDIO
] = 0,
2539 [HDA_PCM_TYPE_SPDIF
] = 1,
2540 [HDA_PCM_TYPE_HDMI
] = 3,
2541 [HDA_PCM_TYPE_MODEM
] = 6
2543 /* normal audio device indices; not linear to keep compatibility */
2544 static int audio_idx
[4] = { 0, 2, 4, 5 };
2548 case HDA_PCM_TYPE_AUDIO
:
2549 for (i
= 0; i
< ARRAY_SIZE(audio_idx
); i
++) {
2551 if (!test_bit(dev
, bus
->pcm_dev_bits
))
2554 if (i
>= ARRAY_SIZE(audio_idx
)) {
2555 snd_printk(KERN_WARNING
"Too many audio devices\n");
2559 case HDA_PCM_TYPE_SPDIF
:
2560 case HDA_PCM_TYPE_HDMI
:
2561 case HDA_PCM_TYPE_MODEM
:
2562 dev
= dev_idx
[type
];
2563 if (test_bit(dev
, bus
->pcm_dev_bits
)) {
2564 snd_printk(KERN_WARNING
"%s already defined\n",
2570 snd_printk(KERN_WARNING
"Invalid PCM type %d\n", type
);
2573 set_bit(dev
, bus
->pcm_dev_bits
);
2578 * attach a new PCM stream
2580 static int snd_hda_attach_pcm(struct hda_codec
*codec
, struct hda_pcm
*pcm
)
2582 struct hda_bus
*bus
= codec
->bus
;
2583 struct hda_pcm_stream
*info
;
2586 if (snd_BUG_ON(!pcm
->name
))
2588 for (stream
= 0; stream
< 2; stream
++) {
2589 info
= &pcm
->stream
[stream
];
2590 if (info
->substreams
) {
2591 err
= set_pcm_default_values(codec
, info
);
2596 return bus
->ops
.attach_pcm(bus
, codec
, pcm
);
2599 /* assign all PCMs of the given codec */
2600 int snd_hda_codec_build_pcms(struct hda_codec
*codec
)
2605 if (!codec
->num_pcms
) {
2606 if (!codec
->patch_ops
.build_pcms
)
2608 err
= codec
->patch_ops
.build_pcms(codec
);
2612 for (pcm
= 0; pcm
< codec
->num_pcms
; pcm
++) {
2613 struct hda_pcm
*cpcm
= &codec
->pcm_info
[pcm
];
2616 if (!cpcm
->stream
[0].substreams
&& !cpcm
->stream
[1].substreams
)
2617 return 0; /* no substreams assigned */
2620 dev
= get_empty_pcm_device(codec
->bus
, cpcm
->pcm_type
);
2624 err
= snd_hda_attach_pcm(codec
, cpcm
);
2633 * snd_hda_build_pcms - build PCM information
2636 * Create PCM information for each codec included in the bus.
2638 * The build_pcms codec patch is requested to set up codec->num_pcms and
2639 * codec->pcm_info properly. The array is referred by the top-level driver
2640 * to create its PCM instances.
2641 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2644 * At least, substreams, channels_min and channels_max must be filled for
2645 * each stream. substreams = 0 indicates that the stream doesn't exist.
2646 * When rates and/or formats are zero, the supported values are queried
2647 * from the given nid. The nid is used also by the default ops.prepare
2648 * and ops.cleanup callbacks.
2650 * The driver needs to call ops.open in its open callback. Similarly,
2651 * ops.close is supposed to be called in the close callback.
2652 * ops.prepare should be called in the prepare or hw_params callback
2653 * with the proper parameters for set up.
2654 * ops.cleanup should be called in hw_free for clean up of streams.
2656 * This function returns 0 if successfull, or a negative error code.
2658 int __devinit
snd_hda_build_pcms(struct hda_bus
*bus
)
2660 struct hda_codec
*codec
;
2662 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
2663 int err
= snd_hda_codec_build_pcms(codec
);
2669 EXPORT_SYMBOL_HDA(snd_hda_build_pcms
);
2672 * snd_hda_check_board_config - compare the current codec with the config table
2673 * @codec: the HDA codec
2674 * @num_configs: number of config enums
2675 * @models: array of model name strings
2676 * @tbl: configuration table, terminated by null entries
2678 * Compares the modelname or PCI subsystem id of the current codec with the
2679 * given configuration table. If a matching entry is found, returns its
2680 * config value (supposed to be 0 or positive).
2682 * If no entries are matching, the function returns a negative value.
2684 int snd_hda_check_board_config(struct hda_codec
*codec
,
2685 int num_configs
, const char **models
,
2686 const struct snd_pci_quirk
*tbl
)
2688 if (codec
->modelname
&& models
) {
2690 for (i
= 0; i
< num_configs
; i
++) {
2692 !strcmp(codec
->modelname
, models
[i
])) {
2693 snd_printd(KERN_INFO
"hda_codec: model '%s' is "
2694 "selected\n", models
[i
]);
2700 if (!codec
->bus
->pci
|| !tbl
)
2703 tbl
= snd_pci_quirk_lookup(codec
->bus
->pci
, tbl
);
2706 if (tbl
->value
>= 0 && tbl
->value
< num_configs
) {
2707 #ifdef CONFIG_SND_DEBUG_VERBOSE
2709 const char *model
= NULL
;
2711 model
= models
[tbl
->value
];
2713 sprintf(tmp
, "#%d", tbl
->value
);
2716 snd_printdd(KERN_INFO
"hda_codec: model '%s' is selected "
2717 "for config %x:%x (%s)\n",
2718 model
, tbl
->subvendor
, tbl
->subdevice
,
2719 (tbl
->name
? tbl
->name
: "Unknown device"));
2725 EXPORT_SYMBOL_HDA(snd_hda_check_board_config
);
2728 * snd_hda_check_board_codec_sid_config - compare the current codec
2729 subsystem ID with the
2732 This is important for Gateway notebooks with SB450 HDA Audio
2733 where the vendor ID of the PCI device is:
2734 ATI Technologies Inc SB450 HDA Audio [1002:437b]
2735 and the vendor/subvendor are found only at the codec.
2737 * @codec: the HDA codec
2738 * @num_configs: number of config enums
2739 * @models: array of model name strings
2740 * @tbl: configuration table, terminated by null entries
2742 * Compares the modelname or PCI subsystem id of the current codec with the
2743 * given configuration table. If a matching entry is found, returns its
2744 * config value (supposed to be 0 or positive).
2746 * If no entries are matching, the function returns a negative value.
2748 int snd_hda_check_board_codec_sid_config(struct hda_codec
*codec
,
2749 int num_configs
, const char **models
,
2750 const struct snd_pci_quirk
*tbl
)
2752 const struct snd_pci_quirk
*q
;
2754 /* Search for codec ID */
2755 for (q
= tbl
; q
->subvendor
; q
++) {
2756 unsigned long vendorid
= (q
->subdevice
) | (q
->subvendor
<< 16);
2758 if (vendorid
== codec
->subsystem_id
)
2767 if (tbl
->value
>= 0 && tbl
->value
< num_configs
) {
2768 #ifdef CONFIG_SND_DEBUG_DETECT
2770 const char *model
= NULL
;
2772 model
= models
[tbl
->value
];
2774 sprintf(tmp
, "#%d", tbl
->value
);
2777 snd_printdd(KERN_INFO
"hda_codec: model '%s' is selected "
2778 "for config %x:%x (%s)\n",
2779 model
, tbl
->subvendor
, tbl
->subdevice
,
2780 (tbl
->name
? tbl
->name
: "Unknown device"));
2786 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config
);
2789 * snd_hda_add_new_ctls - create controls from the array
2790 * @codec: the HDA codec
2791 * @knew: the array of struct snd_kcontrol_new
2793 * This helper function creates and add new controls in the given array.
2794 * The array must be terminated with an empty entry as terminator.
2796 * Returns 0 if successful, or a negative error code.
2798 int snd_hda_add_new_ctls(struct hda_codec
*codec
, struct snd_kcontrol_new
*knew
)
2802 for (; knew
->name
; knew
++) {
2803 struct snd_kcontrol
*kctl
;
2804 kctl
= snd_ctl_new1(knew
, codec
);
2807 err
= snd_hda_ctl_add(codec
, kctl
);
2811 kctl
= snd_ctl_new1(knew
, codec
);
2814 kctl
->id
.device
= codec
->addr
;
2815 err
= snd_hda_ctl_add(codec
, kctl
);
2822 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls
);
2824 #ifdef CONFIG_SND_HDA_POWER_SAVE
2825 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
2826 unsigned int power_state
);
2828 static void hda_power_work(struct work_struct
*work
)
2830 struct hda_codec
*codec
=
2831 container_of(work
, struct hda_codec
, power_work
.work
);
2832 struct hda_bus
*bus
= codec
->bus
;
2834 if (!codec
->power_on
|| codec
->power_count
) {
2835 codec
->power_transition
= 0;
2839 hda_call_codec_suspend(codec
);
2840 if (bus
->ops
.pm_notify
)
2841 bus
->ops
.pm_notify(bus
);
2844 static void hda_keep_power_on(struct hda_codec
*codec
)
2846 codec
->power_count
++;
2847 codec
->power_on
= 1;
2850 void snd_hda_power_up(struct hda_codec
*codec
)
2852 struct hda_bus
*bus
= codec
->bus
;
2854 codec
->power_count
++;
2855 if (codec
->power_on
|| codec
->power_transition
)
2858 codec
->power_on
= 1;
2859 if (bus
->ops
.pm_notify
)
2860 bus
->ops
.pm_notify(bus
);
2861 hda_call_codec_resume(codec
);
2862 cancel_delayed_work(&codec
->power_work
);
2863 codec
->power_transition
= 0;
2865 EXPORT_SYMBOL_HDA(snd_hda_power_up
);
2867 #define power_save(codec) \
2868 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2870 #define power_save(codec) \
2871 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2873 void snd_hda_power_down(struct hda_codec
*codec
)
2875 --codec
->power_count
;
2876 if (!codec
->power_on
|| codec
->power_count
|| codec
->power_transition
)
2878 if (power_save(codec
)) {
2879 codec
->power_transition
= 1; /* avoid reentrance */
2880 queue_delayed_work(codec
->bus
->workq
, &codec
->power_work
,
2881 msecs_to_jiffies(power_save(codec
) * 1000));
2884 EXPORT_SYMBOL_HDA(snd_hda_power_down
);
2886 int snd_hda_check_amp_list_power(struct hda_codec
*codec
,
2887 struct hda_loopback_check
*check
,
2890 struct hda_amp_list
*p
;
2893 if (!check
->amplist
)
2895 for (p
= check
->amplist
; p
->nid
; p
++) {
2900 return 0; /* nothing changed */
2902 for (p
= check
->amplist
; p
->nid
; p
++) {
2903 for (ch
= 0; ch
< 2; ch
++) {
2904 v
= snd_hda_codec_amp_read(codec
, p
->nid
, ch
, p
->dir
,
2906 if (!(v
& HDA_AMP_MUTE
) && v
> 0) {
2907 if (!check
->power_on
) {
2908 check
->power_on
= 1;
2909 snd_hda_power_up(codec
);
2915 if (check
->power_on
) {
2916 check
->power_on
= 0;
2917 snd_hda_power_down(codec
);
2921 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power
);
2925 * Channel mode helper
2927 int snd_hda_ch_mode_info(struct hda_codec
*codec
,
2928 struct snd_ctl_elem_info
*uinfo
,
2929 const struct hda_channel_mode
*chmode
,
2932 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
2934 uinfo
->value
.enumerated
.items
= num_chmodes
;
2935 if (uinfo
->value
.enumerated
.item
>= num_chmodes
)
2936 uinfo
->value
.enumerated
.item
= num_chmodes
- 1;
2937 sprintf(uinfo
->value
.enumerated
.name
, "%dch",
2938 chmode
[uinfo
->value
.enumerated
.item
].channels
);
2941 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info
);
2943 int snd_hda_ch_mode_get(struct hda_codec
*codec
,
2944 struct snd_ctl_elem_value
*ucontrol
,
2945 const struct hda_channel_mode
*chmode
,
2951 for (i
= 0; i
< num_chmodes
; i
++) {
2952 if (max_channels
== chmode
[i
].channels
) {
2953 ucontrol
->value
.enumerated
.item
[0] = i
;
2959 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get
);
2961 int snd_hda_ch_mode_put(struct hda_codec
*codec
,
2962 struct snd_ctl_elem_value
*ucontrol
,
2963 const struct hda_channel_mode
*chmode
,
2969 mode
= ucontrol
->value
.enumerated
.item
[0];
2970 if (mode
>= num_chmodes
)
2972 if (*max_channelsp
== chmode
[mode
].channels
)
2974 /* change the current channel setting */
2975 *max_channelsp
= chmode
[mode
].channels
;
2976 if (chmode
[mode
].sequence
)
2977 snd_hda_sequence_write_cache(codec
, chmode
[mode
].sequence
);
2980 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put
);
2985 int snd_hda_input_mux_info(const struct hda_input_mux
*imux
,
2986 struct snd_ctl_elem_info
*uinfo
)
2990 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
2992 uinfo
->value
.enumerated
.items
= imux
->num_items
;
2993 if (!imux
->num_items
)
2995 index
= uinfo
->value
.enumerated
.item
;
2996 if (index
>= imux
->num_items
)
2997 index
= imux
->num_items
- 1;
2998 strcpy(uinfo
->value
.enumerated
.name
, imux
->items
[index
].label
);
3001 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info
);
3003 int snd_hda_input_mux_put(struct hda_codec
*codec
,
3004 const struct hda_input_mux
*imux
,
3005 struct snd_ctl_elem_value
*ucontrol
,
3007 unsigned int *cur_val
)
3011 if (!imux
->num_items
)
3013 idx
= ucontrol
->value
.enumerated
.item
[0];
3014 if (idx
>= imux
->num_items
)
3015 idx
= imux
->num_items
- 1;
3016 if (*cur_val
== idx
)
3018 snd_hda_codec_write_cache(codec
, nid
, 0, AC_VERB_SET_CONNECT_SEL
,
3019 imux
->items
[idx
].index
);
3023 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put
);
3027 * Multi-channel / digital-out PCM helper functions
3030 /* setup SPDIF output stream */
3031 static void setup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
,
3032 unsigned int stream_tag
, unsigned int format
)
3034 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3035 if (codec
->spdif_status_reset
&& (codec
->spdif_ctls
& AC_DIG1_ENABLE
))
3036 set_dig_out_convert(codec
, nid
,
3037 codec
->spdif_ctls
& ~AC_DIG1_ENABLE
& 0xff,
3039 snd_hda_codec_setup_stream(codec
, nid
, stream_tag
, 0, format
);
3040 if (codec
->slave_dig_outs
) {
3042 for (d
= codec
->slave_dig_outs
; *d
; d
++)
3043 snd_hda_codec_setup_stream(codec
, *d
, stream_tag
, 0,
3046 /* turn on again (if needed) */
3047 if (codec
->spdif_status_reset
&& (codec
->spdif_ctls
& AC_DIG1_ENABLE
))
3048 set_dig_out_convert(codec
, nid
,
3049 codec
->spdif_ctls
& 0xff, -1);
3052 static void cleanup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
)
3054 snd_hda_codec_cleanup_stream(codec
, nid
);
3055 if (codec
->slave_dig_outs
) {
3057 for (d
= codec
->slave_dig_outs
; *d
; d
++)
3058 snd_hda_codec_cleanup_stream(codec
, *d
);
3063 * open the digital out in the exclusive mode
3065 int snd_hda_multi_out_dig_open(struct hda_codec
*codec
,
3066 struct hda_multi_out
*mout
)
3068 mutex_lock(&codec
->spdif_mutex
);
3069 if (mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
)
3070 /* already opened as analog dup; reset it once */
3071 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
3072 mout
->dig_out_used
= HDA_DIG_EXCLUSIVE
;
3073 mutex_unlock(&codec
->spdif_mutex
);
3076 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open
);
3078 int snd_hda_multi_out_dig_prepare(struct hda_codec
*codec
,
3079 struct hda_multi_out
*mout
,
3080 unsigned int stream_tag
,
3081 unsigned int format
,
3082 struct snd_pcm_substream
*substream
)
3084 mutex_lock(&codec
->spdif_mutex
);
3085 setup_dig_out_stream(codec
, mout
->dig_out_nid
, stream_tag
, format
);
3086 mutex_unlock(&codec
->spdif_mutex
);
3089 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare
);
3091 int snd_hda_multi_out_dig_cleanup(struct hda_codec
*codec
,
3092 struct hda_multi_out
*mout
)
3094 mutex_lock(&codec
->spdif_mutex
);
3095 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
3096 mutex_unlock(&codec
->spdif_mutex
);
3099 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup
);
3102 * release the digital out
3104 int snd_hda_multi_out_dig_close(struct hda_codec
*codec
,
3105 struct hda_multi_out
*mout
)
3107 mutex_lock(&codec
->spdif_mutex
);
3108 mout
->dig_out_used
= 0;
3109 mutex_unlock(&codec
->spdif_mutex
);
3112 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close
);
3115 * set up more restrictions for analog out
3117 int snd_hda_multi_out_analog_open(struct hda_codec
*codec
,
3118 struct hda_multi_out
*mout
,
3119 struct snd_pcm_substream
*substream
,
3120 struct hda_pcm_stream
*hinfo
)
3122 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
3123 runtime
->hw
.channels_max
= mout
->max_channels
;
3124 if (mout
->dig_out_nid
) {
3125 if (!mout
->analog_rates
) {
3126 mout
->analog_rates
= hinfo
->rates
;
3127 mout
->analog_formats
= hinfo
->formats
;
3128 mout
->analog_maxbps
= hinfo
->maxbps
;
3130 runtime
->hw
.rates
= mout
->analog_rates
;
3131 runtime
->hw
.formats
= mout
->analog_formats
;
3132 hinfo
->maxbps
= mout
->analog_maxbps
;
3134 if (!mout
->spdif_rates
) {
3135 snd_hda_query_supported_pcm(codec
, mout
->dig_out_nid
,
3137 &mout
->spdif_formats
,
3138 &mout
->spdif_maxbps
);
3140 mutex_lock(&codec
->spdif_mutex
);
3141 if (mout
->share_spdif
) {
3142 runtime
->hw
.rates
&= mout
->spdif_rates
;
3143 runtime
->hw
.formats
&= mout
->spdif_formats
;
3144 if (mout
->spdif_maxbps
< hinfo
->maxbps
)
3145 hinfo
->maxbps
= mout
->spdif_maxbps
;
3147 mutex_unlock(&codec
->spdif_mutex
);
3149 return snd_pcm_hw_constraint_step(substream
->runtime
, 0,
3150 SNDRV_PCM_HW_PARAM_CHANNELS
, 2);
3152 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open
);
3155 * set up the i/o for analog out
3156 * when the digital out is available, copy the front out to digital out, too.
3158 int snd_hda_multi_out_analog_prepare(struct hda_codec
*codec
,
3159 struct hda_multi_out
*mout
,
3160 unsigned int stream_tag
,
3161 unsigned int format
,
3162 struct snd_pcm_substream
*substream
)
3164 hda_nid_t
*nids
= mout
->dac_nids
;
3165 int chs
= substream
->runtime
->channels
;
3168 mutex_lock(&codec
->spdif_mutex
);
3169 if (mout
->dig_out_nid
&& mout
->share_spdif
&&
3170 mout
->dig_out_used
!= HDA_DIG_EXCLUSIVE
) {
3172 snd_hda_is_supported_format(codec
, mout
->dig_out_nid
,
3174 !(codec
->spdif_status
& IEC958_AES0_NONAUDIO
)) {
3175 mout
->dig_out_used
= HDA_DIG_ANALOG_DUP
;
3176 setup_dig_out_stream(codec
, mout
->dig_out_nid
,
3177 stream_tag
, format
);
3179 mout
->dig_out_used
= 0;
3180 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
3183 mutex_unlock(&codec
->spdif_mutex
);
3186 snd_hda_codec_setup_stream(codec
, nids
[HDA_FRONT
], stream_tag
,
3188 if (!mout
->no_share_stream
&&
3189 mout
->hp_nid
&& mout
->hp_nid
!= nids
[HDA_FRONT
])
3190 /* headphone out will just decode front left/right (stereo) */
3191 snd_hda_codec_setup_stream(codec
, mout
->hp_nid
, stream_tag
,
3193 /* extra outputs copied from front */
3194 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
3195 if (!mout
->no_share_stream
&& mout
->extra_out_nid
[i
])
3196 snd_hda_codec_setup_stream(codec
,
3197 mout
->extra_out_nid
[i
],
3198 stream_tag
, 0, format
);
3201 for (i
= 1; i
< mout
->num_dacs
; i
++) {
3202 if (chs
>= (i
+ 1) * 2) /* independent out */
3203 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
3205 else if (!mout
->no_share_stream
) /* copy front */
3206 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
3211 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare
);
3214 * clean up the setting for analog out
3216 int snd_hda_multi_out_analog_cleanup(struct hda_codec
*codec
,
3217 struct hda_multi_out
*mout
)
3219 hda_nid_t
*nids
= mout
->dac_nids
;
3222 for (i
= 0; i
< mout
->num_dacs
; i
++)
3223 snd_hda_codec_cleanup_stream(codec
, nids
[i
]);
3225 snd_hda_codec_cleanup_stream(codec
, mout
->hp_nid
);
3226 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
3227 if (mout
->extra_out_nid
[i
])
3228 snd_hda_codec_cleanup_stream(codec
,
3229 mout
->extra_out_nid
[i
]);
3230 mutex_lock(&codec
->spdif_mutex
);
3231 if (mout
->dig_out_nid
&& mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
) {
3232 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
3233 mout
->dig_out_used
= 0;
3235 mutex_unlock(&codec
->spdif_mutex
);
3238 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup
);
3241 * Helper for automatic pin configuration
3244 static int is_in_nid_list(hda_nid_t nid
, hda_nid_t
*list
)
3246 for (; *list
; list
++)
3254 * Sort an associated group of pins according to their sequence numbers.
3256 static void sort_pins_by_sequence(hda_nid_t
* pins
, short * sequences
,
3263 for (i
= 0; i
< num_pins
; i
++) {
3264 for (j
= i
+ 1; j
< num_pins
; j
++) {
3265 if (sequences
[i
] > sequences
[j
]) {
3267 sequences
[i
] = sequences
[j
];
3279 * Parse all pin widgets and store the useful pin nids to cfg
3281 * The number of line-outs or any primary output is stored in line_outs,
3282 * and the corresponding output pins are assigned to line_out_pins[],
3283 * in the order of front, rear, CLFE, side, ...
3285 * If more extra outputs (speaker and headphone) are found, the pins are
3286 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3287 * is detected, one of speaker of HP pins is assigned as the primary
3288 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3289 * if any analog output exists.
3291 * The analog input pins are assigned to input_pins array.
3292 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3295 int snd_hda_parse_pin_def_config(struct hda_codec
*codec
,
3296 struct auto_pin_cfg
*cfg
,
3297 hda_nid_t
*ignore_nids
)
3299 hda_nid_t nid
, end_nid
;
3300 short seq
, assoc_line_out
, assoc_speaker
;
3301 short sequences_line_out
[ARRAY_SIZE(cfg
->line_out_pins
)];
3302 short sequences_speaker
[ARRAY_SIZE(cfg
->speaker_pins
)];
3303 short sequences_hp
[ARRAY_SIZE(cfg
->hp_pins
)];
3305 memset(cfg
, 0, sizeof(*cfg
));
3307 memset(sequences_line_out
, 0, sizeof(sequences_line_out
));
3308 memset(sequences_speaker
, 0, sizeof(sequences_speaker
));
3309 memset(sequences_hp
, 0, sizeof(sequences_hp
));
3310 assoc_line_out
= assoc_speaker
= 0;
3312 end_nid
= codec
->start_nid
+ codec
->num_nodes
;
3313 for (nid
= codec
->start_nid
; nid
< end_nid
; nid
++) {
3314 unsigned int wid_caps
= get_wcaps(codec
, nid
);
3315 unsigned int wid_type
=
3316 (wid_caps
& AC_WCAP_TYPE
) >> AC_WCAP_TYPE_SHIFT
;
3317 unsigned int def_conf
;
3320 /* read all default configuration for pin complex */
3321 if (wid_type
!= AC_WID_PIN
)
3323 /* ignore the given nids (e.g. pc-beep returns error) */
3324 if (ignore_nids
&& is_in_nid_list(nid
, ignore_nids
))
3327 def_conf
= snd_hda_codec_read(codec
, nid
, 0,
3328 AC_VERB_GET_CONFIG_DEFAULT
, 0);
3329 if (get_defcfg_connect(def_conf
) == AC_JACK_PORT_NONE
)
3331 loc
= get_defcfg_location(def_conf
);
3332 switch (get_defcfg_device(def_conf
)) {
3333 case AC_JACK_LINE_OUT
:
3334 seq
= get_defcfg_sequence(def_conf
);
3335 assoc
= get_defcfg_association(def_conf
);
3337 if (!(wid_caps
& AC_WCAP_STEREO
))
3338 if (!cfg
->mono_out_pin
)
3339 cfg
->mono_out_pin
= nid
;
3342 if (!assoc_line_out
)
3343 assoc_line_out
= assoc
;
3344 else if (assoc_line_out
!= assoc
)
3346 if (cfg
->line_outs
>= ARRAY_SIZE(cfg
->line_out_pins
))
3348 cfg
->line_out_pins
[cfg
->line_outs
] = nid
;
3349 sequences_line_out
[cfg
->line_outs
] = seq
;
3352 case AC_JACK_SPEAKER
:
3353 seq
= get_defcfg_sequence(def_conf
);
3354 assoc
= get_defcfg_association(def_conf
);
3357 if (! assoc_speaker
)
3358 assoc_speaker
= assoc
;
3359 else if (assoc_speaker
!= assoc
)
3361 if (cfg
->speaker_outs
>= ARRAY_SIZE(cfg
->speaker_pins
))
3363 cfg
->speaker_pins
[cfg
->speaker_outs
] = nid
;
3364 sequences_speaker
[cfg
->speaker_outs
] = seq
;
3365 cfg
->speaker_outs
++;
3367 case AC_JACK_HP_OUT
:
3368 seq
= get_defcfg_sequence(def_conf
);
3369 assoc
= get_defcfg_association(def_conf
);
3370 if (cfg
->hp_outs
>= ARRAY_SIZE(cfg
->hp_pins
))
3372 cfg
->hp_pins
[cfg
->hp_outs
] = nid
;
3373 sequences_hp
[cfg
->hp_outs
] = (assoc
<< 4) | seq
;
3376 case AC_JACK_MIC_IN
: {
3378 if (loc
== AC_JACK_LOC_FRONT
) {
3379 preferred
= AUTO_PIN_FRONT_MIC
;
3382 preferred
= AUTO_PIN_MIC
;
3383 alt
= AUTO_PIN_FRONT_MIC
;
3385 if (!cfg
->input_pins
[preferred
])
3386 cfg
->input_pins
[preferred
] = nid
;
3387 else if (!cfg
->input_pins
[alt
])
3388 cfg
->input_pins
[alt
] = nid
;
3391 case AC_JACK_LINE_IN
:
3392 if (loc
== AC_JACK_LOC_FRONT
)
3393 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
] = nid
;
3395 cfg
->input_pins
[AUTO_PIN_LINE
] = nid
;
3398 cfg
->input_pins
[AUTO_PIN_CD
] = nid
;
3401 cfg
->input_pins
[AUTO_PIN_AUX
] = nid
;
3403 case AC_JACK_SPDIF_OUT
:
3404 cfg
->dig_out_pin
= nid
;
3406 case AC_JACK_SPDIF_IN
:
3407 cfg
->dig_in_pin
= nid
;
3413 * If no line-out is defined but multiple HPs are found,
3414 * some of them might be the real line-outs.
3416 if (!cfg
->line_outs
&& cfg
->hp_outs
> 1) {
3418 while (i
< cfg
->hp_outs
) {
3419 /* The real HPs should have the sequence 0x0f */
3420 if ((sequences_hp
[i
] & 0x0f) == 0x0f) {
3424 /* Move it to the line-out table */
3425 cfg
->line_out_pins
[cfg
->line_outs
] = cfg
->hp_pins
[i
];
3426 sequences_line_out
[cfg
->line_outs
] = sequences_hp
[i
];
3429 memmove(cfg
->hp_pins
+ i
, cfg
->hp_pins
+ i
+ 1,
3430 sizeof(cfg
->hp_pins
[0]) * (cfg
->hp_outs
- i
));
3431 memmove(sequences_hp
+ i
- 1, sequences_hp
+ i
,
3432 sizeof(sequences_hp
[0]) * (cfg
->hp_outs
- i
));
3436 /* sort by sequence */
3437 sort_pins_by_sequence(cfg
->line_out_pins
, sequences_line_out
,
3439 sort_pins_by_sequence(cfg
->speaker_pins
, sequences_speaker
,
3441 sort_pins_by_sequence(cfg
->hp_pins
, sequences_hp
,
3444 /* if we have only one mic, make it AUTO_PIN_MIC */
3445 if (!cfg
->input_pins
[AUTO_PIN_MIC
] &&
3446 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
]) {
3447 cfg
->input_pins
[AUTO_PIN_MIC
] =
3448 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
];
3449 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
] = 0;
3451 /* ditto for line-in */
3452 if (!cfg
->input_pins
[AUTO_PIN_LINE
] &&
3453 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
]) {
3454 cfg
->input_pins
[AUTO_PIN_LINE
] =
3455 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
];
3456 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
] = 0;
3460 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3461 * as a primary output
3463 if (!cfg
->line_outs
) {
3464 if (cfg
->speaker_outs
) {
3465 cfg
->line_outs
= cfg
->speaker_outs
;
3466 memcpy(cfg
->line_out_pins
, cfg
->speaker_pins
,
3467 sizeof(cfg
->speaker_pins
));
3468 cfg
->speaker_outs
= 0;
3469 memset(cfg
->speaker_pins
, 0, sizeof(cfg
->speaker_pins
));
3470 cfg
->line_out_type
= AUTO_PIN_SPEAKER_OUT
;
3471 } else if (cfg
->hp_outs
) {
3472 cfg
->line_outs
= cfg
->hp_outs
;
3473 memcpy(cfg
->line_out_pins
, cfg
->hp_pins
,
3474 sizeof(cfg
->hp_pins
));
3476 memset(cfg
->hp_pins
, 0, sizeof(cfg
->hp_pins
));
3477 cfg
->line_out_type
= AUTO_PIN_HP_OUT
;
3481 /* Reorder the surround channels
3482 * ALSA sequence is front/surr/clfe/side
3484 * 4-ch: front/surr => OK as it is
3485 * 6-ch: front/clfe/surr
3486 * 8-ch: front/clfe/rear/side|fc
3488 switch (cfg
->line_outs
) {
3491 nid
= cfg
->line_out_pins
[1];
3492 cfg
->line_out_pins
[1] = cfg
->line_out_pins
[2];
3493 cfg
->line_out_pins
[2] = nid
;
3498 * debug prints of the parsed results
3500 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3501 cfg
->line_outs
, cfg
->line_out_pins
[0], cfg
->line_out_pins
[1],
3502 cfg
->line_out_pins
[2], cfg
->line_out_pins
[3],
3503 cfg
->line_out_pins
[4]);
3504 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3505 cfg
->speaker_outs
, cfg
->speaker_pins
[0],
3506 cfg
->speaker_pins
[1], cfg
->speaker_pins
[2],
3507 cfg
->speaker_pins
[3], cfg
->speaker_pins
[4]);
3508 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3509 cfg
->hp_outs
, cfg
->hp_pins
[0],
3510 cfg
->hp_pins
[1], cfg
->hp_pins
[2],
3511 cfg
->hp_pins
[3], cfg
->hp_pins
[4]);
3512 snd_printd(" mono: mono_out=0x%x\n", cfg
->mono_out_pin
);
3513 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3514 " cd=0x%x, aux=0x%x\n",
3515 cfg
->input_pins
[AUTO_PIN_MIC
],
3516 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
],
3517 cfg
->input_pins
[AUTO_PIN_LINE
],
3518 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
],
3519 cfg
->input_pins
[AUTO_PIN_CD
],
3520 cfg
->input_pins
[AUTO_PIN_AUX
]);
3524 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config
);
3526 /* labels for input pins */
3527 const char *auto_pin_cfg_labels
[AUTO_PIN_LAST
] = {
3528 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3530 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels
);
3539 * snd_hda_suspend - suspend the codecs
3541 * @state: suspsend state
3543 * Returns 0 if successful.
3545 int snd_hda_suspend(struct hda_bus
*bus
, pm_message_t state
)
3547 struct hda_codec
*codec
;
3549 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3550 #ifdef CONFIG_SND_HDA_POWER_SAVE
3551 if (!codec
->power_on
)
3554 hda_call_codec_suspend(codec
);
3558 EXPORT_SYMBOL_HDA(snd_hda_suspend
);
3561 * snd_hda_resume - resume the codecs
3564 * Returns 0 if successful.
3566 * This fucntion is defined only when POWER_SAVE isn't set.
3567 * In the power-save mode, the codec is resumed dynamically.
3569 int snd_hda_resume(struct hda_bus
*bus
)
3571 struct hda_codec
*codec
;
3573 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3574 if (snd_hda_codec_needs_resume(codec
))
3575 hda_call_codec_resume(codec
);
3579 EXPORT_SYMBOL_HDA(snd_hda_resume
);
3580 #endif /* CONFIG_PM */
3586 /* get a new element from the given array
3587 * if it exceeds the pre-allocated array size, re-allocate the array
3589 void *snd_array_new(struct snd_array
*array
)
3591 if (array
->used
>= array
->alloced
) {
3592 int num
= array
->alloced
+ array
->alloc_align
;
3594 if (snd_BUG_ON(num
>= 4096))
3596 nlist
= kcalloc(num
+ 1, array
->elem_size
, GFP_KERNEL
);
3600 memcpy(nlist
, array
->list
,
3601 array
->elem_size
* array
->alloced
);
3604 array
->list
= nlist
;
3605 array
->alloced
= num
;
3607 return snd_array_elem(array
, array
->used
++);
3609 EXPORT_SYMBOL_HDA(snd_array_new
);
3611 /* free the given array elements */
3612 void snd_array_free(struct snd_array
*array
)
3619 EXPORT_SYMBOL_HDA(snd_array_free
);
3622 * used by hda_proc.c and hda_eld.c
3624 void snd_print_pcm_rates(int pcm
, char *buf
, int buflen
)
3626 static unsigned int rates
[] = {
3627 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3628 96000, 176400, 192000, 384000
3632 for (i
= 0, j
= 0; i
< ARRAY_SIZE(rates
); i
++)
3634 j
+= snprintf(buf
+ j
, buflen
- j
, " %d", rates
[i
]);
3636 buf
[j
] = '\0'; /* necessary when j == 0 */
3638 EXPORT_SYMBOL_HDA(snd_print_pcm_rates
);
3640 void snd_print_pcm_bits(int pcm
, char *buf
, int buflen
)
3642 static unsigned int bits
[] = { 8, 16, 20, 24, 32 };
3645 for (i
= 0, j
= 0; i
< ARRAY_SIZE(bits
); i
++)
3646 if (pcm
& (AC_SUPPCM_BITS_8
<< i
))
3647 j
+= snprintf(buf
+ j
, buflen
- j
, " %d", bits
[i
]);
3649 buf
[j
] = '\0'; /* necessary when j == 0 */
3651 EXPORT_SYMBOL_HDA(snd_print_pcm_bits
);
3653 MODULE_DESCRIPTION("HDA codec core");
3654 MODULE_LICENSE("GPL");