2 * Universal Interface for Intel High Definition Audio Codec
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/pci.h>
26 #include <linux/mutex.h>
27 #include <sound/core.h>
28 #include "hda_codec.h"
29 #include <sound/asoundef.h>
30 #include <sound/tlv.h>
31 #include <sound/initval.h>
32 #include "hda_local.h"
33 #include <sound/hda_hwdep.h>
36 * vendor / preset table
39 struct hda_vendor_id
{
44 /* codec vendor labels */
45 static struct hda_vendor_id hda_vendor_ids
[] = {
47 { 0x1013, "Cirrus Logic" },
48 { 0x1057, "Motorola" },
49 { 0x1095, "Silicon Image" },
51 { 0x10ec, "Realtek" },
52 { 0x1102, "Creative" },
56 { 0x11d4, "Analog Devices" },
57 { 0x13f6, "C-Media" },
58 { 0x14f1, "Conexant" },
59 { 0x17e8, "Chrontel" },
61 { 0x1aec, "Wolfson Microelectronics" },
62 { 0x434d, "C-Media" },
64 { 0x8384, "SigmaTel" },
68 static DEFINE_MUTEX(preset_mutex
);
69 static LIST_HEAD(hda_preset_tables
);
71 int snd_hda_add_codec_preset(struct hda_codec_preset_list
*preset
)
73 mutex_lock(&preset_mutex
);
74 list_add_tail(&preset
->list
, &hda_preset_tables
);
75 mutex_unlock(&preset_mutex
);
78 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset
);
80 int snd_hda_delete_codec_preset(struct hda_codec_preset_list
*preset
)
82 mutex_lock(&preset_mutex
);
83 list_del(&preset
->list
);
84 mutex_unlock(&preset_mutex
);
87 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset
);
89 #ifdef CONFIG_SND_HDA_POWER_SAVE
90 static void hda_power_work(struct work_struct
*work
);
91 static void hda_keep_power_on(struct hda_codec
*codec
);
93 static inline void hda_keep_power_on(struct hda_codec
*codec
) {}
96 const char *snd_hda_get_jack_location(u32 cfg
)
98 static char *bases
[7] = {
99 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
101 static unsigned char specials_idx
[] = {
106 static char *specials
[] = {
107 "Rear Panel", "Drive Bar",
108 "Riser", "HDMI", "ATAPI",
109 "Mobile-In", "Mobile-Out"
112 cfg
= (cfg
& AC_DEFCFG_LOCATION
) >> AC_DEFCFG_LOCATION_SHIFT
;
113 if ((cfg
& 0x0f) < 7)
114 return bases
[cfg
& 0x0f];
115 for (i
= 0; i
< ARRAY_SIZE(specials_idx
); i
++) {
116 if (cfg
== specials_idx
[i
])
121 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location
);
123 const char *snd_hda_get_jack_connectivity(u32 cfg
)
125 static char *jack_locations
[4] = { "Ext", "Int", "Sep", "Oth" };
127 return jack_locations
[(cfg
>> (AC_DEFCFG_LOCATION_SHIFT
+ 4)) & 3];
129 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity
);
131 const char *snd_hda_get_jack_type(u32 cfg
)
133 static char *jack_types
[16] = {
134 "Line Out", "Speaker", "HP Out", "CD",
135 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
136 "Line In", "Aux", "Mic", "Telephony",
137 "SPDIF In", "Digitial In", "Reserved", "Other"
140 return jack_types
[(cfg
& AC_DEFCFG_DEVICE
)
141 >> AC_DEFCFG_DEVICE_SHIFT
];
143 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type
);
146 * Compose a 32bit command word to be sent to the HD-audio controller
148 static inline unsigned int
149 make_codec_cmd(struct hda_codec
*codec
, hda_nid_t nid
, int direct
,
150 unsigned int verb
, unsigned int parm
)
154 if ((codec
->addr
& ~0xf) || (direct
& ~1) || (nid
& ~0x7f) ||
155 (verb
& ~0xfff) || (parm
& ~0xffff)) {
156 printk(KERN_ERR
"hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
157 codec
->addr
, direct
, nid
, verb
, parm
);
161 val
= (u32
)codec
->addr
<< 28;
162 val
|= (u32
)direct
<< 27;
163 val
|= (u32
)nid
<< 20;
170 * Send and receive a verb
172 static int codec_exec_verb(struct hda_codec
*codec
, unsigned int cmd
,
175 struct hda_bus
*bus
= codec
->bus
;
184 snd_hda_power_up(codec
);
185 mutex_lock(&bus
->cmd_mutex
);
186 err
= bus
->ops
.command(bus
, cmd
);
188 *res
= bus
->ops
.get_response(bus
, codec
->addr
);
189 mutex_unlock(&bus
->cmd_mutex
);
190 snd_hda_power_down(codec
);
191 if (res
&& *res
== -1 && bus
->rirb_error
) {
192 if (bus
->response_reset
) {
193 snd_printd("hda_codec: resetting BUS due to "
194 "fatal communication error\n");
195 bus
->ops
.bus_reset(bus
);
199 /* clear reset-flag when the communication gets recovered */
201 bus
->response_reset
= 0;
206 * snd_hda_codec_read - send a command and get the response
207 * @codec: the HDA codec
208 * @nid: NID to send the command
209 * @direct: direct flag
210 * @verb: the verb to send
211 * @parm: the parameter for the verb
213 * Send a single command and read the corresponding response.
215 * Returns the obtained response value, or -1 for an error.
217 unsigned int snd_hda_codec_read(struct hda_codec
*codec
, hda_nid_t nid
,
219 unsigned int verb
, unsigned int parm
)
221 unsigned cmd
= make_codec_cmd(codec
, nid
, direct
, verb
, parm
);
223 codec_exec_verb(codec
, cmd
, &res
);
226 EXPORT_SYMBOL_HDA(snd_hda_codec_read
);
229 * snd_hda_codec_write - send a single command without waiting for response
230 * @codec: the HDA codec
231 * @nid: NID to send the command
232 * @direct: direct flag
233 * @verb: the verb to send
234 * @parm: the parameter for the verb
236 * Send a single command without waiting for response.
238 * Returns 0 if successful, or a negative error code.
240 int snd_hda_codec_write(struct hda_codec
*codec
, hda_nid_t nid
, int direct
,
241 unsigned int verb
, unsigned int parm
)
243 unsigned int cmd
= make_codec_cmd(codec
, nid
, direct
, verb
, parm
);
245 return codec_exec_verb(codec
, cmd
,
246 codec
->bus
->sync_write
? &res
: NULL
);
248 EXPORT_SYMBOL_HDA(snd_hda_codec_write
);
251 * snd_hda_sequence_write - sequence writes
252 * @codec: the HDA codec
253 * @seq: VERB array to send
255 * Send the commands sequentially from the given array.
256 * The array must be terminated with NID=0.
258 void snd_hda_sequence_write(struct hda_codec
*codec
, const struct hda_verb
*seq
)
260 for (; seq
->nid
; seq
++)
261 snd_hda_codec_write(codec
, seq
->nid
, 0, seq
->verb
, seq
->param
);
263 EXPORT_SYMBOL_HDA(snd_hda_sequence_write
);
266 * snd_hda_get_sub_nodes - get the range of sub nodes
267 * @codec: the HDA codec
269 * @start_id: the pointer to store the start NID
271 * Parse the NID and store the start NID of its sub-nodes.
272 * Returns the number of sub-nodes.
274 int snd_hda_get_sub_nodes(struct hda_codec
*codec
, hda_nid_t nid
,
279 parm
= snd_hda_param_read(codec
, nid
, AC_PAR_NODE_COUNT
);
282 *start_id
= (parm
>> 16) & 0x7fff;
283 return (int)(parm
& 0x7fff);
285 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes
);
288 * snd_hda_get_connections - get connection list
289 * @codec: the HDA codec
291 * @conn_list: connection list array
292 * @max_conns: max. number of connections to store
294 * Parses the connection list of the given widget and stores the list
297 * Returns the number of connections, or a negative error code.
299 int snd_hda_get_connections(struct hda_codec
*codec
, hda_nid_t nid
,
300 hda_nid_t
*conn_list
, int max_conns
)
303 int i
, conn_len
, conns
;
304 unsigned int shift
, num_elems
, mask
;
308 if (snd_BUG_ON(!conn_list
|| max_conns
<= 0))
311 wcaps
= get_wcaps(codec
, nid
);
312 if (!(wcaps
& AC_WCAP_CONN_LIST
) &&
313 get_wcaps_type(wcaps
) != AC_WID_VOL_KNB
) {
314 snd_printk(KERN_WARNING
"hda_codec: "
315 "connection list not available for 0x%x\n", nid
);
319 parm
= snd_hda_param_read(codec
, nid
, AC_PAR_CONNLIST_LEN
);
320 if (parm
& AC_CLIST_LONG
) {
329 conn_len
= parm
& AC_CLIST_LENGTH
;
330 mask
= (1 << (shift
-1)) - 1;
333 return 0; /* no connection */
336 /* single connection */
337 parm
= snd_hda_codec_read(codec
, nid
, 0,
338 AC_VERB_GET_CONNECT_LIST
, 0);
339 if (parm
== -1 && codec
->bus
->rirb_error
)
341 conn_list
[0] = parm
& mask
;
345 /* multi connection */
348 for (i
= 0; i
< conn_len
; i
++) {
352 if (i
% num_elems
== 0) {
353 parm
= snd_hda_codec_read(codec
, nid
, 0,
354 AC_VERB_GET_CONNECT_LIST
, i
);
355 if (parm
== -1 && codec
->bus
->rirb_error
)
358 range_val
= !!(parm
& (1 << (shift
-1))); /* ranges */
361 snd_printk(KERN_WARNING
"hda_codec: "
362 "invalid CONNECT_LIST verb %x[%i]:%x\n",
368 /* ranges between the previous and this one */
369 if (!prev_nid
|| prev_nid
>= val
) {
370 snd_printk(KERN_WARNING
"hda_codec: "
371 "invalid dep_range_val %x:%x\n",
375 for (n
= prev_nid
+ 1; n
<= val
; n
++) {
376 if (conns
>= max_conns
) {
378 "Too many connections\n");
381 conn_list
[conns
++] = n
;
384 if (conns
>= max_conns
) {
385 snd_printk(KERN_ERR
"Too many connections\n");
388 conn_list
[conns
++] = val
;
394 EXPORT_SYMBOL_HDA(snd_hda_get_connections
);
398 * snd_hda_queue_unsol_event - add an unsolicited event to queue
400 * @res: unsolicited event (lower 32bit of RIRB entry)
401 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
403 * Adds the given event to the queue. The events are processed in
404 * the workqueue asynchronously. Call this function in the interrupt
405 * hanlder when RIRB receives an unsolicited event.
407 * Returns 0 if successful, or a negative error code.
409 int snd_hda_queue_unsol_event(struct hda_bus
*bus
, u32 res
, u32 res_ex
)
411 struct hda_bus_unsolicited
*unsol
;
418 wp
= (unsol
->wp
+ 1) % HDA_UNSOL_QUEUE_SIZE
;
422 unsol
->queue
[wp
] = res
;
423 unsol
->queue
[wp
+ 1] = res_ex
;
425 queue_work(bus
->workq
, &unsol
->work
);
429 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event
);
432 * process queued unsolicited events
434 static void process_unsol_events(struct work_struct
*work
)
436 struct hda_bus_unsolicited
*unsol
=
437 container_of(work
, struct hda_bus_unsolicited
, work
);
438 struct hda_bus
*bus
= unsol
->bus
;
439 struct hda_codec
*codec
;
440 unsigned int rp
, caddr
, res
;
442 while (unsol
->rp
!= unsol
->wp
) {
443 rp
= (unsol
->rp
+ 1) % HDA_UNSOL_QUEUE_SIZE
;
446 res
= unsol
->queue
[rp
];
447 caddr
= unsol
->queue
[rp
+ 1];
448 if (!(caddr
& (1 << 4))) /* no unsolicited event? */
450 codec
= bus
->caddr_tbl
[caddr
& 0x0f];
451 if (codec
&& codec
->patch_ops
.unsol_event
)
452 codec
->patch_ops
.unsol_event(codec
, res
);
457 * initialize unsolicited queue
459 static int init_unsol_queue(struct hda_bus
*bus
)
461 struct hda_bus_unsolicited
*unsol
;
463 if (bus
->unsol
) /* already initialized */
466 unsol
= kzalloc(sizeof(*unsol
), GFP_KERNEL
);
468 snd_printk(KERN_ERR
"hda_codec: "
469 "can't allocate unsolicited queue\n");
472 INIT_WORK(&unsol
->work
, process_unsol_events
);
481 static void snd_hda_codec_free(struct hda_codec
*codec
);
483 static int snd_hda_bus_free(struct hda_bus
*bus
)
485 struct hda_codec
*codec
, *n
;
490 flush_workqueue(bus
->workq
);
493 list_for_each_entry_safe(codec
, n
, &bus
->codec_list
, list
) {
494 snd_hda_codec_free(codec
);
496 if (bus
->ops
.private_free
)
497 bus
->ops
.private_free(bus
);
499 destroy_workqueue(bus
->workq
);
504 static int snd_hda_bus_dev_free(struct snd_device
*device
)
506 struct hda_bus
*bus
= device
->device_data
;
508 return snd_hda_bus_free(bus
);
511 #ifdef CONFIG_SND_HDA_HWDEP
512 static int snd_hda_bus_dev_register(struct snd_device
*device
)
514 struct hda_bus
*bus
= device
->device_data
;
515 struct hda_codec
*codec
;
516 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
517 snd_hda_hwdep_add_sysfs(codec
);
522 #define snd_hda_bus_dev_register NULL
526 * snd_hda_bus_new - create a HDA bus
527 * @card: the card entry
528 * @temp: the template for hda_bus information
529 * @busp: the pointer to store the created bus instance
531 * Returns 0 if successful, or a negative error code.
533 int /*__devinit*/ snd_hda_bus_new(struct snd_card
*card
,
534 const struct hda_bus_template
*temp
,
535 struct hda_bus
**busp
)
539 static struct snd_device_ops dev_ops
= {
540 .dev_register
= snd_hda_bus_dev_register
,
541 .dev_free
= snd_hda_bus_dev_free
,
544 if (snd_BUG_ON(!temp
))
546 if (snd_BUG_ON(!temp
->ops
.command
|| !temp
->ops
.get_response
))
552 bus
= kzalloc(sizeof(*bus
), GFP_KERNEL
);
554 snd_printk(KERN_ERR
"can't allocate struct hda_bus\n");
559 bus
->private_data
= temp
->private_data
;
560 bus
->pci
= temp
->pci
;
561 bus
->modelname
= temp
->modelname
;
562 bus
->power_save
= temp
->power_save
;
563 bus
->ops
= temp
->ops
;
565 mutex_init(&bus
->cmd_mutex
);
566 INIT_LIST_HEAD(&bus
->codec_list
);
568 snprintf(bus
->workq_name
, sizeof(bus
->workq_name
),
569 "hd-audio%d", card
->number
);
570 bus
->workq
= create_singlethread_workqueue(bus
->workq_name
);
572 snd_printk(KERN_ERR
"cannot create workqueue %s\n",
578 err
= snd_device_new(card
, SNDRV_DEV_BUS
, bus
, &dev_ops
);
580 snd_hda_bus_free(bus
);
587 EXPORT_SYMBOL_HDA(snd_hda_bus_new
);
589 #ifdef CONFIG_SND_HDA_GENERIC
590 #define is_generic_config(codec) \
591 (codec->modelname && !strcmp(codec->modelname, "generic"))
593 #define is_generic_config(codec) 0
597 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
599 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
603 * find a matching codec preset
605 static const struct hda_codec_preset
*
606 find_codec_preset(struct hda_codec
*codec
)
608 struct hda_codec_preset_list
*tbl
;
609 const struct hda_codec_preset
*preset
;
610 int mod_requested
= 0;
612 if (is_generic_config(codec
))
613 return NULL
; /* use the generic parser */
616 mutex_lock(&preset_mutex
);
617 list_for_each_entry(tbl
, &hda_preset_tables
, list
) {
618 if (!try_module_get(tbl
->owner
)) {
619 snd_printk(KERN_ERR
"hda_codec: cannot module_get\n");
622 for (preset
= tbl
->preset
; preset
->id
; preset
++) {
623 u32 mask
= preset
->mask
;
624 if (preset
->afg
&& preset
->afg
!= codec
->afg
)
626 if (preset
->mfg
&& preset
->mfg
!= codec
->mfg
)
630 if (preset
->id
== (codec
->vendor_id
& mask
) &&
632 preset
->rev
== codec
->revision_id
)) {
633 mutex_unlock(&preset_mutex
);
634 codec
->owner
= tbl
->owner
;
638 module_put(tbl
->owner
);
640 mutex_unlock(&preset_mutex
);
642 if (mod_requested
< HDA_MODREQ_MAX_COUNT
) {
645 snprintf(name
, sizeof(name
), "snd-hda-codec-id:%08x",
648 snprintf(name
, sizeof(name
), "snd-hda-codec-id:%04x*",
649 (codec
->vendor_id
>> 16) & 0xffff);
650 request_module(name
);
658 * get_codec_name - store the codec name
660 static int get_codec_name(struct hda_codec
*codec
)
662 const struct hda_vendor_id
*c
;
663 const char *vendor
= NULL
;
664 u16 vendor_id
= codec
->vendor_id
>> 16;
667 if (codec
->vendor_name
)
670 for (c
= hda_vendor_ids
; c
->id
; c
++) {
671 if (c
->id
== vendor_id
) {
677 sprintf(tmp
, "Generic %04x", vendor_id
);
680 codec
->vendor_name
= kstrdup(vendor
, GFP_KERNEL
);
681 if (!codec
->vendor_name
)
685 if (codec
->chip_name
)
688 if (codec
->preset
&& codec
->preset
->name
)
689 codec
->chip_name
= kstrdup(codec
->preset
->name
, GFP_KERNEL
);
691 sprintf(tmp
, "ID %x", codec
->vendor_id
& 0xffff);
692 codec
->chip_name
= kstrdup(tmp
, GFP_KERNEL
);
694 if (!codec
->chip_name
)
700 * look for an AFG and MFG nodes
702 static void /*__devinit*/ setup_fg_nodes(struct hda_codec
*codec
)
704 int i
, total_nodes
, function_id
;
707 total_nodes
= snd_hda_get_sub_nodes(codec
, AC_NODE_ROOT
, &nid
);
708 for (i
= 0; i
< total_nodes
; i
++, nid
++) {
709 function_id
= snd_hda_param_read(codec
, nid
,
710 AC_PAR_FUNCTION_TYPE
) & 0xff;
711 switch (function_id
) {
712 case AC_GRP_AUDIO_FUNCTION
:
714 codec
->function_id
= function_id
;
716 case AC_GRP_MODEM_FUNCTION
:
718 codec
->function_id
= function_id
;
727 * read widget caps for each widget and store in cache
729 static int read_widget_caps(struct hda_codec
*codec
, hda_nid_t fg_node
)
734 codec
->num_nodes
= snd_hda_get_sub_nodes(codec
, fg_node
,
736 codec
->wcaps
= kmalloc(codec
->num_nodes
* 4, GFP_KERNEL
);
739 nid
= codec
->start_nid
;
740 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++)
741 codec
->wcaps
[i
] = snd_hda_param_read(codec
, nid
,
742 AC_PAR_AUDIO_WIDGET_CAP
);
746 /* read all pin default configurations and save codec->init_pins */
747 static int read_pin_defaults(struct hda_codec
*codec
)
750 hda_nid_t nid
= codec
->start_nid
;
752 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
753 struct hda_pincfg
*pin
;
754 unsigned int wcaps
= get_wcaps(codec
, nid
);
755 unsigned int wid_type
= get_wcaps_type(wcaps
);
756 if (wid_type
!= AC_WID_PIN
)
758 pin
= snd_array_new(&codec
->init_pins
);
762 pin
->cfg
= snd_hda_codec_read(codec
, nid
, 0,
763 AC_VERB_GET_CONFIG_DEFAULT
, 0);
768 /* look up the given pin config list and return the item matching with NID */
769 static struct hda_pincfg
*look_up_pincfg(struct hda_codec
*codec
,
770 struct snd_array
*array
,
774 for (i
= 0; i
< array
->used
; i
++) {
775 struct hda_pincfg
*pin
= snd_array_elem(array
, i
);
782 /* write a config value for the given NID */
783 static void set_pincfg(struct hda_codec
*codec
, hda_nid_t nid
,
787 for (i
= 0; i
< 4; i
++) {
788 snd_hda_codec_write(codec
, nid
, 0,
789 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0
+ i
,
795 /* set the current pin config value for the given NID.
796 * the value is cached, and read via snd_hda_codec_get_pincfg()
798 int snd_hda_add_pincfg(struct hda_codec
*codec
, struct snd_array
*list
,
799 hda_nid_t nid
, unsigned int cfg
)
801 struct hda_pincfg
*pin
;
804 oldcfg
= snd_hda_codec_get_pincfg(codec
, nid
);
805 pin
= look_up_pincfg(codec
, list
, nid
);
807 pin
= snd_array_new(list
);
814 /* change only when needed; e.g. if the pincfg is already present
815 * in user_pins[], don't write it
817 cfg
= snd_hda_codec_get_pincfg(codec
, nid
);
819 set_pincfg(codec
, nid
, cfg
);
823 int snd_hda_codec_set_pincfg(struct hda_codec
*codec
,
824 hda_nid_t nid
, unsigned int cfg
)
826 return snd_hda_add_pincfg(codec
, &codec
->driver_pins
, nid
, cfg
);
828 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg
);
830 /* get the current pin config value of the given pin NID */
831 unsigned int snd_hda_codec_get_pincfg(struct hda_codec
*codec
, hda_nid_t nid
)
833 struct hda_pincfg
*pin
;
835 #ifdef CONFIG_SND_HDA_HWDEP
836 pin
= look_up_pincfg(codec
, &codec
->user_pins
, nid
);
840 pin
= look_up_pincfg(codec
, &codec
->driver_pins
, nid
);
843 pin
= look_up_pincfg(codec
, &codec
->init_pins
, nid
);
848 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg
);
850 /* restore all current pin configs */
851 static void restore_pincfgs(struct hda_codec
*codec
)
854 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
855 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
856 set_pincfg(codec
, pin
->nid
,
857 snd_hda_codec_get_pincfg(codec
, pin
->nid
));
861 static void init_hda_cache(struct hda_cache_rec
*cache
,
862 unsigned int record_size
);
863 static void free_hda_cache(struct hda_cache_rec
*cache
);
865 /* restore the initial pin cfgs and release all pincfg lists */
866 static void restore_init_pincfgs(struct hda_codec
*codec
)
868 /* first free driver_pins and user_pins, then call restore_pincfg
869 * so that only the values in init_pins are restored
871 snd_array_free(&codec
->driver_pins
);
872 #ifdef CONFIG_SND_HDA_HWDEP
873 snd_array_free(&codec
->user_pins
);
875 restore_pincfgs(codec
);
876 snd_array_free(&codec
->init_pins
);
882 static void snd_hda_codec_free(struct hda_codec
*codec
)
886 restore_init_pincfgs(codec
);
887 #ifdef CONFIG_SND_HDA_POWER_SAVE
888 cancel_delayed_work(&codec
->power_work
);
889 flush_workqueue(codec
->bus
->workq
);
891 list_del(&codec
->list
);
892 snd_array_free(&codec
->mixers
);
893 codec
->bus
->caddr_tbl
[codec
->addr
] = NULL
;
894 if (codec
->patch_ops
.free
)
895 codec
->patch_ops
.free(codec
);
896 module_put(codec
->owner
);
897 free_hda_cache(&codec
->amp_cache
);
898 free_hda_cache(&codec
->cmd_cache
);
899 kfree(codec
->vendor_name
);
900 kfree(codec
->chip_name
);
901 kfree(codec
->modelname
);
906 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
907 unsigned int power_state
);
910 * snd_hda_codec_new - create a HDA codec
911 * @bus: the bus to assign
912 * @codec_addr: the codec address
913 * @codecp: the pointer to store the generated codec
915 * Returns 0 if successful, or a negative error code.
917 int /*__devinit*/ snd_hda_codec_new(struct hda_bus
*bus
, unsigned int codec_addr
,
918 struct hda_codec
**codecp
)
920 struct hda_codec
*codec
;
924 if (snd_BUG_ON(!bus
))
926 if (snd_BUG_ON(codec_addr
> HDA_MAX_CODEC_ADDRESS
))
929 if (bus
->caddr_tbl
[codec_addr
]) {
930 snd_printk(KERN_ERR
"hda_codec: "
931 "address 0x%x is already occupied\n", codec_addr
);
935 codec
= kzalloc(sizeof(*codec
), GFP_KERNEL
);
937 snd_printk(KERN_ERR
"can't allocate struct hda_codec\n");
942 codec
->addr
= codec_addr
;
943 mutex_init(&codec
->spdif_mutex
);
944 mutex_init(&codec
->control_mutex
);
945 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
946 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
947 snd_array_init(&codec
->mixers
, sizeof(struct snd_kcontrol
*), 32);
948 snd_array_init(&codec
->init_pins
, sizeof(struct hda_pincfg
), 16);
949 snd_array_init(&codec
->driver_pins
, sizeof(struct hda_pincfg
), 16);
950 if (codec
->bus
->modelname
) {
951 codec
->modelname
= kstrdup(codec
->bus
->modelname
, GFP_KERNEL
);
952 if (!codec
->modelname
) {
953 snd_hda_codec_free(codec
);
958 #ifdef CONFIG_SND_HDA_POWER_SAVE
959 INIT_DELAYED_WORK(&codec
->power_work
, hda_power_work
);
960 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
961 * the caller has to power down appropriatley after initialization
964 hda_keep_power_on(codec
);
967 list_add_tail(&codec
->list
, &bus
->codec_list
);
968 bus
->caddr_tbl
[codec_addr
] = codec
;
970 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
972 if (codec
->vendor_id
== -1)
973 /* read again, hopefully the access method was corrected
974 * in the last read...
976 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
978 codec
->subsystem_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
979 AC_PAR_SUBSYSTEM_ID
);
980 codec
->revision_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
983 setup_fg_nodes(codec
);
984 if (!codec
->afg
&& !codec
->mfg
) {
985 snd_printdd("hda_codec: no AFG or MFG node found\n");
990 err
= read_widget_caps(codec
, codec
->afg
? codec
->afg
: codec
->mfg
);
992 snd_printk(KERN_ERR
"hda_codec: cannot malloc\n");
995 err
= read_pin_defaults(codec
);
999 if (!codec
->subsystem_id
) {
1000 hda_nid_t nid
= codec
->afg
? codec
->afg
: codec
->mfg
;
1001 codec
->subsystem_id
=
1002 snd_hda_codec_read(codec
, nid
, 0,
1003 AC_VERB_GET_SUBSYSTEM_ID
, 0);
1006 /* power-up all before initialization */
1007 hda_set_power_state(codec
,
1008 codec
->afg
? codec
->afg
: codec
->mfg
,
1011 snd_hda_codec_proc_new(codec
);
1013 snd_hda_create_hwdep(codec
);
1015 sprintf(component
, "HDA:%08x,%08x,%08x", codec
->vendor_id
,
1016 codec
->subsystem_id
, codec
->revision_id
);
1017 snd_component_add(codec
->bus
->card
, component
);
1024 snd_hda_codec_free(codec
);
1027 EXPORT_SYMBOL_HDA(snd_hda_codec_new
);
1029 int snd_hda_codec_configure(struct hda_codec
*codec
)
1033 codec
->preset
= find_codec_preset(codec
);
1034 if (!codec
->vendor_name
|| !codec
->chip_name
) {
1035 err
= get_codec_name(codec
);
1039 /* audio codec should override the mixer name */
1040 if (codec
->afg
|| !*codec
->bus
->card
->mixername
)
1041 snprintf(codec
->bus
->card
->mixername
,
1042 sizeof(codec
->bus
->card
->mixername
),
1043 "%s %s", codec
->vendor_name
, codec
->chip_name
);
1045 if (is_generic_config(codec
)) {
1046 err
= snd_hda_parse_generic_codec(codec
);
1049 if (codec
->preset
&& codec
->preset
->patch
) {
1050 err
= codec
->preset
->patch(codec
);
1054 /* call the default parser */
1055 err
= snd_hda_parse_generic_codec(codec
);
1057 printk(KERN_ERR
"hda-codec: No codec parser is available\n");
1060 if (!err
&& codec
->patch_ops
.unsol_event
)
1061 err
= init_unsol_queue(codec
->bus
);
1064 EXPORT_SYMBOL_HDA(snd_hda_codec_configure
);
1067 * snd_hda_codec_setup_stream - set up the codec for streaming
1068 * @codec: the CODEC to set up
1069 * @nid: the NID to set up
1070 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1071 * @channel_id: channel id to pass, zero based.
1072 * @format: stream format.
1074 void snd_hda_codec_setup_stream(struct hda_codec
*codec
, hda_nid_t nid
,
1076 int channel_id
, int format
)
1081 snd_printdd("hda_codec_setup_stream: "
1082 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1083 nid
, stream_tag
, channel_id
, format
);
1084 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CHANNEL_STREAMID
,
1085 (stream_tag
<< 4) | channel_id
);
1087 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_STREAM_FORMAT
, format
);
1089 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream
);
1091 void snd_hda_codec_cleanup_stream(struct hda_codec
*codec
, hda_nid_t nid
)
1096 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid
);
1097 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CHANNEL_STREAMID
, 0);
1098 #if 0 /* keep the format */
1100 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_STREAM_FORMAT
, 0);
1103 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream
);
1106 * amp access functions
1109 /* FIXME: more better hash key? */
1110 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1111 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1112 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1113 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1114 #define INFO_AMP_CAPS (1<<0)
1115 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1117 /* initialize the hash table */
1118 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec
*cache
,
1119 unsigned int record_size
)
1121 memset(cache
, 0, sizeof(*cache
));
1122 memset(cache
->hash
, 0xff, sizeof(cache
->hash
));
1123 snd_array_init(&cache
->buf
, record_size
, 64);
1126 static void free_hda_cache(struct hda_cache_rec
*cache
)
1128 snd_array_free(&cache
->buf
);
1131 /* query the hash. allocate an entry if not found. */
1132 static struct hda_cache_head
*get_alloc_hash(struct hda_cache_rec
*cache
,
1135 u16 idx
= key
% (u16
)ARRAY_SIZE(cache
->hash
);
1136 u16 cur
= cache
->hash
[idx
];
1137 struct hda_cache_head
*info
;
1139 while (cur
!= 0xffff) {
1140 info
= snd_array_elem(&cache
->buf
, cur
);
1141 if (info
->key
== key
)
1146 /* add a new hash entry */
1147 info
= snd_array_new(&cache
->buf
);
1150 cur
= snd_array_index(&cache
->buf
, info
);
1153 info
->next
= cache
->hash
[idx
];
1154 cache
->hash
[idx
] = cur
;
1159 /* query and allocate an amp hash entry */
1160 static inline struct hda_amp_info
*
1161 get_alloc_amp_hash(struct hda_codec
*codec
, u32 key
)
1163 return (struct hda_amp_info
*)get_alloc_hash(&codec
->amp_cache
, key
);
1167 * query AMP capabilities for the given widget and direction
1169 u32
query_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int direction
)
1171 struct hda_amp_info
*info
;
1173 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, 0));
1176 if (!(info
->head
.val
& INFO_AMP_CAPS
)) {
1177 if (!(get_wcaps(codec
, nid
) & AC_WCAP_AMP_OVRD
))
1179 info
->amp_caps
= snd_hda_param_read(codec
, nid
,
1180 direction
== HDA_OUTPUT
?
1181 AC_PAR_AMP_OUT_CAP
:
1184 info
->head
.val
|= INFO_AMP_CAPS
;
1186 return info
->amp_caps
;
1188 EXPORT_SYMBOL_HDA(query_amp_caps
);
1190 int snd_hda_override_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1193 struct hda_amp_info
*info
;
1195 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, dir
, 0));
1198 info
->amp_caps
= caps
;
1199 info
->head
.val
|= INFO_AMP_CAPS
;
1202 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps
);
1205 query_caps_hash(struct hda_codec
*codec
, hda_nid_t nid
, u32 key
,
1206 unsigned int (*func
)(struct hda_codec
*, hda_nid_t
))
1208 struct hda_amp_info
*info
;
1210 info
= get_alloc_amp_hash(codec
, key
);
1213 if (!info
->head
.val
) {
1214 info
->head
.val
|= INFO_AMP_CAPS
;
1215 info
->amp_caps
= func(codec
, nid
);
1217 return info
->amp_caps
;
1220 static unsigned int read_pin_cap(struct hda_codec
*codec
, hda_nid_t nid
)
1222 return snd_hda_param_read(codec
, nid
, AC_PAR_PIN_CAP
);
1225 u32
snd_hda_query_pin_caps(struct hda_codec
*codec
, hda_nid_t nid
)
1227 return query_caps_hash(codec
, nid
, HDA_HASH_PINCAP_KEY(nid
),
1230 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps
);
1233 * read the current volume to info
1234 * if the cache exists, read the cache value.
1236 static unsigned int get_vol_mute(struct hda_codec
*codec
,
1237 struct hda_amp_info
*info
, hda_nid_t nid
,
1238 int ch
, int direction
, int index
)
1242 if (info
->head
.val
& INFO_AMP_VOL(ch
))
1243 return info
->vol
[ch
];
1245 parm
= ch
? AC_AMP_GET_RIGHT
: AC_AMP_GET_LEFT
;
1246 parm
|= direction
== HDA_OUTPUT
? AC_AMP_GET_OUTPUT
: AC_AMP_GET_INPUT
;
1248 val
= snd_hda_codec_read(codec
, nid
, 0,
1249 AC_VERB_GET_AMP_GAIN_MUTE
, parm
);
1250 info
->vol
[ch
] = val
& 0xff;
1251 info
->head
.val
|= INFO_AMP_VOL(ch
);
1252 return info
->vol
[ch
];
1256 * write the current volume in info to the h/w and update the cache
1258 static void put_vol_mute(struct hda_codec
*codec
, struct hda_amp_info
*info
,
1259 hda_nid_t nid
, int ch
, int direction
, int index
,
1264 parm
= ch
? AC_AMP_SET_RIGHT
: AC_AMP_SET_LEFT
;
1265 parm
|= direction
== HDA_OUTPUT
? AC_AMP_SET_OUTPUT
: AC_AMP_SET_INPUT
;
1266 parm
|= index
<< AC_AMP_SET_INDEX_SHIFT
;
1268 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, parm
);
1269 info
->vol
[ch
] = val
;
1273 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1275 int snd_hda_codec_amp_read(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1276 int direction
, int index
)
1278 struct hda_amp_info
*info
;
1279 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, index
));
1282 return get_vol_mute(codec
, info
, nid
, ch
, direction
, index
);
1284 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read
);
1287 * update the AMP value, mask = bit mask to set, val = the value
1289 int snd_hda_codec_amp_update(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1290 int direction
, int idx
, int mask
, int val
)
1292 struct hda_amp_info
*info
;
1294 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, idx
));
1298 val
|= get_vol_mute(codec
, info
, nid
, ch
, direction
, idx
) & ~mask
;
1299 if (info
->vol
[ch
] == val
)
1301 put_vol_mute(codec
, info
, nid
, ch
, direction
, idx
, val
);
1304 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update
);
1307 * update the AMP stereo with the same mask and value
1309 int snd_hda_codec_amp_stereo(struct hda_codec
*codec
, hda_nid_t nid
,
1310 int direction
, int idx
, int mask
, int val
)
1313 for (ch
= 0; ch
< 2; ch
++)
1314 ret
|= snd_hda_codec_amp_update(codec
, nid
, ch
, direction
,
1318 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo
);
1320 #ifdef SND_HDA_NEEDS_RESUME
1321 /* resume the all amp commands from the cache */
1322 void snd_hda_codec_resume_amp(struct hda_codec
*codec
)
1324 struct hda_amp_info
*buffer
= codec
->amp_cache
.buf
.list
;
1327 for (i
= 0; i
< codec
->amp_cache
.buf
.used
; i
++, buffer
++) {
1328 u32 key
= buffer
->head
.key
;
1330 unsigned int idx
, dir
, ch
;
1334 idx
= (key
>> 16) & 0xff;
1335 dir
= (key
>> 24) & 0xff;
1336 for (ch
= 0; ch
< 2; ch
++) {
1337 if (!(buffer
->head
.val
& INFO_AMP_VOL(ch
)))
1339 put_vol_mute(codec
, buffer
, nid
, ch
, dir
, idx
,
1344 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp
);
1345 #endif /* SND_HDA_NEEDS_RESUME */
1348 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol
*kcontrol
,
1349 struct snd_ctl_elem_info
*uinfo
)
1351 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1352 u16 nid
= get_amp_nid(kcontrol
);
1353 u8 chs
= get_amp_channels(kcontrol
);
1354 int dir
= get_amp_direction(kcontrol
);
1355 unsigned int ofs
= get_amp_offset(kcontrol
);
1358 caps
= query_amp_caps(codec
, nid
, dir
);
1360 caps
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1362 printk(KERN_WARNING
"hda_codec: "
1363 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid
,
1369 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1370 uinfo
->count
= chs
== 3 ? 2 : 1;
1371 uinfo
->value
.integer
.min
= 0;
1372 uinfo
->value
.integer
.max
= caps
;
1375 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info
);
1378 static inline unsigned int
1379 read_amp_value(struct hda_codec
*codec
, hda_nid_t nid
,
1380 int ch
, int dir
, int idx
, unsigned int ofs
)
1383 val
= snd_hda_codec_amp_read(codec
, nid
, ch
, dir
, idx
);
1384 val
&= HDA_AMP_VOLMASK
;
1393 update_amp_value(struct hda_codec
*codec
, hda_nid_t nid
,
1394 int ch
, int dir
, int idx
, unsigned int ofs
,
1399 return snd_hda_codec_amp_update(codec
, nid
, ch
, dir
, idx
,
1400 HDA_AMP_VOLMASK
, val
);
1403 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol
*kcontrol
,
1404 struct snd_ctl_elem_value
*ucontrol
)
1406 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1407 hda_nid_t nid
= get_amp_nid(kcontrol
);
1408 int chs
= get_amp_channels(kcontrol
);
1409 int dir
= get_amp_direction(kcontrol
);
1410 int idx
= get_amp_index(kcontrol
);
1411 unsigned int ofs
= get_amp_offset(kcontrol
);
1412 long *valp
= ucontrol
->value
.integer
.value
;
1415 *valp
++ = read_amp_value(codec
, nid
, 0, dir
, idx
, ofs
);
1417 *valp
= read_amp_value(codec
, nid
, 1, dir
, idx
, ofs
);
1420 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get
);
1422 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol
*kcontrol
,
1423 struct snd_ctl_elem_value
*ucontrol
)
1425 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1426 hda_nid_t nid
= get_amp_nid(kcontrol
);
1427 int chs
= get_amp_channels(kcontrol
);
1428 int dir
= get_amp_direction(kcontrol
);
1429 int idx
= get_amp_index(kcontrol
);
1430 unsigned int ofs
= get_amp_offset(kcontrol
);
1431 long *valp
= ucontrol
->value
.integer
.value
;
1434 snd_hda_power_up(codec
);
1436 change
= update_amp_value(codec
, nid
, 0, dir
, idx
, ofs
, *valp
);
1440 change
|= update_amp_value(codec
, nid
, 1, dir
, idx
, ofs
, *valp
);
1441 snd_hda_power_down(codec
);
1444 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put
);
1446 int snd_hda_mixer_amp_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
1447 unsigned int size
, unsigned int __user
*_tlv
)
1449 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1450 hda_nid_t nid
= get_amp_nid(kcontrol
);
1451 int dir
= get_amp_direction(kcontrol
);
1452 unsigned int ofs
= get_amp_offset(kcontrol
);
1453 u32 caps
, val1
, val2
;
1455 if (size
< 4 * sizeof(unsigned int))
1457 caps
= query_amp_caps(codec
, nid
, dir
);
1458 val2
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1459 val2
= (val2
+ 1) * 25;
1460 val1
= -((caps
& AC_AMPCAP_OFFSET
) >> AC_AMPCAP_OFFSET_SHIFT
);
1462 val1
= ((int)val1
) * ((int)val2
);
1463 if (put_user(SNDRV_CTL_TLVT_DB_SCALE
, _tlv
))
1465 if (put_user(2 * sizeof(unsigned int), _tlv
+ 1))
1467 if (put_user(val1
, _tlv
+ 2))
1469 if (put_user(val2
, _tlv
+ 3))
1473 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv
);
1476 * set (static) TLV for virtual master volume; recalculated as max 0dB
1478 void snd_hda_set_vmaster_tlv(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1484 caps
= query_amp_caps(codec
, nid
, dir
);
1485 nums
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1486 step
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1487 step
= (step
+ 1) * 25;
1488 tlv
[0] = SNDRV_CTL_TLVT_DB_SCALE
;
1489 tlv
[1] = 2 * sizeof(unsigned int);
1490 tlv
[2] = -nums
* step
;
1493 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv
);
1495 /* find a mixer control element with the given name */
1496 static struct snd_kcontrol
*
1497 _snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
1498 const char *name
, int idx
)
1500 struct snd_ctl_elem_id id
;
1501 memset(&id
, 0, sizeof(id
));
1502 id
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1504 if (snd_BUG_ON(strlen(name
) >= sizeof(id
.name
)))
1506 strcpy(id
.name
, name
);
1507 return snd_ctl_find_id(codec
->bus
->card
, &id
);
1510 struct snd_kcontrol
*snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
1513 return _snd_hda_find_mixer_ctl(codec
, name
, 0);
1515 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl
);
1517 /* Add a control element and assign to the codec */
1518 int snd_hda_ctl_add(struct hda_codec
*codec
, struct snd_kcontrol
*kctl
)
1521 struct snd_kcontrol
**knewp
;
1523 err
= snd_ctl_add(codec
->bus
->card
, kctl
);
1526 knewp
= snd_array_new(&codec
->mixers
);
1532 EXPORT_SYMBOL_HDA(snd_hda_ctl_add
);
1534 /* Clear all controls assigned to the given codec */
1535 void snd_hda_ctls_clear(struct hda_codec
*codec
)
1538 struct snd_kcontrol
**kctls
= codec
->mixers
.list
;
1539 for (i
= 0; i
< codec
->mixers
.used
; i
++)
1540 snd_ctl_remove(codec
->bus
->card
, kctls
[i
]);
1541 snd_array_free(&codec
->mixers
);
1544 /* pseudo device locking
1545 * toggle card->shutdown to allow/disallow the device access (as a hack)
1547 static int hda_lock_devices(struct snd_card
*card
)
1549 spin_lock(&card
->files_lock
);
1550 if (card
->shutdown
) {
1551 spin_unlock(&card
->files_lock
);
1555 spin_unlock(&card
->files_lock
);
1559 static void hda_unlock_devices(struct snd_card
*card
)
1561 spin_lock(&card
->files_lock
);
1563 spin_unlock(&card
->files_lock
);
1566 int snd_hda_codec_reset(struct hda_codec
*codec
)
1568 struct snd_card
*card
= codec
->bus
->card
;
1571 if (hda_lock_devices(card
) < 0)
1573 /* check whether the codec isn't used by any mixer or PCM streams */
1574 if (!list_empty(&card
->ctl_files
)) {
1575 hda_unlock_devices(card
);
1578 for (pcm
= 0; pcm
< codec
->num_pcms
; pcm
++) {
1579 struct hda_pcm
*cpcm
= &codec
->pcm_info
[pcm
];
1582 if (cpcm
->pcm
->streams
[0].substream_opened
||
1583 cpcm
->pcm
->streams
[1].substream_opened
) {
1584 hda_unlock_devices(card
);
1589 /* OK, let it free */
1591 #ifdef CONFIG_SND_HDA_POWER_SAVE
1592 cancel_delayed_work(&codec
->power_work
);
1593 flush_workqueue(codec
->bus
->workq
);
1595 snd_hda_ctls_clear(codec
);
1597 for (i
= 0; i
< codec
->num_pcms
; i
++) {
1598 if (codec
->pcm_info
[i
].pcm
) {
1599 snd_device_free(card
, codec
->pcm_info
[i
].pcm
);
1600 clear_bit(codec
->pcm_info
[i
].device
,
1601 codec
->bus
->pcm_dev_bits
);
1604 if (codec
->patch_ops
.free
)
1605 codec
->patch_ops
.free(codec
);
1606 codec
->proc_widget_hook
= NULL
;
1608 free_hda_cache(&codec
->amp_cache
);
1609 free_hda_cache(&codec
->cmd_cache
);
1610 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
1611 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
1612 /* free only driver_pins so that init_pins + user_pins are restored */
1613 snd_array_free(&codec
->driver_pins
);
1614 restore_pincfgs(codec
);
1615 codec
->num_pcms
= 0;
1616 codec
->pcm_info
= NULL
;
1617 codec
->preset
= NULL
;
1618 memset(&codec
->patch_ops
, 0, sizeof(codec
->patch_ops
));
1619 codec
->slave_dig_outs
= NULL
;
1620 codec
->spdif_status_reset
= 0;
1621 module_put(codec
->owner
);
1622 codec
->owner
= NULL
;
1624 /* allow device access again */
1625 hda_unlock_devices(card
);
1629 /* create a virtual master control and add slaves */
1630 int snd_hda_add_vmaster(struct hda_codec
*codec
, char *name
,
1631 unsigned int *tlv
, const char **slaves
)
1633 struct snd_kcontrol
*kctl
;
1637 for (s
= slaves
; *s
&& !snd_hda_find_mixer_ctl(codec
, *s
); s
++)
1640 snd_printdd("No slave found for %s\n", name
);
1643 kctl
= snd_ctl_make_virtual_master(name
, tlv
);
1646 err
= snd_hda_ctl_add(codec
, kctl
);
1650 for (s
= slaves
; *s
; s
++) {
1651 struct snd_kcontrol
*sctl
;
1654 sctl
= _snd_hda_find_mixer_ctl(codec
, *s
, i
);
1657 snd_printdd("Cannot find slave %s, "
1661 err
= snd_ctl_add_slave(kctl
, sctl
);
1669 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster
);
1672 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol
*kcontrol
,
1673 struct snd_ctl_elem_info
*uinfo
)
1675 int chs
= get_amp_channels(kcontrol
);
1677 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
1678 uinfo
->count
= chs
== 3 ? 2 : 1;
1679 uinfo
->value
.integer
.min
= 0;
1680 uinfo
->value
.integer
.max
= 1;
1683 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info
);
1685 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol
*kcontrol
,
1686 struct snd_ctl_elem_value
*ucontrol
)
1688 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1689 hda_nid_t nid
= get_amp_nid(kcontrol
);
1690 int chs
= get_amp_channels(kcontrol
);
1691 int dir
= get_amp_direction(kcontrol
);
1692 int idx
= get_amp_index(kcontrol
);
1693 long *valp
= ucontrol
->value
.integer
.value
;
1696 *valp
++ = (snd_hda_codec_amp_read(codec
, nid
, 0, dir
, idx
) &
1697 HDA_AMP_MUTE
) ? 0 : 1;
1699 *valp
= (snd_hda_codec_amp_read(codec
, nid
, 1, dir
, idx
) &
1700 HDA_AMP_MUTE
) ? 0 : 1;
1703 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get
);
1705 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol
*kcontrol
,
1706 struct snd_ctl_elem_value
*ucontrol
)
1708 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1709 hda_nid_t nid
= get_amp_nid(kcontrol
);
1710 int chs
= get_amp_channels(kcontrol
);
1711 int dir
= get_amp_direction(kcontrol
);
1712 int idx
= get_amp_index(kcontrol
);
1713 long *valp
= ucontrol
->value
.integer
.value
;
1716 snd_hda_power_up(codec
);
1718 change
= snd_hda_codec_amp_update(codec
, nid
, 0, dir
, idx
,
1720 *valp
? 0 : HDA_AMP_MUTE
);
1724 change
|= snd_hda_codec_amp_update(codec
, nid
, 1, dir
, idx
,
1726 *valp
? 0 : HDA_AMP_MUTE
);
1727 #ifdef CONFIG_SND_HDA_POWER_SAVE
1728 if (codec
->patch_ops
.check_power_status
)
1729 codec
->patch_ops
.check_power_status(codec
, nid
);
1731 snd_hda_power_down(codec
);
1734 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put
);
1737 * bound volume controls
1739 * bind multiple volumes (# indices, from 0)
1742 #define AMP_VAL_IDX_SHIFT 19
1743 #define AMP_VAL_IDX_MASK (0x0f<<19)
1745 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol
*kcontrol
,
1746 struct snd_ctl_elem_value
*ucontrol
)
1748 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1752 mutex_lock(&codec
->control_mutex
);
1753 pval
= kcontrol
->private_value
;
1754 kcontrol
->private_value
= pval
& ~AMP_VAL_IDX_MASK
; /* index 0 */
1755 err
= snd_hda_mixer_amp_switch_get(kcontrol
, ucontrol
);
1756 kcontrol
->private_value
= pval
;
1757 mutex_unlock(&codec
->control_mutex
);
1760 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get
);
1762 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol
*kcontrol
,
1763 struct snd_ctl_elem_value
*ucontrol
)
1765 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1767 int i
, indices
, err
= 0, change
= 0;
1769 mutex_lock(&codec
->control_mutex
);
1770 pval
= kcontrol
->private_value
;
1771 indices
= (pval
& AMP_VAL_IDX_MASK
) >> AMP_VAL_IDX_SHIFT
;
1772 for (i
= 0; i
< indices
; i
++) {
1773 kcontrol
->private_value
= (pval
& ~AMP_VAL_IDX_MASK
) |
1774 (i
<< AMP_VAL_IDX_SHIFT
);
1775 err
= snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
1780 kcontrol
->private_value
= pval
;
1781 mutex_unlock(&codec
->control_mutex
);
1782 return err
< 0 ? err
: change
;
1784 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put
);
1787 * generic bound volume/swtich controls
1789 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol
*kcontrol
,
1790 struct snd_ctl_elem_info
*uinfo
)
1792 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1793 struct hda_bind_ctls
*c
;
1796 mutex_lock(&codec
->control_mutex
);
1797 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1798 kcontrol
->private_value
= *c
->values
;
1799 err
= c
->ops
->info(kcontrol
, uinfo
);
1800 kcontrol
->private_value
= (long)c
;
1801 mutex_unlock(&codec
->control_mutex
);
1804 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info
);
1806 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol
*kcontrol
,
1807 struct snd_ctl_elem_value
*ucontrol
)
1809 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1810 struct hda_bind_ctls
*c
;
1813 mutex_lock(&codec
->control_mutex
);
1814 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1815 kcontrol
->private_value
= *c
->values
;
1816 err
= c
->ops
->get(kcontrol
, ucontrol
);
1817 kcontrol
->private_value
= (long)c
;
1818 mutex_unlock(&codec
->control_mutex
);
1821 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get
);
1823 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol
*kcontrol
,
1824 struct snd_ctl_elem_value
*ucontrol
)
1826 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1827 struct hda_bind_ctls
*c
;
1828 unsigned long *vals
;
1829 int err
= 0, change
= 0;
1831 mutex_lock(&codec
->control_mutex
);
1832 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1833 for (vals
= c
->values
; *vals
; vals
++) {
1834 kcontrol
->private_value
= *vals
;
1835 err
= c
->ops
->put(kcontrol
, ucontrol
);
1840 kcontrol
->private_value
= (long)c
;
1841 mutex_unlock(&codec
->control_mutex
);
1842 return err
< 0 ? err
: change
;
1844 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put
);
1846 int snd_hda_mixer_bind_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
1847 unsigned int size
, unsigned int __user
*tlv
)
1849 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1850 struct hda_bind_ctls
*c
;
1853 mutex_lock(&codec
->control_mutex
);
1854 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1855 kcontrol
->private_value
= *c
->values
;
1856 err
= c
->ops
->tlv(kcontrol
, op_flag
, size
, tlv
);
1857 kcontrol
->private_value
= (long)c
;
1858 mutex_unlock(&codec
->control_mutex
);
1861 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv
);
1863 struct hda_ctl_ops snd_hda_bind_vol
= {
1864 .info
= snd_hda_mixer_amp_volume_info
,
1865 .get
= snd_hda_mixer_amp_volume_get
,
1866 .put
= snd_hda_mixer_amp_volume_put
,
1867 .tlv
= snd_hda_mixer_amp_tlv
1869 EXPORT_SYMBOL_HDA(snd_hda_bind_vol
);
1871 struct hda_ctl_ops snd_hda_bind_sw
= {
1872 .info
= snd_hda_mixer_amp_switch_info
,
1873 .get
= snd_hda_mixer_amp_switch_get
,
1874 .put
= snd_hda_mixer_amp_switch_put
,
1875 .tlv
= snd_hda_mixer_amp_tlv
1877 EXPORT_SYMBOL_HDA(snd_hda_bind_sw
);
1880 * SPDIF out controls
1883 static int snd_hda_spdif_mask_info(struct snd_kcontrol
*kcontrol
,
1884 struct snd_ctl_elem_info
*uinfo
)
1886 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
1891 static int snd_hda_spdif_cmask_get(struct snd_kcontrol
*kcontrol
,
1892 struct snd_ctl_elem_value
*ucontrol
)
1894 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
1895 IEC958_AES0_NONAUDIO
|
1896 IEC958_AES0_CON_EMPHASIS_5015
|
1897 IEC958_AES0_CON_NOT_COPYRIGHT
;
1898 ucontrol
->value
.iec958
.status
[1] = IEC958_AES1_CON_CATEGORY
|
1899 IEC958_AES1_CON_ORIGINAL
;
1903 static int snd_hda_spdif_pmask_get(struct snd_kcontrol
*kcontrol
,
1904 struct snd_ctl_elem_value
*ucontrol
)
1906 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
1907 IEC958_AES0_NONAUDIO
|
1908 IEC958_AES0_PRO_EMPHASIS_5015
;
1912 static int snd_hda_spdif_default_get(struct snd_kcontrol
*kcontrol
,
1913 struct snd_ctl_elem_value
*ucontrol
)
1915 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1917 ucontrol
->value
.iec958
.status
[0] = codec
->spdif_status
& 0xff;
1918 ucontrol
->value
.iec958
.status
[1] = (codec
->spdif_status
>> 8) & 0xff;
1919 ucontrol
->value
.iec958
.status
[2] = (codec
->spdif_status
>> 16) & 0xff;
1920 ucontrol
->value
.iec958
.status
[3] = (codec
->spdif_status
>> 24) & 0xff;
1925 /* convert from SPDIF status bits to HDA SPDIF bits
1926 * bit 0 (DigEn) is always set zero (to be filled later)
1928 static unsigned short convert_from_spdif_status(unsigned int sbits
)
1930 unsigned short val
= 0;
1932 if (sbits
& IEC958_AES0_PROFESSIONAL
)
1933 val
|= AC_DIG1_PROFESSIONAL
;
1934 if (sbits
& IEC958_AES0_NONAUDIO
)
1935 val
|= AC_DIG1_NONAUDIO
;
1936 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
1937 if ((sbits
& IEC958_AES0_PRO_EMPHASIS
) ==
1938 IEC958_AES0_PRO_EMPHASIS_5015
)
1939 val
|= AC_DIG1_EMPHASIS
;
1941 if ((sbits
& IEC958_AES0_CON_EMPHASIS
) ==
1942 IEC958_AES0_CON_EMPHASIS_5015
)
1943 val
|= AC_DIG1_EMPHASIS
;
1944 if (!(sbits
& IEC958_AES0_CON_NOT_COPYRIGHT
))
1945 val
|= AC_DIG1_COPYRIGHT
;
1946 if (sbits
& (IEC958_AES1_CON_ORIGINAL
<< 8))
1947 val
|= AC_DIG1_LEVEL
;
1948 val
|= sbits
& (IEC958_AES1_CON_CATEGORY
<< 8);
1953 /* convert to SPDIF status bits from HDA SPDIF bits
1955 static unsigned int convert_to_spdif_status(unsigned short val
)
1957 unsigned int sbits
= 0;
1959 if (val
& AC_DIG1_NONAUDIO
)
1960 sbits
|= IEC958_AES0_NONAUDIO
;
1961 if (val
& AC_DIG1_PROFESSIONAL
)
1962 sbits
|= IEC958_AES0_PROFESSIONAL
;
1963 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
1964 if (sbits
& AC_DIG1_EMPHASIS
)
1965 sbits
|= IEC958_AES0_PRO_EMPHASIS_5015
;
1967 if (val
& AC_DIG1_EMPHASIS
)
1968 sbits
|= IEC958_AES0_CON_EMPHASIS_5015
;
1969 if (!(val
& AC_DIG1_COPYRIGHT
))
1970 sbits
|= IEC958_AES0_CON_NOT_COPYRIGHT
;
1971 if (val
& AC_DIG1_LEVEL
)
1972 sbits
|= (IEC958_AES1_CON_ORIGINAL
<< 8);
1973 sbits
|= val
& (0x7f << 8);
1978 /* set digital convert verbs both for the given NID and its slaves */
1979 static void set_dig_out(struct hda_codec
*codec
, hda_nid_t nid
,
1984 snd_hda_codec_write_cache(codec
, nid
, 0, verb
, val
);
1985 d
= codec
->slave_dig_outs
;
1989 snd_hda_codec_write_cache(codec
, *d
, 0, verb
, val
);
1992 static inline void set_dig_out_convert(struct hda_codec
*codec
, hda_nid_t nid
,
1996 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_1
, dig1
);
1998 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_2
, dig2
);
2001 static int snd_hda_spdif_default_put(struct snd_kcontrol
*kcontrol
,
2002 struct snd_ctl_elem_value
*ucontrol
)
2004 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2005 hda_nid_t nid
= kcontrol
->private_value
;
2009 mutex_lock(&codec
->spdif_mutex
);
2010 codec
->spdif_status
= ucontrol
->value
.iec958
.status
[0] |
2011 ((unsigned int)ucontrol
->value
.iec958
.status
[1] << 8) |
2012 ((unsigned int)ucontrol
->value
.iec958
.status
[2] << 16) |
2013 ((unsigned int)ucontrol
->value
.iec958
.status
[3] << 24);
2014 val
= convert_from_spdif_status(codec
->spdif_status
);
2015 val
|= codec
->spdif_ctls
& 1;
2016 change
= codec
->spdif_ctls
!= val
;
2017 codec
->spdif_ctls
= val
;
2020 set_dig_out_convert(codec
, nid
, val
& 0xff, (val
>> 8) & 0xff);
2022 mutex_unlock(&codec
->spdif_mutex
);
2026 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2028 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol
*kcontrol
,
2029 struct snd_ctl_elem_value
*ucontrol
)
2031 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2033 ucontrol
->value
.integer
.value
[0] = codec
->spdif_ctls
& AC_DIG1_ENABLE
;
2037 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol
*kcontrol
,
2038 struct snd_ctl_elem_value
*ucontrol
)
2040 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2041 hda_nid_t nid
= kcontrol
->private_value
;
2045 mutex_lock(&codec
->spdif_mutex
);
2046 val
= codec
->spdif_ctls
& ~AC_DIG1_ENABLE
;
2047 if (ucontrol
->value
.integer
.value
[0])
2048 val
|= AC_DIG1_ENABLE
;
2049 change
= codec
->spdif_ctls
!= val
;
2051 codec
->spdif_ctls
= val
;
2052 set_dig_out_convert(codec
, nid
, val
& 0xff, -1);
2053 /* unmute amp switch (if any) */
2054 if ((get_wcaps(codec
, nid
) & AC_WCAP_OUT_AMP
) &&
2055 (val
& AC_DIG1_ENABLE
))
2056 snd_hda_codec_amp_stereo(codec
, nid
, HDA_OUTPUT
, 0,
2059 mutex_unlock(&codec
->spdif_mutex
);
2063 static struct snd_kcontrol_new dig_mixes
[] = {
2065 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2066 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2067 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,CON_MASK
),
2068 .info
= snd_hda_spdif_mask_info
,
2069 .get
= snd_hda_spdif_cmask_get
,
2072 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2073 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2074 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,PRO_MASK
),
2075 .info
= snd_hda_spdif_mask_info
,
2076 .get
= snd_hda_spdif_pmask_get
,
2079 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2080 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,DEFAULT
),
2081 .info
= snd_hda_spdif_mask_info
,
2082 .get
= snd_hda_spdif_default_get
,
2083 .put
= snd_hda_spdif_default_put
,
2086 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2087 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,SWITCH
),
2088 .info
= snd_hda_spdif_out_switch_info
,
2089 .get
= snd_hda_spdif_out_switch_get
,
2090 .put
= snd_hda_spdif_out_switch_put
,
2095 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2098 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2099 * @codec: the HDA codec
2100 * @nid: audio out widget NID
2102 * Creates controls related with the SPDIF output.
2103 * Called from each patch supporting the SPDIF out.
2105 * Returns 0 if successful, or a negative error code.
2107 int snd_hda_create_spdif_out_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
2110 struct snd_kcontrol
*kctl
;
2111 struct snd_kcontrol_new
*dig_mix
;
2114 for (idx
= 0; idx
< SPDIF_MAX_IDX
; idx
++) {
2115 if (!_snd_hda_find_mixer_ctl(codec
, "IEC958 Playback Switch",
2119 if (idx
>= SPDIF_MAX_IDX
) {
2120 printk(KERN_ERR
"hda_codec: too many IEC958 outputs\n");
2123 for (dig_mix
= dig_mixes
; dig_mix
->name
; dig_mix
++) {
2124 kctl
= snd_ctl_new1(dig_mix
, codec
);
2127 kctl
->id
.index
= idx
;
2128 kctl
->private_value
= nid
;
2129 err
= snd_hda_ctl_add(codec
, kctl
);
2134 snd_hda_codec_read(codec
, nid
, 0,
2135 AC_VERB_GET_DIGI_CONVERT_1
, 0);
2136 codec
->spdif_status
= convert_to_spdif_status(codec
->spdif_ctls
);
2139 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls
);
2142 * SPDIF sharing with analog output
2144 static int spdif_share_sw_get(struct snd_kcontrol
*kcontrol
,
2145 struct snd_ctl_elem_value
*ucontrol
)
2147 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
2148 ucontrol
->value
.integer
.value
[0] = mout
->share_spdif
;
2152 static int spdif_share_sw_put(struct snd_kcontrol
*kcontrol
,
2153 struct snd_ctl_elem_value
*ucontrol
)
2155 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
2156 mout
->share_spdif
= !!ucontrol
->value
.integer
.value
[0];
2160 static struct snd_kcontrol_new spdif_share_sw
= {
2161 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2162 .name
= "IEC958 Default PCM Playback Switch",
2163 .info
= snd_ctl_boolean_mono_info
,
2164 .get
= spdif_share_sw_get
,
2165 .put
= spdif_share_sw_put
,
2168 int snd_hda_create_spdif_share_sw(struct hda_codec
*codec
,
2169 struct hda_multi_out
*mout
)
2171 if (!mout
->dig_out_nid
)
2173 /* ATTENTION: here mout is passed as private_data, instead of codec */
2174 return snd_hda_ctl_add(codec
,
2175 snd_ctl_new1(&spdif_share_sw
, mout
));
2177 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw
);
2183 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2185 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol
*kcontrol
,
2186 struct snd_ctl_elem_value
*ucontrol
)
2188 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2190 ucontrol
->value
.integer
.value
[0] = codec
->spdif_in_enable
;
2194 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol
*kcontrol
,
2195 struct snd_ctl_elem_value
*ucontrol
)
2197 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2198 hda_nid_t nid
= kcontrol
->private_value
;
2199 unsigned int val
= !!ucontrol
->value
.integer
.value
[0];
2202 mutex_lock(&codec
->spdif_mutex
);
2203 change
= codec
->spdif_in_enable
!= val
;
2205 codec
->spdif_in_enable
= val
;
2206 snd_hda_codec_write_cache(codec
, nid
, 0,
2207 AC_VERB_SET_DIGI_CONVERT_1
, val
);
2209 mutex_unlock(&codec
->spdif_mutex
);
2213 static int snd_hda_spdif_in_status_get(struct snd_kcontrol
*kcontrol
,
2214 struct snd_ctl_elem_value
*ucontrol
)
2216 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2217 hda_nid_t nid
= kcontrol
->private_value
;
2221 val
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_DIGI_CONVERT_1
, 0);
2222 sbits
= convert_to_spdif_status(val
);
2223 ucontrol
->value
.iec958
.status
[0] = sbits
;
2224 ucontrol
->value
.iec958
.status
[1] = sbits
>> 8;
2225 ucontrol
->value
.iec958
.status
[2] = sbits
>> 16;
2226 ucontrol
->value
.iec958
.status
[3] = sbits
>> 24;
2230 static struct snd_kcontrol_new dig_in_ctls
[] = {
2232 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2233 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,SWITCH
),
2234 .info
= snd_hda_spdif_in_switch_info
,
2235 .get
= snd_hda_spdif_in_switch_get
,
2236 .put
= snd_hda_spdif_in_switch_put
,
2239 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2240 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2241 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,DEFAULT
),
2242 .info
= snd_hda_spdif_mask_info
,
2243 .get
= snd_hda_spdif_in_status_get
,
2249 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2250 * @codec: the HDA codec
2251 * @nid: audio in widget NID
2253 * Creates controls related with the SPDIF input.
2254 * Called from each patch supporting the SPDIF in.
2256 * Returns 0 if successful, or a negative error code.
2258 int snd_hda_create_spdif_in_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
2261 struct snd_kcontrol
*kctl
;
2262 struct snd_kcontrol_new
*dig_mix
;
2265 for (idx
= 0; idx
< SPDIF_MAX_IDX
; idx
++) {
2266 if (!_snd_hda_find_mixer_ctl(codec
, "IEC958 Capture Switch",
2270 if (idx
>= SPDIF_MAX_IDX
) {
2271 printk(KERN_ERR
"hda_codec: too many IEC958 inputs\n");
2274 for (dig_mix
= dig_in_ctls
; dig_mix
->name
; dig_mix
++) {
2275 kctl
= snd_ctl_new1(dig_mix
, codec
);
2278 kctl
->private_value
= nid
;
2279 err
= snd_hda_ctl_add(codec
, kctl
);
2283 codec
->spdif_in_enable
=
2284 snd_hda_codec_read(codec
, nid
, 0,
2285 AC_VERB_GET_DIGI_CONVERT_1
, 0) &
2289 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls
);
2291 #ifdef SND_HDA_NEEDS_RESUME
2296 /* build a 32bit cache key with the widget id and the command parameter */
2297 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2298 #define get_cmd_cache_nid(key) ((key) & 0xff)
2299 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2302 * snd_hda_codec_write_cache - send a single command with caching
2303 * @codec: the HDA codec
2304 * @nid: NID to send the command
2305 * @direct: direct flag
2306 * @verb: the verb to send
2307 * @parm: the parameter for the verb
2309 * Send a single command without waiting for response.
2311 * Returns 0 if successful, or a negative error code.
2313 int snd_hda_codec_write_cache(struct hda_codec
*codec
, hda_nid_t nid
,
2314 int direct
, unsigned int verb
, unsigned int parm
)
2316 int err
= snd_hda_codec_write(codec
, nid
, direct
, verb
, parm
);
2317 struct hda_cache_head
*c
;
2322 /* parm may contain the verb stuff for get/set amp */
2323 verb
= verb
| (parm
>> 8);
2325 key
= build_cmd_cache_key(nid
, verb
);
2326 mutex_lock(&codec
->bus
->cmd_mutex
);
2327 c
= get_alloc_hash(&codec
->cmd_cache
, key
);
2330 mutex_unlock(&codec
->bus
->cmd_mutex
);
2333 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache
);
2335 /* resume the all commands from the cache */
2336 void snd_hda_codec_resume_cache(struct hda_codec
*codec
)
2338 struct hda_cache_head
*buffer
= codec
->cmd_cache
.buf
.list
;
2341 for (i
= 0; i
< codec
->cmd_cache
.buf
.used
; i
++, buffer
++) {
2342 u32 key
= buffer
->key
;
2345 snd_hda_codec_write(codec
, get_cmd_cache_nid(key
), 0,
2346 get_cmd_cache_cmd(key
), buffer
->val
);
2349 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache
);
2352 * snd_hda_sequence_write_cache - sequence writes with caching
2353 * @codec: the HDA codec
2354 * @seq: VERB array to send
2356 * Send the commands sequentially from the given array.
2357 * Thte commands are recorded on cache for power-save and resume.
2358 * The array must be terminated with NID=0.
2360 void snd_hda_sequence_write_cache(struct hda_codec
*codec
,
2361 const struct hda_verb
*seq
)
2363 for (; seq
->nid
; seq
++)
2364 snd_hda_codec_write_cache(codec
, seq
->nid
, 0, seq
->verb
,
2367 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache
);
2368 #endif /* SND_HDA_NEEDS_RESUME */
2371 * set power state of the codec
2373 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
2374 unsigned int power_state
)
2379 /* this delay seems necessary to avoid click noise at power-down */
2380 if (power_state
== AC_PWRST_D3
)
2382 snd_hda_codec_read(codec
, fg
, 0, AC_VERB_SET_POWER_STATE
,
2384 /* partial workaround for "azx_get_response timeout" */
2385 if (power_state
== AC_PWRST_D0
)
2388 nid
= codec
->start_nid
;
2389 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
2390 unsigned int wcaps
= get_wcaps(codec
, nid
);
2391 if (wcaps
& AC_WCAP_POWER
) {
2392 unsigned int wid_type
= get_wcaps_type(wcaps
);
2393 if (power_state
== AC_PWRST_D3
&&
2394 wid_type
== AC_WID_PIN
) {
2395 unsigned int pincap
;
2397 * don't power down the widget if it controls
2398 * eapd and EAPD_BTLENABLE is set.
2400 pincap
= snd_hda_query_pin_caps(codec
, nid
);
2401 if (pincap
& AC_PINCAP_EAPD
) {
2402 int eapd
= snd_hda_codec_read(codec
,
2404 AC_VERB_GET_EAPD_BTLENABLE
, 0);
2410 snd_hda_codec_write(codec
, nid
, 0,
2411 AC_VERB_SET_POWER_STATE
,
2416 if (power_state
== AC_PWRST_D0
) {
2417 unsigned long end_time
;
2420 /* wait until the codec reachs to D0 */
2421 end_time
= jiffies
+ msecs_to_jiffies(500);
2423 state
= snd_hda_codec_read(codec
, fg
, 0,
2424 AC_VERB_GET_POWER_STATE
, 0);
2425 if (state
== power_state
)
2428 } while (time_after_eq(end_time
, jiffies
));
2432 #ifdef CONFIG_SND_HDA_HWDEP
2433 /* execute additional init verbs */
2434 static void hda_exec_init_verbs(struct hda_codec
*codec
)
2436 if (codec
->init_verbs
.list
)
2437 snd_hda_sequence_write(codec
, codec
->init_verbs
.list
);
2440 static inline void hda_exec_init_verbs(struct hda_codec
*codec
) {}
2443 #ifdef SND_HDA_NEEDS_RESUME
2445 * call suspend and power-down; used both from PM and power-save
2447 static void hda_call_codec_suspend(struct hda_codec
*codec
)
2449 if (codec
->patch_ops
.suspend
)
2450 codec
->patch_ops
.suspend(codec
, PMSG_SUSPEND
);
2451 hda_set_power_state(codec
,
2452 codec
->afg
? codec
->afg
: codec
->mfg
,
2454 #ifdef CONFIG_SND_HDA_POWER_SAVE
2455 cancel_delayed_work(&codec
->power_work
);
2456 codec
->power_on
= 0;
2457 codec
->power_transition
= 0;
2462 * kick up codec; used both from PM and power-save
2464 static void hda_call_codec_resume(struct hda_codec
*codec
)
2466 hda_set_power_state(codec
,
2467 codec
->afg
? codec
->afg
: codec
->mfg
,
2469 restore_pincfgs(codec
); /* restore all current pin configs */
2470 hda_exec_init_verbs(codec
);
2471 if (codec
->patch_ops
.resume
)
2472 codec
->patch_ops
.resume(codec
);
2474 if (codec
->patch_ops
.init
)
2475 codec
->patch_ops
.init(codec
);
2476 snd_hda_codec_resume_amp(codec
);
2477 snd_hda_codec_resume_cache(codec
);
2480 #endif /* SND_HDA_NEEDS_RESUME */
2484 * snd_hda_build_controls - build mixer controls
2487 * Creates mixer controls for each codec included in the bus.
2489 * Returns 0 if successful, otherwise a negative error code.
2491 int /*__devinit*/ snd_hda_build_controls(struct hda_bus
*bus
)
2493 struct hda_codec
*codec
;
2495 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
2496 int err
= snd_hda_codec_build_controls(codec
);
2498 printk(KERN_ERR
"hda_codec: cannot build controls"
2499 "for #%d (error %d)\n", codec
->addr
, err
);
2500 err
= snd_hda_codec_reset(codec
);
2503 "hda_codec: cannot revert codec\n");
2510 EXPORT_SYMBOL_HDA(snd_hda_build_controls
);
2512 int snd_hda_codec_build_controls(struct hda_codec
*codec
)
2515 hda_exec_init_verbs(codec
);
2516 /* continue to initialize... */
2517 if (codec
->patch_ops
.init
)
2518 err
= codec
->patch_ops
.init(codec
);
2519 if (!err
&& codec
->patch_ops
.build_controls
)
2520 err
= codec
->patch_ops
.build_controls(codec
);
2529 struct hda_rate_tbl
{
2531 unsigned int alsa_bits
;
2532 unsigned int hda_fmt
;
2535 static struct hda_rate_tbl rate_bits
[] = {
2536 /* rate in Hz, ALSA rate bitmask, HDA format value */
2538 /* autodetected value used in snd_hda_query_supported_pcm */
2539 { 8000, SNDRV_PCM_RATE_8000
, 0x0500 }, /* 1/6 x 48 */
2540 { 11025, SNDRV_PCM_RATE_11025
, 0x4300 }, /* 1/4 x 44 */
2541 { 16000, SNDRV_PCM_RATE_16000
, 0x0200 }, /* 1/3 x 48 */
2542 { 22050, SNDRV_PCM_RATE_22050
, 0x4100 }, /* 1/2 x 44 */
2543 { 32000, SNDRV_PCM_RATE_32000
, 0x0a00 }, /* 2/3 x 48 */
2544 { 44100, SNDRV_PCM_RATE_44100
, 0x4000 }, /* 44 */
2545 { 48000, SNDRV_PCM_RATE_48000
, 0x0000 }, /* 48 */
2546 { 88200, SNDRV_PCM_RATE_88200
, 0x4800 }, /* 2 x 44 */
2547 { 96000, SNDRV_PCM_RATE_96000
, 0x0800 }, /* 2 x 48 */
2548 { 176400, SNDRV_PCM_RATE_176400
, 0x5800 },/* 4 x 44 */
2549 { 192000, SNDRV_PCM_RATE_192000
, 0x1800 }, /* 4 x 48 */
2550 #define AC_PAR_PCM_RATE_BITS 11
2551 /* up to bits 10, 384kHZ isn't supported properly */
2553 /* not autodetected value */
2554 { 9600, SNDRV_PCM_RATE_KNOT
, 0x0400 }, /* 1/5 x 48 */
2556 { 0 } /* terminator */
2560 * snd_hda_calc_stream_format - calculate format bitset
2561 * @rate: the sample rate
2562 * @channels: the number of channels
2563 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2564 * @maxbps: the max. bps
2566 * Calculate the format bitset from the given rate, channels and th PCM format.
2568 * Return zero if invalid.
2570 unsigned int snd_hda_calc_stream_format(unsigned int rate
,
2571 unsigned int channels
,
2572 unsigned int format
,
2573 unsigned int maxbps
)
2576 unsigned int val
= 0;
2578 for (i
= 0; rate_bits
[i
].hz
; i
++)
2579 if (rate_bits
[i
].hz
== rate
) {
2580 val
= rate_bits
[i
].hda_fmt
;
2583 if (!rate_bits
[i
].hz
) {
2584 snd_printdd("invalid rate %d\n", rate
);
2588 if (channels
== 0 || channels
> 8) {
2589 snd_printdd("invalid channels %d\n", channels
);
2592 val
|= channels
- 1;
2594 switch (snd_pcm_format_width(format
)) {
2595 case 8: val
|= 0x00; break;
2596 case 16: val
|= 0x10; break;
2600 if (maxbps
>= 32 || format
== SNDRV_PCM_FORMAT_FLOAT_LE
)
2602 else if (maxbps
>= 24)
2608 snd_printdd("invalid format width %d\n",
2609 snd_pcm_format_width(format
));
2615 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format
);
2617 static unsigned int get_pcm_param(struct hda_codec
*codec
, hda_nid_t nid
)
2619 unsigned int val
= 0;
2620 if (nid
!= codec
->afg
&&
2621 (get_wcaps(codec
, nid
) & AC_WCAP_FORMAT_OVRD
))
2622 val
= snd_hda_param_read(codec
, nid
, AC_PAR_PCM
);
2623 if (!val
|| val
== -1)
2624 val
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_PCM
);
2625 if (!val
|| val
== -1)
2630 static unsigned int query_pcm_param(struct hda_codec
*codec
, hda_nid_t nid
)
2632 return query_caps_hash(codec
, nid
, HDA_HASH_PARPCM_KEY(nid
),
2636 static unsigned int get_stream_param(struct hda_codec
*codec
, hda_nid_t nid
)
2638 unsigned int streams
= snd_hda_param_read(codec
, nid
, AC_PAR_STREAM
);
2639 if (!streams
|| streams
== -1)
2640 streams
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_STREAM
);
2641 if (!streams
|| streams
== -1)
2646 static unsigned int query_stream_param(struct hda_codec
*codec
, hda_nid_t nid
)
2648 return query_caps_hash(codec
, nid
, HDA_HASH_PARSTR_KEY(nid
),
2653 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2654 * @codec: the HDA codec
2655 * @nid: NID to query
2656 * @ratesp: the pointer to store the detected rate bitflags
2657 * @formatsp: the pointer to store the detected formats
2658 * @bpsp: the pointer to store the detected format widths
2660 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2661 * or @bsps argument is ignored.
2663 * Returns 0 if successful, otherwise a negative error code.
2665 static int snd_hda_query_supported_pcm(struct hda_codec
*codec
, hda_nid_t nid
,
2666 u32
*ratesp
, u64
*formatsp
, unsigned int *bpsp
)
2668 unsigned int i
, val
, wcaps
;
2670 wcaps
= get_wcaps(codec
, nid
);
2671 val
= query_pcm_param(codec
, nid
);
2675 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++) {
2677 rates
|= rate_bits
[i
].alsa_bits
;
2680 snd_printk(KERN_ERR
"hda_codec: rates == 0 "
2681 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2683 (wcaps
& AC_WCAP_FORMAT_OVRD
) ? 1 : 0);
2689 if (formatsp
|| bpsp
) {
2691 unsigned int streams
, bps
;
2693 streams
= query_stream_param(codec
, nid
);
2698 if (streams
& AC_SUPFMT_PCM
) {
2699 if (val
& AC_SUPPCM_BITS_8
) {
2700 formats
|= SNDRV_PCM_FMTBIT_U8
;
2703 if (val
& AC_SUPPCM_BITS_16
) {
2704 formats
|= SNDRV_PCM_FMTBIT_S16_LE
;
2707 if (wcaps
& AC_WCAP_DIGITAL
) {
2708 if (val
& AC_SUPPCM_BITS_32
)
2709 formats
|= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
;
2710 if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
))
2711 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
2712 if (val
& AC_SUPPCM_BITS_24
)
2714 else if (val
& AC_SUPPCM_BITS_20
)
2716 } else if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
|
2717 AC_SUPPCM_BITS_32
)) {
2718 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
2719 if (val
& AC_SUPPCM_BITS_32
)
2721 else if (val
& AC_SUPPCM_BITS_24
)
2723 else if (val
& AC_SUPPCM_BITS_20
)
2727 if (streams
& AC_SUPFMT_FLOAT32
) {
2728 formats
|= SNDRV_PCM_FMTBIT_FLOAT_LE
;
2732 if (streams
== AC_SUPFMT_AC3
) {
2733 /* should be exclusive */
2734 /* temporary hack: we have still no proper support
2735 * for the direct AC3 stream...
2737 formats
|= SNDRV_PCM_FMTBIT_U8
;
2741 snd_printk(KERN_ERR
"hda_codec: formats == 0 "
2742 "(nid=0x%x, val=0x%x, ovrd=%i, "
2745 (wcaps
& AC_WCAP_FORMAT_OVRD
) ? 1 : 0,
2750 *formatsp
= formats
;
2759 * snd_hda_is_supported_format - check whether the given node supports
2762 * Returns 1 if supported, 0 if not.
2764 int snd_hda_is_supported_format(struct hda_codec
*codec
, hda_nid_t nid
,
2765 unsigned int format
)
2768 unsigned int val
= 0, rate
, stream
;
2770 val
= query_pcm_param(codec
, nid
);
2774 rate
= format
& 0xff00;
2775 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++)
2776 if (rate_bits
[i
].hda_fmt
== rate
) {
2781 if (i
>= AC_PAR_PCM_RATE_BITS
)
2784 stream
= query_stream_param(codec
, nid
);
2788 if (stream
& AC_SUPFMT_PCM
) {
2789 switch (format
& 0xf0) {
2791 if (!(val
& AC_SUPPCM_BITS_8
))
2795 if (!(val
& AC_SUPPCM_BITS_16
))
2799 if (!(val
& AC_SUPPCM_BITS_20
))
2803 if (!(val
& AC_SUPPCM_BITS_24
))
2807 if (!(val
& AC_SUPPCM_BITS_32
))
2814 /* FIXME: check for float32 and AC3? */
2819 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format
);
2824 static int hda_pcm_default_open_close(struct hda_pcm_stream
*hinfo
,
2825 struct hda_codec
*codec
,
2826 struct snd_pcm_substream
*substream
)
2831 static int hda_pcm_default_prepare(struct hda_pcm_stream
*hinfo
,
2832 struct hda_codec
*codec
,
2833 unsigned int stream_tag
,
2834 unsigned int format
,
2835 struct snd_pcm_substream
*substream
)
2837 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, stream_tag
, 0, format
);
2841 static int hda_pcm_default_cleanup(struct hda_pcm_stream
*hinfo
,
2842 struct hda_codec
*codec
,
2843 struct snd_pcm_substream
*substream
)
2845 snd_hda_codec_cleanup_stream(codec
, hinfo
->nid
);
2849 static int set_pcm_default_values(struct hda_codec
*codec
,
2850 struct hda_pcm_stream
*info
)
2854 /* query support PCM information from the given NID */
2855 if (info
->nid
&& (!info
->rates
|| !info
->formats
)) {
2856 err
= snd_hda_query_supported_pcm(codec
, info
->nid
,
2857 info
->rates
? NULL
: &info
->rates
,
2858 info
->formats
? NULL
: &info
->formats
,
2859 info
->maxbps
? NULL
: &info
->maxbps
);
2863 if (info
->ops
.open
== NULL
)
2864 info
->ops
.open
= hda_pcm_default_open_close
;
2865 if (info
->ops
.close
== NULL
)
2866 info
->ops
.close
= hda_pcm_default_open_close
;
2867 if (info
->ops
.prepare
== NULL
) {
2868 if (snd_BUG_ON(!info
->nid
))
2870 info
->ops
.prepare
= hda_pcm_default_prepare
;
2872 if (info
->ops
.cleanup
== NULL
) {
2873 if (snd_BUG_ON(!info
->nid
))
2875 info
->ops
.cleanup
= hda_pcm_default_cleanup
;
2880 const char *snd_hda_pcm_type_name
[HDA_PCM_NTYPES
] = {
2881 "Audio", "SPDIF", "HDMI", "Modem"
2885 * get the empty PCM device number to assign
2887 static int get_empty_pcm_device(struct hda_bus
*bus
, int type
)
2889 /* audio device indices; not linear to keep compatibility */
2890 static int audio_idx
[HDA_PCM_NTYPES
][5] = {
2891 [HDA_PCM_TYPE_AUDIO
] = { 0, 2, 4, 5, -1 },
2892 [HDA_PCM_TYPE_SPDIF
] = { 1, -1 },
2893 [HDA_PCM_TYPE_HDMI
] = { 3, 7, 8, 9, -1 },
2894 [HDA_PCM_TYPE_MODEM
] = { 6, -1 },
2898 if (type
>= HDA_PCM_NTYPES
) {
2899 snd_printk(KERN_WARNING
"Invalid PCM type %d\n", type
);
2903 for (i
= 0; audio_idx
[type
][i
] >= 0 ; i
++)
2904 if (!test_and_set_bit(audio_idx
[type
][i
], bus
->pcm_dev_bits
))
2905 return audio_idx
[type
][i
];
2907 snd_printk(KERN_WARNING
"Too many %s devices\n", snd_hda_pcm_type_name
[type
]);
2912 * attach a new PCM stream
2914 static int snd_hda_attach_pcm(struct hda_codec
*codec
, struct hda_pcm
*pcm
)
2916 struct hda_bus
*bus
= codec
->bus
;
2917 struct hda_pcm_stream
*info
;
2920 if (snd_BUG_ON(!pcm
->name
))
2922 for (stream
= 0; stream
< 2; stream
++) {
2923 info
= &pcm
->stream
[stream
];
2924 if (info
->substreams
) {
2925 err
= set_pcm_default_values(codec
, info
);
2930 return bus
->ops
.attach_pcm(bus
, codec
, pcm
);
2933 /* assign all PCMs of the given codec */
2934 int snd_hda_codec_build_pcms(struct hda_codec
*codec
)
2939 if (!codec
->num_pcms
) {
2940 if (!codec
->patch_ops
.build_pcms
)
2942 err
= codec
->patch_ops
.build_pcms(codec
);
2944 printk(KERN_ERR
"hda_codec: cannot build PCMs"
2945 "for #%d (error %d)\n", codec
->addr
, err
);
2946 err
= snd_hda_codec_reset(codec
);
2949 "hda_codec: cannot revert codec\n");
2954 for (pcm
= 0; pcm
< codec
->num_pcms
; pcm
++) {
2955 struct hda_pcm
*cpcm
= &codec
->pcm_info
[pcm
];
2958 if (!cpcm
->stream
[0].substreams
&& !cpcm
->stream
[1].substreams
)
2959 continue; /* no substreams assigned */
2962 dev
= get_empty_pcm_device(codec
->bus
, cpcm
->pcm_type
);
2964 continue; /* no fatal error */
2966 err
= snd_hda_attach_pcm(codec
, cpcm
);
2968 printk(KERN_ERR
"hda_codec: cannot attach "
2969 "PCM stream %d for codec #%d\n",
2971 continue; /* no fatal error */
2979 * snd_hda_build_pcms - build PCM information
2982 * Create PCM information for each codec included in the bus.
2984 * The build_pcms codec patch is requested to set up codec->num_pcms and
2985 * codec->pcm_info properly. The array is referred by the top-level driver
2986 * to create its PCM instances.
2987 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2990 * At least, substreams, channels_min and channels_max must be filled for
2991 * each stream. substreams = 0 indicates that the stream doesn't exist.
2992 * When rates and/or formats are zero, the supported values are queried
2993 * from the given nid. The nid is used also by the default ops.prepare
2994 * and ops.cleanup callbacks.
2996 * The driver needs to call ops.open in its open callback. Similarly,
2997 * ops.close is supposed to be called in the close callback.
2998 * ops.prepare should be called in the prepare or hw_params callback
2999 * with the proper parameters for set up.
3000 * ops.cleanup should be called in hw_free for clean up of streams.
3002 * This function returns 0 if successfull, or a negative error code.
3004 int __devinit
snd_hda_build_pcms(struct hda_bus
*bus
)
3006 struct hda_codec
*codec
;
3008 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3009 int err
= snd_hda_codec_build_pcms(codec
);
3015 EXPORT_SYMBOL_HDA(snd_hda_build_pcms
);
3018 * snd_hda_check_board_config - compare the current codec with the config table
3019 * @codec: the HDA codec
3020 * @num_configs: number of config enums
3021 * @models: array of model name strings
3022 * @tbl: configuration table, terminated by null entries
3024 * Compares the modelname or PCI subsystem id of the current codec with the
3025 * given configuration table. If a matching entry is found, returns its
3026 * config value (supposed to be 0 or positive).
3028 * If no entries are matching, the function returns a negative value.
3030 int snd_hda_check_board_config(struct hda_codec
*codec
,
3031 int num_configs
, const char **models
,
3032 const struct snd_pci_quirk
*tbl
)
3034 if (codec
->modelname
&& models
) {
3036 for (i
= 0; i
< num_configs
; i
++) {
3038 !strcmp(codec
->modelname
, models
[i
])) {
3039 snd_printd(KERN_INFO
"hda_codec: model '%s' is "
3040 "selected\n", models
[i
]);
3046 if (!codec
->bus
->pci
|| !tbl
)
3049 tbl
= snd_pci_quirk_lookup(codec
->bus
->pci
, tbl
);
3052 if (tbl
->value
>= 0 && tbl
->value
< num_configs
) {
3053 #ifdef CONFIG_SND_DEBUG_VERBOSE
3055 const char *model
= NULL
;
3057 model
= models
[tbl
->value
];
3059 sprintf(tmp
, "#%d", tbl
->value
);
3062 snd_printdd(KERN_INFO
"hda_codec: model '%s' is selected "
3063 "for config %x:%x (%s)\n",
3064 model
, tbl
->subvendor
, tbl
->subdevice
,
3065 (tbl
->name
? tbl
->name
: "Unknown device"));
3071 EXPORT_SYMBOL_HDA(snd_hda_check_board_config
);
3074 * snd_hda_check_board_codec_sid_config - compare the current codec
3075 subsystem ID with the
3078 This is important for Gateway notebooks with SB450 HDA Audio
3079 where the vendor ID of the PCI device is:
3080 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3081 and the vendor/subvendor are found only at the codec.
3083 * @codec: the HDA codec
3084 * @num_configs: number of config enums
3085 * @models: array of model name strings
3086 * @tbl: configuration table, terminated by null entries
3088 * Compares the modelname or PCI subsystem id of the current codec with the
3089 * given configuration table. If a matching entry is found, returns its
3090 * config value (supposed to be 0 or positive).
3092 * If no entries are matching, the function returns a negative value.
3094 int snd_hda_check_board_codec_sid_config(struct hda_codec
*codec
,
3095 int num_configs
, const char **models
,
3096 const struct snd_pci_quirk
*tbl
)
3098 const struct snd_pci_quirk
*q
;
3100 /* Search for codec ID */
3101 for (q
= tbl
; q
->subvendor
; q
++) {
3102 unsigned long vendorid
= (q
->subdevice
) | (q
->subvendor
<< 16);
3104 if (vendorid
== codec
->subsystem_id
)
3113 if (tbl
->value
>= 0 && tbl
->value
< num_configs
) {
3114 #ifdef CONFIG_SND_DEBUG_VERBOSE
3116 const char *model
= NULL
;
3118 model
= models
[tbl
->value
];
3120 sprintf(tmp
, "#%d", tbl
->value
);
3123 snd_printdd(KERN_INFO
"hda_codec: model '%s' is selected "
3124 "for config %x:%x (%s)\n",
3125 model
, tbl
->subvendor
, tbl
->subdevice
,
3126 (tbl
->name
? tbl
->name
: "Unknown device"));
3132 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config
);
3135 * snd_hda_add_new_ctls - create controls from the array
3136 * @codec: the HDA codec
3137 * @knew: the array of struct snd_kcontrol_new
3139 * This helper function creates and add new controls in the given array.
3140 * The array must be terminated with an empty entry as terminator.
3142 * Returns 0 if successful, or a negative error code.
3144 int snd_hda_add_new_ctls(struct hda_codec
*codec
, struct snd_kcontrol_new
*knew
)
3148 for (; knew
->name
; knew
++) {
3149 struct snd_kcontrol
*kctl
;
3150 kctl
= snd_ctl_new1(knew
, codec
);
3153 err
= snd_hda_ctl_add(codec
, kctl
);
3157 kctl
= snd_ctl_new1(knew
, codec
);
3160 kctl
->id
.device
= codec
->addr
;
3161 err
= snd_hda_ctl_add(codec
, kctl
);
3168 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls
);
3170 #ifdef CONFIG_SND_HDA_POWER_SAVE
3171 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
3172 unsigned int power_state
);
3174 static void hda_power_work(struct work_struct
*work
)
3176 struct hda_codec
*codec
=
3177 container_of(work
, struct hda_codec
, power_work
.work
);
3178 struct hda_bus
*bus
= codec
->bus
;
3180 if (!codec
->power_on
|| codec
->power_count
) {
3181 codec
->power_transition
= 0;
3185 hda_call_codec_suspend(codec
);
3186 if (bus
->ops
.pm_notify
)
3187 bus
->ops
.pm_notify(bus
);
3190 static void hda_keep_power_on(struct hda_codec
*codec
)
3192 codec
->power_count
++;
3193 codec
->power_on
= 1;
3196 void snd_hda_power_up(struct hda_codec
*codec
)
3198 struct hda_bus
*bus
= codec
->bus
;
3200 codec
->power_count
++;
3201 if (codec
->power_on
|| codec
->power_transition
)
3204 codec
->power_on
= 1;
3205 if (bus
->ops
.pm_notify
)
3206 bus
->ops
.pm_notify(bus
);
3207 hda_call_codec_resume(codec
);
3208 cancel_delayed_work(&codec
->power_work
);
3209 codec
->power_transition
= 0;
3211 EXPORT_SYMBOL_HDA(snd_hda_power_up
);
3213 #define power_save(codec) \
3214 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3216 #define power_save(codec) \
3217 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3219 void snd_hda_power_down(struct hda_codec
*codec
)
3221 --codec
->power_count
;
3222 if (!codec
->power_on
|| codec
->power_count
|| codec
->power_transition
)
3224 if (power_save(codec
)) {
3225 codec
->power_transition
= 1; /* avoid reentrance */
3226 queue_delayed_work(codec
->bus
->workq
, &codec
->power_work
,
3227 msecs_to_jiffies(power_save(codec
) * 1000));
3230 EXPORT_SYMBOL_HDA(snd_hda_power_down
);
3232 int snd_hda_check_amp_list_power(struct hda_codec
*codec
,
3233 struct hda_loopback_check
*check
,
3236 struct hda_amp_list
*p
;
3239 if (!check
->amplist
)
3241 for (p
= check
->amplist
; p
->nid
; p
++) {
3246 return 0; /* nothing changed */
3248 for (p
= check
->amplist
; p
->nid
; p
++) {
3249 for (ch
= 0; ch
< 2; ch
++) {
3250 v
= snd_hda_codec_amp_read(codec
, p
->nid
, ch
, p
->dir
,
3252 if (!(v
& HDA_AMP_MUTE
) && v
> 0) {
3253 if (!check
->power_on
) {
3254 check
->power_on
= 1;
3255 snd_hda_power_up(codec
);
3261 if (check
->power_on
) {
3262 check
->power_on
= 0;
3263 snd_hda_power_down(codec
);
3267 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power
);
3271 * Channel mode helper
3273 int snd_hda_ch_mode_info(struct hda_codec
*codec
,
3274 struct snd_ctl_elem_info
*uinfo
,
3275 const struct hda_channel_mode
*chmode
,
3278 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
3280 uinfo
->value
.enumerated
.items
= num_chmodes
;
3281 if (uinfo
->value
.enumerated
.item
>= num_chmodes
)
3282 uinfo
->value
.enumerated
.item
= num_chmodes
- 1;
3283 sprintf(uinfo
->value
.enumerated
.name
, "%dch",
3284 chmode
[uinfo
->value
.enumerated
.item
].channels
);
3287 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info
);
3289 int snd_hda_ch_mode_get(struct hda_codec
*codec
,
3290 struct snd_ctl_elem_value
*ucontrol
,
3291 const struct hda_channel_mode
*chmode
,
3297 for (i
= 0; i
< num_chmodes
; i
++) {
3298 if (max_channels
== chmode
[i
].channels
) {
3299 ucontrol
->value
.enumerated
.item
[0] = i
;
3305 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get
);
3307 int snd_hda_ch_mode_put(struct hda_codec
*codec
,
3308 struct snd_ctl_elem_value
*ucontrol
,
3309 const struct hda_channel_mode
*chmode
,
3315 mode
= ucontrol
->value
.enumerated
.item
[0];
3316 if (mode
>= num_chmodes
)
3318 if (*max_channelsp
== chmode
[mode
].channels
)
3320 /* change the current channel setting */
3321 *max_channelsp
= chmode
[mode
].channels
;
3322 if (chmode
[mode
].sequence
)
3323 snd_hda_sequence_write_cache(codec
, chmode
[mode
].sequence
);
3326 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put
);
3331 int snd_hda_input_mux_info(const struct hda_input_mux
*imux
,
3332 struct snd_ctl_elem_info
*uinfo
)
3336 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
3338 uinfo
->value
.enumerated
.items
= imux
->num_items
;
3339 if (!imux
->num_items
)
3341 index
= uinfo
->value
.enumerated
.item
;
3342 if (index
>= imux
->num_items
)
3343 index
= imux
->num_items
- 1;
3344 strcpy(uinfo
->value
.enumerated
.name
, imux
->items
[index
].label
);
3347 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info
);
3349 int snd_hda_input_mux_put(struct hda_codec
*codec
,
3350 const struct hda_input_mux
*imux
,
3351 struct snd_ctl_elem_value
*ucontrol
,
3353 unsigned int *cur_val
)
3357 if (!imux
->num_items
)
3359 idx
= ucontrol
->value
.enumerated
.item
[0];
3360 if (idx
>= imux
->num_items
)
3361 idx
= imux
->num_items
- 1;
3362 if (*cur_val
== idx
)
3364 snd_hda_codec_write_cache(codec
, nid
, 0, AC_VERB_SET_CONNECT_SEL
,
3365 imux
->items
[idx
].index
);
3369 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put
);
3373 * Multi-channel / digital-out PCM helper functions
3376 /* setup SPDIF output stream */
3377 static void setup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
,
3378 unsigned int stream_tag
, unsigned int format
)
3380 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3381 if (codec
->spdif_status_reset
&& (codec
->spdif_ctls
& AC_DIG1_ENABLE
))
3382 set_dig_out_convert(codec
, nid
,
3383 codec
->spdif_ctls
& ~AC_DIG1_ENABLE
& 0xff,
3385 snd_hda_codec_setup_stream(codec
, nid
, stream_tag
, 0, format
);
3386 if (codec
->slave_dig_outs
) {
3388 for (d
= codec
->slave_dig_outs
; *d
; d
++)
3389 snd_hda_codec_setup_stream(codec
, *d
, stream_tag
, 0,
3392 /* turn on again (if needed) */
3393 if (codec
->spdif_status_reset
&& (codec
->spdif_ctls
& AC_DIG1_ENABLE
))
3394 set_dig_out_convert(codec
, nid
,
3395 codec
->spdif_ctls
& 0xff, -1);
3398 static void cleanup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
)
3400 snd_hda_codec_cleanup_stream(codec
, nid
);
3401 if (codec
->slave_dig_outs
) {
3403 for (d
= codec
->slave_dig_outs
; *d
; d
++)
3404 snd_hda_codec_cleanup_stream(codec
, *d
);
3408 /* call each reboot notifier */
3409 void snd_hda_bus_reboot_notify(struct hda_bus
*bus
)
3411 struct hda_codec
*codec
;
3415 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3416 #ifdef CONFIG_SND_HDA_POWER_SAVE
3417 if (!codec
->power_on
)
3420 if (codec
->patch_ops
.reboot_notify
)
3421 codec
->patch_ops
.reboot_notify(codec
);
3426 * open the digital out in the exclusive mode
3428 int snd_hda_multi_out_dig_open(struct hda_codec
*codec
,
3429 struct hda_multi_out
*mout
)
3431 mutex_lock(&codec
->spdif_mutex
);
3432 if (mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
)
3433 /* already opened as analog dup; reset it once */
3434 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
3435 mout
->dig_out_used
= HDA_DIG_EXCLUSIVE
;
3436 mutex_unlock(&codec
->spdif_mutex
);
3439 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open
);
3441 int snd_hda_multi_out_dig_prepare(struct hda_codec
*codec
,
3442 struct hda_multi_out
*mout
,
3443 unsigned int stream_tag
,
3444 unsigned int format
,
3445 struct snd_pcm_substream
*substream
)
3447 mutex_lock(&codec
->spdif_mutex
);
3448 setup_dig_out_stream(codec
, mout
->dig_out_nid
, stream_tag
, format
);
3449 mutex_unlock(&codec
->spdif_mutex
);
3452 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare
);
3454 int snd_hda_multi_out_dig_cleanup(struct hda_codec
*codec
,
3455 struct hda_multi_out
*mout
)
3457 mutex_lock(&codec
->spdif_mutex
);
3458 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
3459 mutex_unlock(&codec
->spdif_mutex
);
3462 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup
);
3465 * release the digital out
3467 int snd_hda_multi_out_dig_close(struct hda_codec
*codec
,
3468 struct hda_multi_out
*mout
)
3470 mutex_lock(&codec
->spdif_mutex
);
3471 mout
->dig_out_used
= 0;
3472 mutex_unlock(&codec
->spdif_mutex
);
3475 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close
);
3478 * set up more restrictions for analog out
3480 int snd_hda_multi_out_analog_open(struct hda_codec
*codec
,
3481 struct hda_multi_out
*mout
,
3482 struct snd_pcm_substream
*substream
,
3483 struct hda_pcm_stream
*hinfo
)
3485 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
3486 runtime
->hw
.channels_max
= mout
->max_channels
;
3487 if (mout
->dig_out_nid
) {
3488 if (!mout
->analog_rates
) {
3489 mout
->analog_rates
= hinfo
->rates
;
3490 mout
->analog_formats
= hinfo
->formats
;
3491 mout
->analog_maxbps
= hinfo
->maxbps
;
3493 runtime
->hw
.rates
= mout
->analog_rates
;
3494 runtime
->hw
.formats
= mout
->analog_formats
;
3495 hinfo
->maxbps
= mout
->analog_maxbps
;
3497 if (!mout
->spdif_rates
) {
3498 snd_hda_query_supported_pcm(codec
, mout
->dig_out_nid
,
3500 &mout
->spdif_formats
,
3501 &mout
->spdif_maxbps
);
3503 mutex_lock(&codec
->spdif_mutex
);
3504 if (mout
->share_spdif
) {
3505 if ((runtime
->hw
.rates
& mout
->spdif_rates
) &&
3506 (runtime
->hw
.formats
& mout
->spdif_formats
)) {
3507 runtime
->hw
.rates
&= mout
->spdif_rates
;
3508 runtime
->hw
.formats
&= mout
->spdif_formats
;
3509 if (mout
->spdif_maxbps
< hinfo
->maxbps
)
3510 hinfo
->maxbps
= mout
->spdif_maxbps
;
3512 mout
->share_spdif
= 0;
3513 /* FIXME: need notify? */
3516 mutex_unlock(&codec
->spdif_mutex
);
3518 return snd_pcm_hw_constraint_step(substream
->runtime
, 0,
3519 SNDRV_PCM_HW_PARAM_CHANNELS
, 2);
3521 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open
);
3524 * set up the i/o for analog out
3525 * when the digital out is available, copy the front out to digital out, too.
3527 int snd_hda_multi_out_analog_prepare(struct hda_codec
*codec
,
3528 struct hda_multi_out
*mout
,
3529 unsigned int stream_tag
,
3530 unsigned int format
,
3531 struct snd_pcm_substream
*substream
)
3533 hda_nid_t
*nids
= mout
->dac_nids
;
3534 int chs
= substream
->runtime
->channels
;
3537 mutex_lock(&codec
->spdif_mutex
);
3538 if (mout
->dig_out_nid
&& mout
->share_spdif
&&
3539 mout
->dig_out_used
!= HDA_DIG_EXCLUSIVE
) {
3541 snd_hda_is_supported_format(codec
, mout
->dig_out_nid
,
3543 !(codec
->spdif_status
& IEC958_AES0_NONAUDIO
)) {
3544 mout
->dig_out_used
= HDA_DIG_ANALOG_DUP
;
3545 setup_dig_out_stream(codec
, mout
->dig_out_nid
,
3546 stream_tag
, format
);
3548 mout
->dig_out_used
= 0;
3549 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
3552 mutex_unlock(&codec
->spdif_mutex
);
3555 snd_hda_codec_setup_stream(codec
, nids
[HDA_FRONT
], stream_tag
,
3557 if (!mout
->no_share_stream
&&
3558 mout
->hp_nid
&& mout
->hp_nid
!= nids
[HDA_FRONT
])
3559 /* headphone out will just decode front left/right (stereo) */
3560 snd_hda_codec_setup_stream(codec
, mout
->hp_nid
, stream_tag
,
3562 /* extra outputs copied from front */
3563 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
3564 if (!mout
->no_share_stream
&& mout
->extra_out_nid
[i
])
3565 snd_hda_codec_setup_stream(codec
,
3566 mout
->extra_out_nid
[i
],
3567 stream_tag
, 0, format
);
3570 for (i
= 1; i
< mout
->num_dacs
; i
++) {
3571 if (chs
>= (i
+ 1) * 2) /* independent out */
3572 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
3574 else if (!mout
->no_share_stream
) /* copy front */
3575 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
3580 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare
);
3583 * clean up the setting for analog out
3585 int snd_hda_multi_out_analog_cleanup(struct hda_codec
*codec
,
3586 struct hda_multi_out
*mout
)
3588 hda_nid_t
*nids
= mout
->dac_nids
;
3591 for (i
= 0; i
< mout
->num_dacs
; i
++)
3592 snd_hda_codec_cleanup_stream(codec
, nids
[i
]);
3594 snd_hda_codec_cleanup_stream(codec
, mout
->hp_nid
);
3595 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
3596 if (mout
->extra_out_nid
[i
])
3597 snd_hda_codec_cleanup_stream(codec
,
3598 mout
->extra_out_nid
[i
]);
3599 mutex_lock(&codec
->spdif_mutex
);
3600 if (mout
->dig_out_nid
&& mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
) {
3601 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
3602 mout
->dig_out_used
= 0;
3604 mutex_unlock(&codec
->spdif_mutex
);
3607 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup
);
3610 * Helper for automatic pin configuration
3613 static int is_in_nid_list(hda_nid_t nid
, hda_nid_t
*list
)
3615 for (; *list
; list
++)
3623 * Sort an associated group of pins according to their sequence numbers.
3625 static void sort_pins_by_sequence(hda_nid_t
* pins
, short * sequences
,
3632 for (i
= 0; i
< num_pins
; i
++) {
3633 for (j
= i
+ 1; j
< num_pins
; j
++) {
3634 if (sequences
[i
] > sequences
[j
]) {
3636 sequences
[i
] = sequences
[j
];
3648 * Parse all pin widgets and store the useful pin nids to cfg
3650 * The number of line-outs or any primary output is stored in line_outs,
3651 * and the corresponding output pins are assigned to line_out_pins[],
3652 * in the order of front, rear, CLFE, side, ...
3654 * If more extra outputs (speaker and headphone) are found, the pins are
3655 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3656 * is detected, one of speaker of HP pins is assigned as the primary
3657 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3658 * if any analog output exists.
3660 * The analog input pins are assigned to input_pins array.
3661 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3664 int snd_hda_parse_pin_def_config(struct hda_codec
*codec
,
3665 struct auto_pin_cfg
*cfg
,
3666 hda_nid_t
*ignore_nids
)
3668 hda_nid_t nid
, end_nid
;
3669 short seq
, assoc_line_out
, assoc_speaker
;
3670 short sequences_line_out
[ARRAY_SIZE(cfg
->line_out_pins
)];
3671 short sequences_speaker
[ARRAY_SIZE(cfg
->speaker_pins
)];
3672 short sequences_hp
[ARRAY_SIZE(cfg
->hp_pins
)];
3674 memset(cfg
, 0, sizeof(*cfg
));
3676 memset(sequences_line_out
, 0, sizeof(sequences_line_out
));
3677 memset(sequences_speaker
, 0, sizeof(sequences_speaker
));
3678 memset(sequences_hp
, 0, sizeof(sequences_hp
));
3679 assoc_line_out
= assoc_speaker
= 0;
3681 end_nid
= codec
->start_nid
+ codec
->num_nodes
;
3682 for (nid
= codec
->start_nid
; nid
< end_nid
; nid
++) {
3683 unsigned int wid_caps
= get_wcaps(codec
, nid
);
3684 unsigned int wid_type
= get_wcaps_type(wid_caps
);
3685 unsigned int def_conf
;
3688 /* read all default configuration for pin complex */
3689 if (wid_type
!= AC_WID_PIN
)
3691 /* ignore the given nids (e.g. pc-beep returns error) */
3692 if (ignore_nids
&& is_in_nid_list(nid
, ignore_nids
))
3695 def_conf
= snd_hda_codec_get_pincfg(codec
, nid
);
3696 if (get_defcfg_connect(def_conf
) == AC_JACK_PORT_NONE
)
3698 loc
= get_defcfg_location(def_conf
);
3699 switch (get_defcfg_device(def_conf
)) {
3700 case AC_JACK_LINE_OUT
:
3701 seq
= get_defcfg_sequence(def_conf
);
3702 assoc
= get_defcfg_association(def_conf
);
3704 if (!(wid_caps
& AC_WCAP_STEREO
))
3705 if (!cfg
->mono_out_pin
)
3706 cfg
->mono_out_pin
= nid
;
3709 if (!assoc_line_out
)
3710 assoc_line_out
= assoc
;
3711 else if (assoc_line_out
!= assoc
)
3713 if (cfg
->line_outs
>= ARRAY_SIZE(cfg
->line_out_pins
))
3715 cfg
->line_out_pins
[cfg
->line_outs
] = nid
;
3716 sequences_line_out
[cfg
->line_outs
] = seq
;
3719 case AC_JACK_SPEAKER
:
3720 seq
= get_defcfg_sequence(def_conf
);
3721 assoc
= get_defcfg_association(def_conf
);
3724 if (! assoc_speaker
)
3725 assoc_speaker
= assoc
;
3726 else if (assoc_speaker
!= assoc
)
3728 if (cfg
->speaker_outs
>= ARRAY_SIZE(cfg
->speaker_pins
))
3730 cfg
->speaker_pins
[cfg
->speaker_outs
] = nid
;
3731 sequences_speaker
[cfg
->speaker_outs
] = seq
;
3732 cfg
->speaker_outs
++;
3734 case AC_JACK_HP_OUT
:
3735 seq
= get_defcfg_sequence(def_conf
);
3736 assoc
= get_defcfg_association(def_conf
);
3737 if (cfg
->hp_outs
>= ARRAY_SIZE(cfg
->hp_pins
))
3739 cfg
->hp_pins
[cfg
->hp_outs
] = nid
;
3740 sequences_hp
[cfg
->hp_outs
] = (assoc
<< 4) | seq
;
3743 case AC_JACK_MIC_IN
: {
3745 if (loc
== AC_JACK_LOC_FRONT
) {
3746 preferred
= AUTO_PIN_FRONT_MIC
;
3749 preferred
= AUTO_PIN_MIC
;
3750 alt
= AUTO_PIN_FRONT_MIC
;
3752 if (!cfg
->input_pins
[preferred
])
3753 cfg
->input_pins
[preferred
] = nid
;
3754 else if (!cfg
->input_pins
[alt
])
3755 cfg
->input_pins
[alt
] = nid
;
3758 case AC_JACK_LINE_IN
:
3759 if (loc
== AC_JACK_LOC_FRONT
)
3760 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
] = nid
;
3762 cfg
->input_pins
[AUTO_PIN_LINE
] = nid
;
3765 cfg
->input_pins
[AUTO_PIN_CD
] = nid
;
3768 cfg
->input_pins
[AUTO_PIN_AUX
] = nid
;
3770 case AC_JACK_SPDIF_OUT
:
3771 case AC_JACK_DIG_OTHER_OUT
:
3772 if (cfg
->dig_outs
>= ARRAY_SIZE(cfg
->dig_out_pins
))
3774 cfg
->dig_out_pins
[cfg
->dig_outs
] = nid
;
3775 cfg
->dig_out_type
[cfg
->dig_outs
] =
3776 (loc
== AC_JACK_LOC_HDMI
) ?
3777 HDA_PCM_TYPE_HDMI
: HDA_PCM_TYPE_SPDIF
;
3780 case AC_JACK_SPDIF_IN
:
3781 case AC_JACK_DIG_OTHER_IN
:
3782 cfg
->dig_in_pin
= nid
;
3783 if (loc
== AC_JACK_LOC_HDMI
)
3784 cfg
->dig_in_type
= HDA_PCM_TYPE_HDMI
;
3786 cfg
->dig_in_type
= HDA_PCM_TYPE_SPDIF
;
3792 * If no line-out is defined but multiple HPs are found,
3793 * some of them might be the real line-outs.
3795 if (!cfg
->line_outs
&& cfg
->hp_outs
> 1) {
3797 while (i
< cfg
->hp_outs
) {
3798 /* The real HPs should have the sequence 0x0f */
3799 if ((sequences_hp
[i
] & 0x0f) == 0x0f) {
3803 /* Move it to the line-out table */
3804 cfg
->line_out_pins
[cfg
->line_outs
] = cfg
->hp_pins
[i
];
3805 sequences_line_out
[cfg
->line_outs
] = sequences_hp
[i
];
3808 memmove(cfg
->hp_pins
+ i
, cfg
->hp_pins
+ i
+ 1,
3809 sizeof(cfg
->hp_pins
[0]) * (cfg
->hp_outs
- i
));
3810 memmove(sequences_hp
+ i
- 1, sequences_hp
+ i
,
3811 sizeof(sequences_hp
[0]) * (cfg
->hp_outs
- i
));
3815 /* sort by sequence */
3816 sort_pins_by_sequence(cfg
->line_out_pins
, sequences_line_out
,
3818 sort_pins_by_sequence(cfg
->speaker_pins
, sequences_speaker
,
3820 sort_pins_by_sequence(cfg
->hp_pins
, sequences_hp
,
3823 /* if we have only one mic, make it AUTO_PIN_MIC */
3824 if (!cfg
->input_pins
[AUTO_PIN_MIC
] &&
3825 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
]) {
3826 cfg
->input_pins
[AUTO_PIN_MIC
] =
3827 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
];
3828 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
] = 0;
3830 /* ditto for line-in */
3831 if (!cfg
->input_pins
[AUTO_PIN_LINE
] &&
3832 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
]) {
3833 cfg
->input_pins
[AUTO_PIN_LINE
] =
3834 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
];
3835 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
] = 0;
3839 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3840 * as a primary output
3842 if (!cfg
->line_outs
) {
3843 if (cfg
->speaker_outs
) {
3844 cfg
->line_outs
= cfg
->speaker_outs
;
3845 memcpy(cfg
->line_out_pins
, cfg
->speaker_pins
,
3846 sizeof(cfg
->speaker_pins
));
3847 cfg
->speaker_outs
= 0;
3848 memset(cfg
->speaker_pins
, 0, sizeof(cfg
->speaker_pins
));
3849 cfg
->line_out_type
= AUTO_PIN_SPEAKER_OUT
;
3850 } else if (cfg
->hp_outs
) {
3851 cfg
->line_outs
= cfg
->hp_outs
;
3852 memcpy(cfg
->line_out_pins
, cfg
->hp_pins
,
3853 sizeof(cfg
->hp_pins
));
3855 memset(cfg
->hp_pins
, 0, sizeof(cfg
->hp_pins
));
3856 cfg
->line_out_type
= AUTO_PIN_HP_OUT
;
3860 /* Reorder the surround channels
3861 * ALSA sequence is front/surr/clfe/side
3863 * 4-ch: front/surr => OK as it is
3864 * 6-ch: front/clfe/surr
3865 * 8-ch: front/clfe/rear/side|fc
3867 switch (cfg
->line_outs
) {
3870 nid
= cfg
->line_out_pins
[1];
3871 cfg
->line_out_pins
[1] = cfg
->line_out_pins
[2];
3872 cfg
->line_out_pins
[2] = nid
;
3877 * debug prints of the parsed results
3879 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3880 cfg
->line_outs
, cfg
->line_out_pins
[0], cfg
->line_out_pins
[1],
3881 cfg
->line_out_pins
[2], cfg
->line_out_pins
[3],
3882 cfg
->line_out_pins
[4]);
3883 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3884 cfg
->speaker_outs
, cfg
->speaker_pins
[0],
3885 cfg
->speaker_pins
[1], cfg
->speaker_pins
[2],
3886 cfg
->speaker_pins
[3], cfg
->speaker_pins
[4]);
3887 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3888 cfg
->hp_outs
, cfg
->hp_pins
[0],
3889 cfg
->hp_pins
[1], cfg
->hp_pins
[2],
3890 cfg
->hp_pins
[3], cfg
->hp_pins
[4]);
3891 snd_printd(" mono: mono_out=0x%x\n", cfg
->mono_out_pin
);
3893 snd_printd(" dig-out=0x%x/0x%x\n",
3894 cfg
->dig_out_pins
[0], cfg
->dig_out_pins
[1]);
3895 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3896 " cd=0x%x, aux=0x%x\n",
3897 cfg
->input_pins
[AUTO_PIN_MIC
],
3898 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
],
3899 cfg
->input_pins
[AUTO_PIN_LINE
],
3900 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
],
3901 cfg
->input_pins
[AUTO_PIN_CD
],
3902 cfg
->input_pins
[AUTO_PIN_AUX
]);
3903 if (cfg
->dig_in_pin
)
3904 snd_printd(" dig-in=0x%x\n", cfg
->dig_in_pin
);
3908 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config
);
3910 /* labels for input pins */
3911 const char *auto_pin_cfg_labels
[AUTO_PIN_LAST
] = {
3912 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3914 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels
);
3923 * snd_hda_suspend - suspend the codecs
3926 * Returns 0 if successful.
3928 int snd_hda_suspend(struct hda_bus
*bus
)
3930 struct hda_codec
*codec
;
3932 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3933 #ifdef CONFIG_SND_HDA_POWER_SAVE
3934 if (!codec
->power_on
)
3937 hda_call_codec_suspend(codec
);
3941 EXPORT_SYMBOL_HDA(snd_hda_suspend
);
3944 * snd_hda_resume - resume the codecs
3947 * Returns 0 if successful.
3949 * This fucntion is defined only when POWER_SAVE isn't set.
3950 * In the power-save mode, the codec is resumed dynamically.
3952 int snd_hda_resume(struct hda_bus
*bus
)
3954 struct hda_codec
*codec
;
3956 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3957 if (snd_hda_codec_needs_resume(codec
))
3958 hda_call_codec_resume(codec
);
3962 EXPORT_SYMBOL_HDA(snd_hda_resume
);
3963 #endif /* CONFIG_PM */
3969 /* get a new element from the given array
3970 * if it exceeds the pre-allocated array size, re-allocate the array
3972 void *snd_array_new(struct snd_array
*array
)
3974 if (array
->used
>= array
->alloced
) {
3975 int num
= array
->alloced
+ array
->alloc_align
;
3977 if (snd_BUG_ON(num
>= 4096))
3979 nlist
= kcalloc(num
+ 1, array
->elem_size
, GFP_KERNEL
);
3983 memcpy(nlist
, array
->list
,
3984 array
->elem_size
* array
->alloced
);
3987 array
->list
= nlist
;
3988 array
->alloced
= num
;
3990 return snd_array_elem(array
, array
->used
++);
3992 EXPORT_SYMBOL_HDA(snd_array_new
);
3994 /* free the given array elements */
3995 void snd_array_free(struct snd_array
*array
)
4002 EXPORT_SYMBOL_HDA(snd_array_free
);
4005 * used by hda_proc.c and hda_eld.c
4007 void snd_print_pcm_rates(int pcm
, char *buf
, int buflen
)
4009 static unsigned int rates
[] = {
4010 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
4011 96000, 176400, 192000, 384000
4015 for (i
= 0, j
= 0; i
< ARRAY_SIZE(rates
); i
++)
4017 j
+= snprintf(buf
+ j
, buflen
- j
, " %d", rates
[i
]);
4019 buf
[j
] = '\0'; /* necessary when j == 0 */
4021 EXPORT_SYMBOL_HDA(snd_print_pcm_rates
);
4023 void snd_print_pcm_bits(int pcm
, char *buf
, int buflen
)
4025 static unsigned int bits
[] = { 8, 16, 20, 24, 32 };
4028 for (i
= 0, j
= 0; i
< ARRAY_SIZE(bits
); i
++)
4029 if (pcm
& (AC_SUPPCM_BITS_8
<< i
))
4030 j
+= snprintf(buf
+ j
, buflen
- j
, " %d", bits
[i
]);
4032 buf
[j
] = '\0'; /* necessary when j == 0 */
4034 EXPORT_SYMBOL_HDA(snd_print_pcm_bits
);
4036 MODULE_DESCRIPTION("HDA codec core");
4037 MODULE_LICENSE("GPL");