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 <sound/jack.h>
33 #include "hda_local.h"
35 #include <sound/hda_hwdep.h>
37 #define CREATE_TRACE_POINTS
38 #include "hda_trace.h"
41 * vendor / preset table
44 struct hda_vendor_id
{
49 /* codec vendor labels */
50 static struct hda_vendor_id hda_vendor_ids
[] = {
52 { 0x1013, "Cirrus Logic" },
53 { 0x1057, "Motorola" },
54 { 0x1095, "Silicon Image" },
56 { 0x10ec, "Realtek" },
57 { 0x1102, "Creative" },
61 { 0x11d4, "Analog Devices" },
62 { 0x13f6, "C-Media" },
63 { 0x14f1, "Conexant" },
64 { 0x17e8, "Chrontel" },
66 { 0x1aec, "Wolfson Microelectronics" },
67 { 0x434d, "C-Media" },
69 { 0x8384, "SigmaTel" },
73 static DEFINE_MUTEX(preset_mutex
);
74 static LIST_HEAD(hda_preset_tables
);
76 int snd_hda_add_codec_preset(struct hda_codec_preset_list
*preset
)
78 mutex_lock(&preset_mutex
);
79 list_add_tail(&preset
->list
, &hda_preset_tables
);
80 mutex_unlock(&preset_mutex
);
83 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset
);
85 int snd_hda_delete_codec_preset(struct hda_codec_preset_list
*preset
)
87 mutex_lock(&preset_mutex
);
88 list_del(&preset
->list
);
89 mutex_unlock(&preset_mutex
);
92 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset
);
94 #ifdef CONFIG_SND_HDA_POWER_SAVE
95 static void hda_power_work(struct work_struct
*work
);
96 static void hda_keep_power_on(struct hda_codec
*codec
);
97 #define hda_codec_is_power_on(codec) ((codec)->power_on)
99 static inline void hda_keep_power_on(struct hda_codec
*codec
) {}
100 #define hda_codec_is_power_on(codec) 1
104 * snd_hda_get_jack_location - Give a location string of the jack
105 * @cfg: pin default config value
107 * Parse the pin default config value and returns the string of the
108 * jack location, e.g. "Rear", "Front", etc.
110 const char *snd_hda_get_jack_location(u32 cfg
)
112 static char *bases
[7] = {
113 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
115 static unsigned char specials_idx
[] = {
120 static char *specials
[] = {
121 "Rear Panel", "Drive Bar",
122 "Riser", "HDMI", "ATAPI",
123 "Mobile-In", "Mobile-Out"
126 cfg
= (cfg
& AC_DEFCFG_LOCATION
) >> AC_DEFCFG_LOCATION_SHIFT
;
127 if ((cfg
& 0x0f) < 7)
128 return bases
[cfg
& 0x0f];
129 for (i
= 0; i
< ARRAY_SIZE(specials_idx
); i
++) {
130 if (cfg
== specials_idx
[i
])
135 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location
);
138 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
139 * @cfg: pin default config value
141 * Parse the pin default config value and returns the string of the
142 * jack connectivity, i.e. external or internal connection.
144 const char *snd_hda_get_jack_connectivity(u32 cfg
)
146 static char *jack_locations
[4] = { "Ext", "Int", "Sep", "Oth" };
148 return jack_locations
[(cfg
>> (AC_DEFCFG_LOCATION_SHIFT
+ 4)) & 3];
150 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity
);
153 * snd_hda_get_jack_type - Give a type string of the jack
154 * @cfg: pin default config value
156 * Parse the pin default config value and returns the string of the
157 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
159 const char *snd_hda_get_jack_type(u32 cfg
)
161 static char *jack_types
[16] = {
162 "Line Out", "Speaker", "HP Out", "CD",
163 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
164 "Line In", "Aux", "Mic", "Telephony",
165 "SPDIF In", "Digitial In", "Reserved", "Other"
168 return jack_types
[(cfg
& AC_DEFCFG_DEVICE
)
169 >> AC_DEFCFG_DEVICE_SHIFT
];
171 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type
);
174 * Compose a 32bit command word to be sent to the HD-audio controller
176 static inline unsigned int
177 make_codec_cmd(struct hda_codec
*codec
, hda_nid_t nid
, int direct
,
178 unsigned int verb
, unsigned int parm
)
182 if ((codec
->addr
& ~0xf) || (direct
& ~1) || (nid
& ~0x7f) ||
183 (verb
& ~0xfff) || (parm
& ~0xffff)) {
184 printk(KERN_ERR
"hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
185 codec
->addr
, direct
, nid
, verb
, parm
);
189 val
= (u32
)codec
->addr
<< 28;
190 val
|= (u32
)direct
<< 27;
191 val
|= (u32
)nid
<< 20;
198 * Send and receive a verb
200 static int codec_exec_verb(struct hda_codec
*codec
, unsigned int cmd
,
203 struct hda_bus
*bus
= codec
->bus
;
212 snd_hda_power_up(codec
);
213 mutex_lock(&bus
->cmd_mutex
);
214 trace_hda_send_cmd(codec
, cmd
);
215 err
= bus
->ops
.command(bus
, cmd
);
217 *res
= bus
->ops
.get_response(bus
, codec
->addr
);
218 trace_hda_get_response(codec
, *res
);
220 mutex_unlock(&bus
->cmd_mutex
);
221 snd_hda_power_down(codec
);
222 if (res
&& *res
== -1 && bus
->rirb_error
) {
223 if (bus
->response_reset
) {
224 snd_printd("hda_codec: resetting BUS due to "
225 "fatal communication error\n");
226 trace_hda_bus_reset(bus
);
227 bus
->ops
.bus_reset(bus
);
231 /* clear reset-flag when the communication gets recovered */
233 bus
->response_reset
= 0;
238 * snd_hda_codec_read - send a command and get the response
239 * @codec: the HDA codec
240 * @nid: NID to send the command
241 * @direct: direct flag
242 * @verb: the verb to send
243 * @parm: the parameter for the verb
245 * Send a single command and read the corresponding response.
247 * Returns the obtained response value, or -1 for an error.
249 unsigned int snd_hda_codec_read(struct hda_codec
*codec
, hda_nid_t nid
,
251 unsigned int verb
, unsigned int parm
)
253 unsigned cmd
= make_codec_cmd(codec
, nid
, direct
, verb
, parm
);
255 if (codec_exec_verb(codec
, cmd
, &res
))
259 EXPORT_SYMBOL_HDA(snd_hda_codec_read
);
262 * snd_hda_codec_write - send a single command without waiting for response
263 * @codec: the HDA codec
264 * @nid: NID to send the command
265 * @direct: direct flag
266 * @verb: the verb to send
267 * @parm: the parameter for the verb
269 * Send a single command without waiting for response.
271 * Returns 0 if successful, or a negative error code.
273 int snd_hda_codec_write(struct hda_codec
*codec
, hda_nid_t nid
, int direct
,
274 unsigned int verb
, unsigned int parm
)
276 unsigned int cmd
= make_codec_cmd(codec
, nid
, direct
, verb
, parm
);
278 return codec_exec_verb(codec
, cmd
,
279 codec
->bus
->sync_write
? &res
: NULL
);
281 EXPORT_SYMBOL_HDA(snd_hda_codec_write
);
284 * snd_hda_sequence_write - sequence writes
285 * @codec: the HDA codec
286 * @seq: VERB array to send
288 * Send the commands sequentially from the given array.
289 * The array must be terminated with NID=0.
291 void snd_hda_sequence_write(struct hda_codec
*codec
, const struct hda_verb
*seq
)
293 for (; seq
->nid
; seq
++)
294 snd_hda_codec_write(codec
, seq
->nid
, 0, seq
->verb
, seq
->param
);
296 EXPORT_SYMBOL_HDA(snd_hda_sequence_write
);
299 * snd_hda_get_sub_nodes - get the range of sub nodes
300 * @codec: the HDA codec
302 * @start_id: the pointer to store the start NID
304 * Parse the NID and store the start NID of its sub-nodes.
305 * Returns the number of sub-nodes.
307 int snd_hda_get_sub_nodes(struct hda_codec
*codec
, hda_nid_t nid
,
312 parm
= snd_hda_param_read(codec
, nid
, AC_PAR_NODE_COUNT
);
315 *start_id
= (parm
>> 16) & 0x7fff;
316 return (int)(parm
& 0x7fff);
318 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes
);
320 /* look up the cached results */
321 static hda_nid_t
*lookup_conn_list(struct snd_array
*array
, hda_nid_t nid
)
324 for (i
= 0; i
< array
->used
; ) {
325 hda_nid_t
*p
= snd_array_elem(array
, i
);
335 * snd_hda_get_conn_list - get connection list
336 * @codec: the HDA codec
338 * @listp: the pointer to store NID list
340 * Parses the connection list of the given widget and stores the list
343 * Returns the number of connections, or a negative error code.
345 int snd_hda_get_conn_list(struct hda_codec
*codec
, hda_nid_t nid
,
346 const hda_nid_t
**listp
)
348 struct snd_array
*array
= &codec
->conn_lists
;
350 hda_nid_t list
[HDA_MAX_CONNECTIONS
];
355 /* if the connection-list is already cached, read it */
356 p
= lookup_conn_list(array
, nid
);
362 if (snd_BUG_ON(added
))
365 /* read the connection and add to the cache */
366 len
= snd_hda_get_raw_connections(codec
, nid
, list
, HDA_MAX_CONNECTIONS
);
369 err
= snd_hda_override_conn_list(codec
, nid
, len
, list
);
375 EXPORT_SYMBOL_HDA(snd_hda_get_conn_list
);
378 * snd_hda_get_connections - copy connection list
379 * @codec: the HDA codec
381 * @conn_list: connection list array
382 * @max_conns: max. number of connections to store
384 * Parses the connection list of the given widget and stores the list
387 * Returns the number of connections, or a negative error code.
389 int snd_hda_get_connections(struct hda_codec
*codec
, hda_nid_t nid
,
390 hda_nid_t
*conn_list
, int max_conns
)
392 const hda_nid_t
*list
;
393 int len
= snd_hda_get_conn_list(codec
, nid
, &list
);
397 if (len
> max_conns
) {
398 snd_printk(KERN_ERR
"hda_codec: "
399 "Too many connections %d for NID 0x%x\n",
403 memcpy(conn_list
, list
, len
* sizeof(hda_nid_t
));
406 EXPORT_SYMBOL_HDA(snd_hda_get_connections
);
409 * snd_hda_get_raw_connections - copy connection list without cache
410 * @codec: the HDA codec
412 * @conn_list: connection list array
413 * @max_conns: max. number of connections to store
415 * Like snd_hda_get_connections(), copy the connection list but without
416 * checking through the connection-list cache.
417 * Currently called only from hda_proc.c, so not exported.
419 int snd_hda_get_raw_connections(struct hda_codec
*codec
, hda_nid_t nid
,
420 hda_nid_t
*conn_list
, int max_conns
)
423 int i
, conn_len
, conns
;
424 unsigned int shift
, num_elems
, mask
;
428 if (snd_BUG_ON(!conn_list
|| max_conns
<= 0))
431 wcaps
= get_wcaps(codec
, nid
);
432 if (!(wcaps
& AC_WCAP_CONN_LIST
) &&
433 get_wcaps_type(wcaps
) != AC_WID_VOL_KNB
)
436 parm
= snd_hda_param_read(codec
, nid
, AC_PAR_CONNLIST_LEN
);
437 if (parm
& AC_CLIST_LONG
) {
446 conn_len
= parm
& AC_CLIST_LENGTH
;
447 mask
= (1 << (shift
-1)) - 1;
450 return 0; /* no connection */
453 /* single connection */
454 parm
= snd_hda_codec_read(codec
, nid
, 0,
455 AC_VERB_GET_CONNECT_LIST
, 0);
456 if (parm
== -1 && codec
->bus
->rirb_error
)
458 conn_list
[0] = parm
& mask
;
462 /* multi connection */
465 for (i
= 0; i
< conn_len
; i
++) {
469 if (i
% num_elems
== 0) {
470 parm
= snd_hda_codec_read(codec
, nid
, 0,
471 AC_VERB_GET_CONNECT_LIST
, i
);
472 if (parm
== -1 && codec
->bus
->rirb_error
)
475 range_val
= !!(parm
& (1 << (shift
-1))); /* ranges */
478 snd_printk(KERN_WARNING
"hda_codec: "
479 "invalid CONNECT_LIST verb %x[%i]:%x\n",
485 /* ranges between the previous and this one */
486 if (!prev_nid
|| prev_nid
>= val
) {
487 snd_printk(KERN_WARNING
"hda_codec: "
488 "invalid dep_range_val %x:%x\n",
492 for (n
= prev_nid
+ 1; n
<= val
; n
++) {
493 if (conns
>= max_conns
) {
494 snd_printk(KERN_ERR
"hda_codec: "
495 "Too many connections %d for NID 0x%x\n",
499 conn_list
[conns
++] = n
;
502 if (conns
>= max_conns
) {
503 snd_printk(KERN_ERR
"hda_codec: "
504 "Too many connections %d for NID 0x%x\n",
508 conn_list
[conns
++] = val
;
515 static bool add_conn_list(struct snd_array
*array
, hda_nid_t nid
)
517 hda_nid_t
*p
= snd_array_new(array
);
525 * snd_hda_override_conn_list - add/modify the connection-list to cache
526 * @codec: the HDA codec
528 * @len: number of connection list entries
529 * @list: the list of connection entries
531 * Add or modify the given connection-list to the cache. If the corresponding
532 * cache already exists, invalidate it and append a new one.
534 * Returns zero or a negative error code.
536 int snd_hda_override_conn_list(struct hda_codec
*codec
, hda_nid_t nid
, int len
,
537 const hda_nid_t
*list
)
539 struct snd_array
*array
= &codec
->conn_lists
;
543 p
= lookup_conn_list(array
, nid
);
545 *p
= -1; /* invalidate the old entry */
547 old_used
= array
->used
;
548 if (!add_conn_list(array
, nid
) || !add_conn_list(array
, len
))
550 for (i
= 0; i
< len
; i
++)
551 if (!add_conn_list(array
, list
[i
]))
556 array
->used
= old_used
;
559 EXPORT_SYMBOL_HDA(snd_hda_override_conn_list
);
562 * snd_hda_get_conn_index - get the connection index of the given NID
563 * @codec: the HDA codec
564 * @mux: NID containing the list
565 * @nid: NID to select
566 * @recursive: 1 when searching NID recursively, otherwise 0
568 * Parses the connection list of the widget @mux and checks whether the
569 * widget @nid is present. If it is, return the connection index.
570 * Otherwise it returns -1.
572 int snd_hda_get_conn_index(struct hda_codec
*codec
, hda_nid_t mux
,
573 hda_nid_t nid
, int recursive
)
575 hda_nid_t conn
[HDA_MAX_NUM_INPUTS
];
578 nums
= snd_hda_get_connections(codec
, mux
, conn
, ARRAY_SIZE(conn
));
579 for (i
= 0; i
< nums
; i
++)
585 snd_printd("hda_codec: too deep connection for 0x%x\n", nid
);
589 for (i
= 0; i
< nums
; i
++) {
590 unsigned int type
= get_wcaps_type(get_wcaps(codec
, conn
[i
]));
591 if (type
== AC_WID_PIN
|| type
== AC_WID_AUD_OUT
)
593 if (snd_hda_get_conn_index(codec
, conn
[i
], nid
, recursive
) >= 0)
598 EXPORT_SYMBOL_HDA(snd_hda_get_conn_index
);
601 * snd_hda_queue_unsol_event - add an unsolicited event to queue
603 * @res: unsolicited event (lower 32bit of RIRB entry)
604 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
606 * Adds the given event to the queue. The events are processed in
607 * the workqueue asynchronously. Call this function in the interrupt
608 * hanlder when RIRB receives an unsolicited event.
610 * Returns 0 if successful, or a negative error code.
612 int snd_hda_queue_unsol_event(struct hda_bus
*bus
, u32 res
, u32 res_ex
)
614 struct hda_bus_unsolicited
*unsol
;
617 trace_hda_unsol_event(bus
, res
, res_ex
);
622 wp
= (unsol
->wp
+ 1) % HDA_UNSOL_QUEUE_SIZE
;
626 unsol
->queue
[wp
] = res
;
627 unsol
->queue
[wp
+ 1] = res_ex
;
629 queue_work(bus
->workq
, &unsol
->work
);
633 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event
);
636 * process queued unsolicited events
638 static void process_unsol_events(struct work_struct
*work
)
640 struct hda_bus_unsolicited
*unsol
=
641 container_of(work
, struct hda_bus_unsolicited
, work
);
642 struct hda_bus
*bus
= unsol
->bus
;
643 struct hda_codec
*codec
;
644 unsigned int rp
, caddr
, res
;
646 while (unsol
->rp
!= unsol
->wp
) {
647 rp
= (unsol
->rp
+ 1) % HDA_UNSOL_QUEUE_SIZE
;
650 res
= unsol
->queue
[rp
];
651 caddr
= unsol
->queue
[rp
+ 1];
652 if (!(caddr
& (1 << 4))) /* no unsolicited event? */
654 codec
= bus
->caddr_tbl
[caddr
& 0x0f];
655 if (codec
&& codec
->patch_ops
.unsol_event
)
656 codec
->patch_ops
.unsol_event(codec
, res
);
661 * initialize unsolicited queue
663 static int init_unsol_queue(struct hda_bus
*bus
)
665 struct hda_bus_unsolicited
*unsol
;
667 if (bus
->unsol
) /* already initialized */
670 unsol
= kzalloc(sizeof(*unsol
), GFP_KERNEL
);
672 snd_printk(KERN_ERR
"hda_codec: "
673 "can't allocate unsolicited queue\n");
676 INIT_WORK(&unsol
->work
, process_unsol_events
);
685 static void snd_hda_codec_free(struct hda_codec
*codec
);
687 static int snd_hda_bus_free(struct hda_bus
*bus
)
689 struct hda_codec
*codec
, *n
;
694 flush_workqueue(bus
->workq
);
697 list_for_each_entry_safe(codec
, n
, &bus
->codec_list
, list
) {
698 snd_hda_codec_free(codec
);
700 if (bus
->ops
.private_free
)
701 bus
->ops
.private_free(bus
);
703 destroy_workqueue(bus
->workq
);
708 static int snd_hda_bus_dev_free(struct snd_device
*device
)
710 struct hda_bus
*bus
= device
->device_data
;
712 return snd_hda_bus_free(bus
);
715 #ifdef CONFIG_SND_HDA_HWDEP
716 static int snd_hda_bus_dev_register(struct snd_device
*device
)
718 struct hda_bus
*bus
= device
->device_data
;
719 struct hda_codec
*codec
;
720 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
721 snd_hda_hwdep_add_sysfs(codec
);
722 snd_hda_hwdep_add_power_sysfs(codec
);
727 #define snd_hda_bus_dev_register NULL
731 * snd_hda_bus_new - create a HDA bus
732 * @card: the card entry
733 * @temp: the template for hda_bus information
734 * @busp: the pointer to store the created bus instance
736 * Returns 0 if successful, or a negative error code.
738 int /*__devinit*/ snd_hda_bus_new(struct snd_card
*card
,
739 const struct hda_bus_template
*temp
,
740 struct hda_bus
**busp
)
744 static struct snd_device_ops dev_ops
= {
745 .dev_register
= snd_hda_bus_dev_register
,
746 .dev_free
= snd_hda_bus_dev_free
,
749 if (snd_BUG_ON(!temp
))
751 if (snd_BUG_ON(!temp
->ops
.command
|| !temp
->ops
.get_response
))
757 bus
= kzalloc(sizeof(*bus
), GFP_KERNEL
);
759 snd_printk(KERN_ERR
"can't allocate struct hda_bus\n");
764 bus
->private_data
= temp
->private_data
;
765 bus
->pci
= temp
->pci
;
766 bus
->modelname
= temp
->modelname
;
767 bus
->power_save
= temp
->power_save
;
768 bus
->ops
= temp
->ops
;
770 mutex_init(&bus
->cmd_mutex
);
771 mutex_init(&bus
->prepare_mutex
);
772 INIT_LIST_HEAD(&bus
->codec_list
);
774 snprintf(bus
->workq_name
, sizeof(bus
->workq_name
),
775 "hd-audio%d", card
->number
);
776 bus
->workq
= create_singlethread_workqueue(bus
->workq_name
);
778 snd_printk(KERN_ERR
"cannot create workqueue %s\n",
784 err
= snd_device_new(card
, SNDRV_DEV_BUS
, bus
, &dev_ops
);
786 snd_hda_bus_free(bus
);
793 EXPORT_SYMBOL_HDA(snd_hda_bus_new
);
795 #ifdef CONFIG_SND_HDA_GENERIC
796 #define is_generic_config(codec) \
797 (codec->modelname && !strcmp(codec->modelname, "generic"))
799 #define is_generic_config(codec) 0
803 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
805 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
809 * find a matching codec preset
811 static const struct hda_codec_preset
*
812 find_codec_preset(struct hda_codec
*codec
)
814 struct hda_codec_preset_list
*tbl
;
815 const struct hda_codec_preset
*preset
;
816 int mod_requested
= 0;
818 if (is_generic_config(codec
))
819 return NULL
; /* use the generic parser */
822 mutex_lock(&preset_mutex
);
823 list_for_each_entry(tbl
, &hda_preset_tables
, list
) {
824 if (!try_module_get(tbl
->owner
)) {
825 snd_printk(KERN_ERR
"hda_codec: cannot module_get\n");
828 for (preset
= tbl
->preset
; preset
->id
; preset
++) {
829 u32 mask
= preset
->mask
;
830 if (preset
->afg
&& preset
->afg
!= codec
->afg
)
832 if (preset
->mfg
&& preset
->mfg
!= codec
->mfg
)
836 if (preset
->id
== (codec
->vendor_id
& mask
) &&
838 preset
->rev
== codec
->revision_id
)) {
839 mutex_unlock(&preset_mutex
);
840 codec
->owner
= tbl
->owner
;
844 module_put(tbl
->owner
);
846 mutex_unlock(&preset_mutex
);
848 if (mod_requested
< HDA_MODREQ_MAX_COUNT
) {
851 snprintf(name
, sizeof(name
), "snd-hda-codec-id:%08x",
854 snprintf(name
, sizeof(name
), "snd-hda-codec-id:%04x*",
855 (codec
->vendor_id
>> 16) & 0xffff);
856 request_module(name
);
864 * get_codec_name - store the codec name
866 static int get_codec_name(struct hda_codec
*codec
)
868 const struct hda_vendor_id
*c
;
869 const char *vendor
= NULL
;
870 u16 vendor_id
= codec
->vendor_id
>> 16;
873 if (codec
->vendor_name
)
876 for (c
= hda_vendor_ids
; c
->id
; c
++) {
877 if (c
->id
== vendor_id
) {
883 sprintf(tmp
, "Generic %04x", vendor_id
);
886 codec
->vendor_name
= kstrdup(vendor
, GFP_KERNEL
);
887 if (!codec
->vendor_name
)
891 if (codec
->chip_name
)
894 if (codec
->preset
&& codec
->preset
->name
)
895 codec
->chip_name
= kstrdup(codec
->preset
->name
, GFP_KERNEL
);
897 sprintf(tmp
, "ID %x", codec
->vendor_id
& 0xffff);
898 codec
->chip_name
= kstrdup(tmp
, GFP_KERNEL
);
900 if (!codec
->chip_name
)
906 * look for an AFG and MFG nodes
908 static void /*__devinit*/ setup_fg_nodes(struct hda_codec
*codec
)
910 int i
, total_nodes
, function_id
;
913 total_nodes
= snd_hda_get_sub_nodes(codec
, AC_NODE_ROOT
, &nid
);
914 for (i
= 0; i
< total_nodes
; i
++, nid
++) {
915 function_id
= snd_hda_param_read(codec
, nid
,
916 AC_PAR_FUNCTION_TYPE
);
917 switch (function_id
& 0xff) {
918 case AC_GRP_AUDIO_FUNCTION
:
920 codec
->afg_function_id
= function_id
& 0xff;
921 codec
->afg_unsol
= (function_id
>> 8) & 1;
923 case AC_GRP_MODEM_FUNCTION
:
925 codec
->mfg_function_id
= function_id
& 0xff;
926 codec
->mfg_unsol
= (function_id
>> 8) & 1;
935 * read widget caps for each widget and store in cache
937 static int read_widget_caps(struct hda_codec
*codec
, hda_nid_t fg_node
)
942 codec
->num_nodes
= snd_hda_get_sub_nodes(codec
, fg_node
,
944 codec
->wcaps
= kmalloc(codec
->num_nodes
* 4, GFP_KERNEL
);
947 nid
= codec
->start_nid
;
948 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++)
949 codec
->wcaps
[i
] = snd_hda_param_read(codec
, nid
,
950 AC_PAR_AUDIO_WIDGET_CAP
);
954 /* read all pin default configurations and save codec->init_pins */
955 static int read_pin_defaults(struct hda_codec
*codec
)
958 hda_nid_t nid
= codec
->start_nid
;
960 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
961 struct hda_pincfg
*pin
;
962 unsigned int wcaps
= get_wcaps(codec
, nid
);
963 unsigned int wid_type
= get_wcaps_type(wcaps
);
964 if (wid_type
!= AC_WID_PIN
)
966 pin
= snd_array_new(&codec
->init_pins
);
970 pin
->cfg
= snd_hda_codec_read(codec
, nid
, 0,
971 AC_VERB_GET_CONFIG_DEFAULT
, 0);
972 pin
->ctrl
= snd_hda_codec_read(codec
, nid
, 0,
973 AC_VERB_GET_PIN_WIDGET_CONTROL
,
979 /* look up the given pin config list and return the item matching with NID */
980 static struct hda_pincfg
*look_up_pincfg(struct hda_codec
*codec
,
981 struct snd_array
*array
,
985 for (i
= 0; i
< array
->used
; i
++) {
986 struct hda_pincfg
*pin
= snd_array_elem(array
, i
);
993 /* write a config value for the given NID */
994 static void set_pincfg(struct hda_codec
*codec
, hda_nid_t nid
,
998 for (i
= 0; i
< 4; i
++) {
999 snd_hda_codec_write(codec
, nid
, 0,
1000 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0
+ i
,
1006 /* set the current pin config value for the given NID.
1007 * the value is cached, and read via snd_hda_codec_get_pincfg()
1009 int snd_hda_add_pincfg(struct hda_codec
*codec
, struct snd_array
*list
,
1010 hda_nid_t nid
, unsigned int cfg
)
1012 struct hda_pincfg
*pin
;
1013 unsigned int oldcfg
;
1015 if (get_wcaps_type(get_wcaps(codec
, nid
)) != AC_WID_PIN
)
1018 oldcfg
= snd_hda_codec_get_pincfg(codec
, nid
);
1019 pin
= look_up_pincfg(codec
, list
, nid
);
1021 pin
= snd_array_new(list
);
1028 /* change only when needed; e.g. if the pincfg is already present
1029 * in user_pins[], don't write it
1031 cfg
= snd_hda_codec_get_pincfg(codec
, nid
);
1033 set_pincfg(codec
, nid
, cfg
);
1038 * snd_hda_codec_set_pincfg - Override a pin default configuration
1039 * @codec: the HDA codec
1040 * @nid: NID to set the pin config
1041 * @cfg: the pin default config value
1043 * Override a pin default configuration value in the cache.
1044 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1045 * priority than the real hardware value.
1047 int snd_hda_codec_set_pincfg(struct hda_codec
*codec
,
1048 hda_nid_t nid
, unsigned int cfg
)
1050 return snd_hda_add_pincfg(codec
, &codec
->driver_pins
, nid
, cfg
);
1052 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg
);
1055 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1056 * @codec: the HDA codec
1057 * @nid: NID to get the pin config
1059 * Get the current pin config value of the given pin NID.
1060 * If the pincfg value is cached or overridden via sysfs or driver,
1061 * returns the cached value.
1063 unsigned int snd_hda_codec_get_pincfg(struct hda_codec
*codec
, hda_nid_t nid
)
1065 struct hda_pincfg
*pin
;
1067 #ifdef CONFIG_SND_HDA_HWDEP
1068 pin
= look_up_pincfg(codec
, &codec
->user_pins
, nid
);
1072 pin
= look_up_pincfg(codec
, &codec
->driver_pins
, nid
);
1075 pin
= look_up_pincfg(codec
, &codec
->init_pins
, nid
);
1080 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg
);
1082 /* restore all current pin configs */
1083 static void restore_pincfgs(struct hda_codec
*codec
)
1086 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
1087 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
1088 set_pincfg(codec
, pin
->nid
,
1089 snd_hda_codec_get_pincfg(codec
, pin
->nid
));
1094 * snd_hda_shutup_pins - Shut up all pins
1095 * @codec: the HDA codec
1097 * Clear all pin controls to shup up before suspend for avoiding click noise.
1098 * The controls aren't cached so that they can be resumed properly.
1100 void snd_hda_shutup_pins(struct hda_codec
*codec
)
1103 /* don't shut up pins when unloading the driver; otherwise it breaks
1104 * the default pin setup at the next load of the driver
1106 if (codec
->bus
->shutdown
)
1108 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
1109 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
1110 /* use read here for syncing after issuing each verb */
1111 snd_hda_codec_read(codec
, pin
->nid
, 0,
1112 AC_VERB_SET_PIN_WIDGET_CONTROL
, 0);
1114 codec
->pins_shutup
= 1;
1116 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins
);
1119 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1120 static void restore_shutup_pins(struct hda_codec
*codec
)
1123 if (!codec
->pins_shutup
)
1125 if (codec
->bus
->shutdown
)
1127 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
1128 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
1129 snd_hda_codec_write(codec
, pin
->nid
, 0,
1130 AC_VERB_SET_PIN_WIDGET_CONTROL
,
1133 codec
->pins_shutup
= 0;
1137 static void init_hda_cache(struct hda_cache_rec
*cache
,
1138 unsigned int record_size
);
1139 static void free_hda_cache(struct hda_cache_rec
*cache
);
1141 /* restore the initial pin cfgs and release all pincfg lists */
1142 static void restore_init_pincfgs(struct hda_codec
*codec
)
1144 /* first free driver_pins and user_pins, then call restore_pincfg
1145 * so that only the values in init_pins are restored
1147 snd_array_free(&codec
->driver_pins
);
1148 #ifdef CONFIG_SND_HDA_HWDEP
1149 snd_array_free(&codec
->user_pins
);
1151 restore_pincfgs(codec
);
1152 snd_array_free(&codec
->init_pins
);
1156 * audio-converter setup caches
1158 struct hda_cvt_setup
{
1163 unsigned char active
; /* cvt is currently used */
1164 unsigned char dirty
; /* setups should be cleared */
1167 /* get or create a cache entry for the given audio converter NID */
1168 static struct hda_cvt_setup
*
1169 get_hda_cvt_setup(struct hda_codec
*codec
, hda_nid_t nid
)
1171 struct hda_cvt_setup
*p
;
1174 for (i
= 0; i
< codec
->cvt_setups
.used
; i
++) {
1175 p
= snd_array_elem(&codec
->cvt_setups
, i
);
1179 p
= snd_array_new(&codec
->cvt_setups
);
1188 static void snd_hda_codec_free(struct hda_codec
*codec
)
1192 restore_init_pincfgs(codec
);
1193 #ifdef CONFIG_SND_HDA_POWER_SAVE
1194 cancel_delayed_work(&codec
->power_work
);
1195 flush_workqueue(codec
->bus
->workq
);
1197 list_del(&codec
->list
);
1198 snd_array_free(&codec
->mixers
);
1199 snd_array_free(&codec
->nids
);
1200 snd_array_free(&codec
->conn_lists
);
1201 snd_array_free(&codec
->spdif_out
);
1202 codec
->bus
->caddr_tbl
[codec
->addr
] = NULL
;
1203 if (codec
->patch_ops
.free
)
1204 codec
->patch_ops
.free(codec
);
1205 module_put(codec
->owner
);
1206 free_hda_cache(&codec
->amp_cache
);
1207 free_hda_cache(&codec
->cmd_cache
);
1208 kfree(codec
->vendor_name
);
1209 kfree(codec
->chip_name
);
1210 kfree(codec
->modelname
);
1211 kfree(codec
->wcaps
);
1215 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
1216 unsigned int power_state
);
1219 * snd_hda_codec_new - create a HDA codec
1220 * @bus: the bus to assign
1221 * @codec_addr: the codec address
1222 * @codecp: the pointer to store the generated codec
1224 * Returns 0 if successful, or a negative error code.
1226 int /*__devinit*/ snd_hda_codec_new(struct hda_bus
*bus
,
1227 unsigned int codec_addr
,
1228 struct hda_codec
**codecp
)
1230 struct hda_codec
*codec
;
1234 if (snd_BUG_ON(!bus
))
1236 if (snd_BUG_ON(codec_addr
> HDA_MAX_CODEC_ADDRESS
))
1239 if (bus
->caddr_tbl
[codec_addr
]) {
1240 snd_printk(KERN_ERR
"hda_codec: "
1241 "address 0x%x is already occupied\n", codec_addr
);
1245 codec
= kzalloc(sizeof(*codec
), GFP_KERNEL
);
1246 if (codec
== NULL
) {
1247 snd_printk(KERN_ERR
"can't allocate struct hda_codec\n");
1252 codec
->addr
= codec_addr
;
1253 mutex_init(&codec
->spdif_mutex
);
1254 mutex_init(&codec
->control_mutex
);
1255 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
1256 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
1257 snd_array_init(&codec
->mixers
, sizeof(struct hda_nid_item
), 32);
1258 snd_array_init(&codec
->nids
, sizeof(struct hda_nid_item
), 32);
1259 snd_array_init(&codec
->init_pins
, sizeof(struct hda_pincfg
), 16);
1260 snd_array_init(&codec
->driver_pins
, sizeof(struct hda_pincfg
), 16);
1261 snd_array_init(&codec
->cvt_setups
, sizeof(struct hda_cvt_setup
), 8);
1262 snd_array_init(&codec
->conn_lists
, sizeof(hda_nid_t
), 64);
1263 snd_array_init(&codec
->spdif_out
, sizeof(struct hda_spdif_out
), 16);
1264 if (codec
->bus
->modelname
) {
1265 codec
->modelname
= kstrdup(codec
->bus
->modelname
, GFP_KERNEL
);
1266 if (!codec
->modelname
) {
1267 snd_hda_codec_free(codec
);
1272 #ifdef CONFIG_SND_HDA_POWER_SAVE
1273 INIT_DELAYED_WORK(&codec
->power_work
, hda_power_work
);
1274 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1275 * the caller has to power down appropriatley after initialization
1278 hda_keep_power_on(codec
);
1281 list_add_tail(&codec
->list
, &bus
->codec_list
);
1282 bus
->caddr_tbl
[codec_addr
] = codec
;
1284 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1286 if (codec
->vendor_id
== -1)
1287 /* read again, hopefully the access method was corrected
1288 * in the last read...
1290 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1292 codec
->subsystem_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1293 AC_PAR_SUBSYSTEM_ID
);
1294 codec
->revision_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1297 setup_fg_nodes(codec
);
1298 if (!codec
->afg
&& !codec
->mfg
) {
1299 snd_printdd("hda_codec: no AFG or MFG node found\n");
1304 err
= read_widget_caps(codec
, codec
->afg
? codec
->afg
: codec
->mfg
);
1306 snd_printk(KERN_ERR
"hda_codec: cannot malloc\n");
1309 err
= read_pin_defaults(codec
);
1313 if (!codec
->subsystem_id
) {
1314 hda_nid_t nid
= codec
->afg
? codec
->afg
: codec
->mfg
;
1315 codec
->subsystem_id
=
1316 snd_hda_codec_read(codec
, nid
, 0,
1317 AC_VERB_GET_SUBSYSTEM_ID
, 0);
1320 /* power-up all before initialization */
1321 hda_set_power_state(codec
,
1322 codec
->afg
? codec
->afg
: codec
->mfg
,
1325 snd_hda_codec_proc_new(codec
);
1327 snd_hda_create_hwdep(codec
);
1329 sprintf(component
, "HDA:%08x,%08x,%08x", codec
->vendor_id
,
1330 codec
->subsystem_id
, codec
->revision_id
);
1331 snd_component_add(codec
->bus
->card
, component
);
1338 snd_hda_codec_free(codec
);
1341 EXPORT_SYMBOL_HDA(snd_hda_codec_new
);
1344 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1345 * @codec: the HDA codec
1347 * Start parsing of the given codec tree and (re-)initialize the whole
1350 * Returns 0 if successful or a negative error code.
1352 int snd_hda_codec_configure(struct hda_codec
*codec
)
1356 codec
->preset
= find_codec_preset(codec
);
1357 if (!codec
->vendor_name
|| !codec
->chip_name
) {
1358 err
= get_codec_name(codec
);
1363 if (is_generic_config(codec
)) {
1364 err
= snd_hda_parse_generic_codec(codec
);
1367 if (codec
->preset
&& codec
->preset
->patch
) {
1368 err
= codec
->preset
->patch(codec
);
1372 /* call the default parser */
1373 err
= snd_hda_parse_generic_codec(codec
);
1375 printk(KERN_ERR
"hda-codec: No codec parser is available\n");
1378 if (!err
&& codec
->patch_ops
.unsol_event
)
1379 err
= init_unsol_queue(codec
->bus
);
1380 /* audio codec should override the mixer name */
1381 if (!err
&& (codec
->afg
|| !*codec
->bus
->card
->mixername
))
1382 snprintf(codec
->bus
->card
->mixername
,
1383 sizeof(codec
->bus
->card
->mixername
),
1384 "%s %s", codec
->vendor_name
, codec
->chip_name
);
1387 EXPORT_SYMBOL_HDA(snd_hda_codec_configure
);
1390 * snd_hda_codec_setup_stream - set up the codec for streaming
1391 * @codec: the CODEC to set up
1392 * @nid: the NID to set up
1393 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1394 * @channel_id: channel id to pass, zero based.
1395 * @format: stream format.
1397 void snd_hda_codec_setup_stream(struct hda_codec
*codec
, hda_nid_t nid
,
1399 int channel_id
, int format
)
1401 struct hda_codec
*c
;
1402 struct hda_cvt_setup
*p
;
1403 unsigned int oldval
, newval
;
1410 snd_printdd("hda_codec_setup_stream: "
1411 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1412 nid
, stream_tag
, channel_id
, format
);
1413 p
= get_hda_cvt_setup(codec
, nid
);
1416 /* update the stream-id if changed */
1417 if (p
->stream_tag
!= stream_tag
|| p
->channel_id
!= channel_id
) {
1418 oldval
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_CONV
, 0);
1419 newval
= (stream_tag
<< 4) | channel_id
;
1420 if (oldval
!= newval
)
1421 snd_hda_codec_write(codec
, nid
, 0,
1422 AC_VERB_SET_CHANNEL_STREAMID
,
1424 p
->stream_tag
= stream_tag
;
1425 p
->channel_id
= channel_id
;
1427 /* update the format-id if changed */
1428 if (p
->format_id
!= format
) {
1429 oldval
= snd_hda_codec_read(codec
, nid
, 0,
1430 AC_VERB_GET_STREAM_FORMAT
, 0);
1431 if (oldval
!= format
) {
1433 snd_hda_codec_write(codec
, nid
, 0,
1434 AC_VERB_SET_STREAM_FORMAT
,
1437 p
->format_id
= format
;
1442 /* make other inactive cvts with the same stream-tag dirty */
1443 type
= get_wcaps_type(get_wcaps(codec
, nid
));
1444 list_for_each_entry(c
, &codec
->bus
->codec_list
, list
) {
1445 for (i
= 0; i
< c
->cvt_setups
.used
; i
++) {
1446 p
= snd_array_elem(&c
->cvt_setups
, i
);
1447 if (!p
->active
&& p
->stream_tag
== stream_tag
&&
1448 get_wcaps_type(get_wcaps(codec
, p
->nid
)) == type
)
1453 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream
);
1455 static void really_cleanup_stream(struct hda_codec
*codec
,
1456 struct hda_cvt_setup
*q
);
1459 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1460 * @codec: the CODEC to clean up
1461 * @nid: the NID to clean up
1462 * @do_now: really clean up the stream instead of clearing the active flag
1464 void __snd_hda_codec_cleanup_stream(struct hda_codec
*codec
, hda_nid_t nid
,
1467 struct hda_cvt_setup
*p
;
1472 if (codec
->no_sticky_stream
)
1475 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid
);
1476 p
= get_hda_cvt_setup(codec
, nid
);
1478 /* here we just clear the active flag when do_now isn't set;
1479 * actual clean-ups will be done later in
1480 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1483 really_cleanup_stream(codec
, p
);
1488 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream
);
1490 static void really_cleanup_stream(struct hda_codec
*codec
,
1491 struct hda_cvt_setup
*q
)
1493 hda_nid_t nid
= q
->nid
;
1494 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CHANNEL_STREAMID
, 0);
1495 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_STREAM_FORMAT
, 0);
1496 memset(q
, 0, sizeof(*q
));
1500 /* clean up the all conflicting obsolete streams */
1501 static void purify_inactive_streams(struct hda_codec
*codec
)
1503 struct hda_codec
*c
;
1506 list_for_each_entry(c
, &codec
->bus
->codec_list
, list
) {
1507 for (i
= 0; i
< c
->cvt_setups
.used
; i
++) {
1508 struct hda_cvt_setup
*p
;
1509 p
= snd_array_elem(&c
->cvt_setups
, i
);
1511 really_cleanup_stream(c
, p
);
1517 /* clean up all streams; called from suspend */
1518 static void hda_cleanup_all_streams(struct hda_codec
*codec
)
1522 for (i
= 0; i
< codec
->cvt_setups
.used
; i
++) {
1523 struct hda_cvt_setup
*p
= snd_array_elem(&codec
->cvt_setups
, i
);
1525 really_cleanup_stream(codec
, p
);
1531 * amp access functions
1534 /* FIXME: more better hash key? */
1535 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1536 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1537 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1538 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1539 #define INFO_AMP_CAPS (1<<0)
1540 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1542 /* initialize the hash table */
1543 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec
*cache
,
1544 unsigned int record_size
)
1546 memset(cache
, 0, sizeof(*cache
));
1547 memset(cache
->hash
, 0xff, sizeof(cache
->hash
));
1548 snd_array_init(&cache
->buf
, record_size
, 64);
1551 static void free_hda_cache(struct hda_cache_rec
*cache
)
1553 snd_array_free(&cache
->buf
);
1556 /* query the hash. allocate an entry if not found. */
1557 static struct hda_cache_head
*get_hash(struct hda_cache_rec
*cache
, u32 key
)
1559 u16 idx
= key
% (u16
)ARRAY_SIZE(cache
->hash
);
1560 u16 cur
= cache
->hash
[idx
];
1561 struct hda_cache_head
*info
;
1563 while (cur
!= 0xffff) {
1564 info
= snd_array_elem(&cache
->buf
, cur
);
1565 if (info
->key
== key
)
1572 /* query the hash. allocate an entry if not found. */
1573 static struct hda_cache_head
*get_alloc_hash(struct hda_cache_rec
*cache
,
1576 struct hda_cache_head
*info
= get_hash(cache
, key
);
1579 /* add a new hash entry */
1580 info
= snd_array_new(&cache
->buf
);
1583 cur
= snd_array_index(&cache
->buf
, info
);
1586 idx
= key
% (u16
)ARRAY_SIZE(cache
->hash
);
1587 info
->next
= cache
->hash
[idx
];
1588 cache
->hash
[idx
] = cur
;
1593 /* query and allocate an amp hash entry */
1594 static inline struct hda_amp_info
*
1595 get_alloc_amp_hash(struct hda_codec
*codec
, u32 key
)
1597 return (struct hda_amp_info
*)get_alloc_hash(&codec
->amp_cache
, key
);
1601 * query_amp_caps - query AMP capabilities
1602 * @codec: the HD-auio codec
1603 * @nid: the NID to query
1604 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1606 * Query AMP capabilities for the given widget and direction.
1607 * Returns the obtained capability bits.
1609 * When cap bits have been already read, this doesn't read again but
1610 * returns the cached value.
1612 u32
query_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int direction
)
1614 struct hda_amp_info
*info
;
1616 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, 0));
1619 if (!(info
->head
.val
& INFO_AMP_CAPS
)) {
1620 if (!(get_wcaps(codec
, nid
) & AC_WCAP_AMP_OVRD
))
1622 info
->amp_caps
= snd_hda_param_read(codec
, nid
,
1623 direction
== HDA_OUTPUT
?
1624 AC_PAR_AMP_OUT_CAP
:
1627 info
->head
.val
|= INFO_AMP_CAPS
;
1629 return info
->amp_caps
;
1631 EXPORT_SYMBOL_HDA(query_amp_caps
);
1634 * snd_hda_override_amp_caps - Override the AMP capabilities
1635 * @codec: the CODEC to clean up
1636 * @nid: the NID to clean up
1637 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1638 * @caps: the capability bits to set
1640 * Override the cached AMP caps bits value by the given one.
1641 * This function is useful if the driver needs to adjust the AMP ranges,
1642 * e.g. limit to 0dB, etc.
1644 * Returns zero if successful or a negative error code.
1646 int snd_hda_override_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1649 struct hda_amp_info
*info
;
1651 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, dir
, 0));
1654 info
->amp_caps
= caps
;
1655 info
->head
.val
|= INFO_AMP_CAPS
;
1658 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps
);
1661 query_caps_hash(struct hda_codec
*codec
, hda_nid_t nid
, u32 key
,
1662 unsigned int (*func
)(struct hda_codec
*, hda_nid_t
))
1664 struct hda_amp_info
*info
;
1666 info
= get_alloc_amp_hash(codec
, key
);
1669 if (!info
->head
.val
) {
1670 info
->head
.val
|= INFO_AMP_CAPS
;
1671 info
->amp_caps
= func(codec
, nid
);
1673 return info
->amp_caps
;
1676 static unsigned int read_pin_cap(struct hda_codec
*codec
, hda_nid_t nid
)
1678 return snd_hda_param_read(codec
, nid
, AC_PAR_PIN_CAP
);
1682 * snd_hda_query_pin_caps - Query PIN capabilities
1683 * @codec: the HD-auio codec
1684 * @nid: the NID to query
1686 * Query PIN capabilities for the given widget.
1687 * Returns the obtained capability bits.
1689 * When cap bits have been already read, this doesn't read again but
1690 * returns the cached value.
1692 u32
snd_hda_query_pin_caps(struct hda_codec
*codec
, hda_nid_t nid
)
1694 return query_caps_hash(codec
, nid
, HDA_HASH_PINCAP_KEY(nid
),
1697 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps
);
1700 * snd_hda_override_pin_caps - Override the pin capabilities
1702 * @nid: the NID to override
1703 * @caps: the capability bits to set
1705 * Override the cached PIN capabilitiy bits value by the given one.
1707 * Returns zero if successful or a negative error code.
1709 int snd_hda_override_pin_caps(struct hda_codec
*codec
, hda_nid_t nid
,
1712 struct hda_amp_info
*info
;
1713 info
= get_alloc_amp_hash(codec
, HDA_HASH_PINCAP_KEY(nid
));
1716 info
->amp_caps
= caps
;
1717 info
->head
.val
|= INFO_AMP_CAPS
;
1720 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps
);
1723 * snd_hda_pin_sense - execute pin sense measurement
1724 * @codec: the CODEC to sense
1725 * @nid: the pin NID to sense
1727 * Execute necessary pin sense measurement and return its Presence Detect,
1728 * Impedance, ELD Valid etc. status bits.
1730 u32
snd_hda_pin_sense(struct hda_codec
*codec
, hda_nid_t nid
)
1734 if (!codec
->no_trigger_sense
) {
1735 pincap
= snd_hda_query_pin_caps(codec
, nid
);
1736 if (pincap
& AC_PINCAP_TRIG_REQ
) /* need trigger? */
1737 snd_hda_codec_read(codec
, nid
, 0,
1738 AC_VERB_SET_PIN_SENSE
, 0);
1740 return snd_hda_codec_read(codec
, nid
, 0,
1741 AC_VERB_GET_PIN_SENSE
, 0);
1743 EXPORT_SYMBOL_HDA(snd_hda_pin_sense
);
1746 * snd_hda_jack_detect - query pin Presence Detect status
1747 * @codec: the CODEC to sense
1748 * @nid: the pin NID to sense
1750 * Query and return the pin's Presence Detect status.
1752 int snd_hda_jack_detect(struct hda_codec
*codec
, hda_nid_t nid
)
1754 u32 sense
= snd_hda_pin_sense(codec
, nid
);
1755 return !!(sense
& AC_PINSENSE_PRESENCE
);
1757 EXPORT_SYMBOL_HDA(snd_hda_jack_detect
);
1760 * read the current volume to info
1761 * if the cache exists, read the cache value.
1763 static unsigned int get_vol_mute(struct hda_codec
*codec
,
1764 struct hda_amp_info
*info
, hda_nid_t nid
,
1765 int ch
, int direction
, int index
)
1769 if (info
->head
.val
& INFO_AMP_VOL(ch
))
1770 return info
->vol
[ch
];
1772 parm
= ch
? AC_AMP_GET_RIGHT
: AC_AMP_GET_LEFT
;
1773 parm
|= direction
== HDA_OUTPUT
? AC_AMP_GET_OUTPUT
: AC_AMP_GET_INPUT
;
1775 val
= snd_hda_codec_read(codec
, nid
, 0,
1776 AC_VERB_GET_AMP_GAIN_MUTE
, parm
);
1777 info
->vol
[ch
] = val
& 0xff;
1778 info
->head
.val
|= INFO_AMP_VOL(ch
);
1779 return info
->vol
[ch
];
1783 * write the current volume in info to the h/w and update the cache
1785 static void put_vol_mute(struct hda_codec
*codec
, struct hda_amp_info
*info
,
1786 hda_nid_t nid
, int ch
, int direction
, int index
,
1791 parm
= ch
? AC_AMP_SET_RIGHT
: AC_AMP_SET_LEFT
;
1792 parm
|= direction
== HDA_OUTPUT
? AC_AMP_SET_OUTPUT
: AC_AMP_SET_INPUT
;
1793 parm
|= index
<< AC_AMP_SET_INDEX_SHIFT
;
1795 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, parm
);
1796 info
->vol
[ch
] = val
;
1800 * snd_hda_codec_amp_read - Read AMP value
1801 * @codec: HD-audio codec
1802 * @nid: NID to read the AMP value
1803 * @ch: channel (left=0 or right=1)
1804 * @direction: #HDA_INPUT or #HDA_OUTPUT
1805 * @index: the index value (only for input direction)
1807 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1809 int snd_hda_codec_amp_read(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1810 int direction
, int index
)
1812 struct hda_amp_info
*info
;
1813 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, index
));
1816 return get_vol_mute(codec
, info
, nid
, ch
, direction
, index
);
1818 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read
);
1821 * snd_hda_codec_amp_update - update the AMP value
1822 * @codec: HD-audio codec
1823 * @nid: NID to read the AMP value
1824 * @ch: channel (left=0 or right=1)
1825 * @direction: #HDA_INPUT or #HDA_OUTPUT
1826 * @idx: the index value (only for input direction)
1827 * @mask: bit mask to set
1828 * @val: the bits value to set
1830 * Update the AMP value with a bit mask.
1831 * Returns 0 if the value is unchanged, 1 if changed.
1833 int snd_hda_codec_amp_update(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1834 int direction
, int idx
, int mask
, int val
)
1836 struct hda_amp_info
*info
;
1838 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, idx
));
1841 if (snd_BUG_ON(mask
& ~0xff))
1844 val
|= get_vol_mute(codec
, info
, nid
, ch
, direction
, idx
) & ~mask
;
1845 if (info
->vol
[ch
] == val
)
1847 put_vol_mute(codec
, info
, nid
, ch
, direction
, idx
, val
);
1850 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update
);
1853 * snd_hda_codec_amp_stereo - update the AMP stereo values
1854 * @codec: HD-audio codec
1855 * @nid: NID to read the AMP value
1856 * @direction: #HDA_INPUT or #HDA_OUTPUT
1857 * @idx: the index value (only for input direction)
1858 * @mask: bit mask to set
1859 * @val: the bits value to set
1861 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1862 * stereo widget with the same mask and value.
1864 int snd_hda_codec_amp_stereo(struct hda_codec
*codec
, hda_nid_t nid
,
1865 int direction
, int idx
, int mask
, int val
)
1869 if (snd_BUG_ON(mask
& ~0xff))
1871 for (ch
= 0; ch
< 2; ch
++)
1872 ret
|= snd_hda_codec_amp_update(codec
, nid
, ch
, direction
,
1876 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo
);
1880 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1881 * @codec: HD-audio codec
1883 * Resume the all amp commands from the cache.
1885 void snd_hda_codec_resume_amp(struct hda_codec
*codec
)
1887 struct hda_amp_info
*buffer
= codec
->amp_cache
.buf
.list
;
1890 for (i
= 0; i
< codec
->amp_cache
.buf
.used
; i
++, buffer
++) {
1891 u32 key
= buffer
->head
.key
;
1893 unsigned int idx
, dir
, ch
;
1897 idx
= (key
>> 16) & 0xff;
1898 dir
= (key
>> 24) & 0xff;
1899 for (ch
= 0; ch
< 2; ch
++) {
1900 if (!(buffer
->head
.val
& INFO_AMP_VOL(ch
)))
1902 put_vol_mute(codec
, buffer
, nid
, ch
, dir
, idx
,
1907 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp
);
1908 #endif /* CONFIG_PM */
1910 static u32
get_amp_max_value(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1913 u32 caps
= query_amp_caps(codec
, nid
, dir
);
1915 caps
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1922 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1924 * The control element is supposed to have the private_value field
1925 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1927 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol
*kcontrol
,
1928 struct snd_ctl_elem_info
*uinfo
)
1930 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1931 u16 nid
= get_amp_nid(kcontrol
);
1932 u8 chs
= get_amp_channels(kcontrol
);
1933 int dir
= get_amp_direction(kcontrol
);
1934 unsigned int ofs
= get_amp_offset(kcontrol
);
1936 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1937 uinfo
->count
= chs
== 3 ? 2 : 1;
1938 uinfo
->value
.integer
.min
= 0;
1939 uinfo
->value
.integer
.max
= get_amp_max_value(codec
, nid
, dir
, ofs
);
1940 if (!uinfo
->value
.integer
.max
) {
1941 printk(KERN_WARNING
"hda_codec: "
1942 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid
,
1948 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info
);
1951 static inline unsigned int
1952 read_amp_value(struct hda_codec
*codec
, hda_nid_t nid
,
1953 int ch
, int dir
, int idx
, unsigned int ofs
)
1956 val
= snd_hda_codec_amp_read(codec
, nid
, ch
, dir
, idx
);
1957 val
&= HDA_AMP_VOLMASK
;
1966 update_amp_value(struct hda_codec
*codec
, hda_nid_t nid
,
1967 int ch
, int dir
, int idx
, unsigned int ofs
,
1970 unsigned int maxval
;
1974 /* ofs = 0: raw max value */
1975 maxval
= get_amp_max_value(codec
, nid
, dir
, 0);
1978 return snd_hda_codec_amp_update(codec
, nid
, ch
, dir
, idx
,
1979 HDA_AMP_VOLMASK
, val
);
1983 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1985 * The control element is supposed to have the private_value field
1986 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1988 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol
*kcontrol
,
1989 struct snd_ctl_elem_value
*ucontrol
)
1991 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1992 hda_nid_t nid
= get_amp_nid(kcontrol
);
1993 int chs
= get_amp_channels(kcontrol
);
1994 int dir
= get_amp_direction(kcontrol
);
1995 int idx
= get_amp_index(kcontrol
);
1996 unsigned int ofs
= get_amp_offset(kcontrol
);
1997 long *valp
= ucontrol
->value
.integer
.value
;
2000 *valp
++ = read_amp_value(codec
, nid
, 0, dir
, idx
, ofs
);
2002 *valp
= read_amp_value(codec
, nid
, 1, dir
, idx
, ofs
);
2005 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get
);
2008 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2010 * The control element is supposed to have the private_value field
2011 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2013 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol
*kcontrol
,
2014 struct snd_ctl_elem_value
*ucontrol
)
2016 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2017 hda_nid_t nid
= get_amp_nid(kcontrol
);
2018 int chs
= get_amp_channels(kcontrol
);
2019 int dir
= get_amp_direction(kcontrol
);
2020 int idx
= get_amp_index(kcontrol
);
2021 unsigned int ofs
= get_amp_offset(kcontrol
);
2022 long *valp
= ucontrol
->value
.integer
.value
;
2025 snd_hda_power_up(codec
);
2027 change
= update_amp_value(codec
, nid
, 0, dir
, idx
, ofs
, *valp
);
2031 change
|= update_amp_value(codec
, nid
, 1, dir
, idx
, ofs
, *valp
);
2032 snd_hda_power_down(codec
);
2035 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put
);
2038 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2040 * The control element is supposed to have the private_value field
2041 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2043 int snd_hda_mixer_amp_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
2044 unsigned int size
, unsigned int __user
*_tlv
)
2046 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2047 hda_nid_t nid
= get_amp_nid(kcontrol
);
2048 int dir
= get_amp_direction(kcontrol
);
2049 unsigned int ofs
= get_amp_offset(kcontrol
);
2050 bool min_mute
= get_amp_min_mute(kcontrol
);
2051 u32 caps
, val1
, val2
;
2053 if (size
< 4 * sizeof(unsigned int))
2055 caps
= query_amp_caps(codec
, nid
, dir
);
2056 val2
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
2057 val2
= (val2
+ 1) * 25;
2058 val1
= -((caps
& AC_AMPCAP_OFFSET
) >> AC_AMPCAP_OFFSET_SHIFT
);
2060 val1
= ((int)val1
) * ((int)val2
);
2062 val2
|= TLV_DB_SCALE_MUTE
;
2063 if (put_user(SNDRV_CTL_TLVT_DB_SCALE
, _tlv
))
2065 if (put_user(2 * sizeof(unsigned int), _tlv
+ 1))
2067 if (put_user(val1
, _tlv
+ 2))
2069 if (put_user(val2
, _tlv
+ 3))
2073 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv
);
2076 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2077 * @codec: HD-audio codec
2078 * @nid: NID of a reference widget
2079 * @dir: #HDA_INPUT or #HDA_OUTPUT
2080 * @tlv: TLV data to be stored, at least 4 elements
2082 * Set (static) TLV data for a virtual master volume using the AMP caps
2083 * obtained from the reference NID.
2084 * The volume range is recalculated as if the max volume is 0dB.
2086 void snd_hda_set_vmaster_tlv(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
2092 caps
= query_amp_caps(codec
, nid
, dir
);
2093 nums
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
2094 step
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
2095 step
= (step
+ 1) * 25;
2096 tlv
[0] = SNDRV_CTL_TLVT_DB_SCALE
;
2097 tlv
[1] = 2 * sizeof(unsigned int);
2098 tlv
[2] = -nums
* step
;
2101 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv
);
2103 /* find a mixer control element with the given name */
2104 static struct snd_kcontrol
*
2105 _snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
2106 const char *name
, int idx
)
2108 struct snd_ctl_elem_id id
;
2109 memset(&id
, 0, sizeof(id
));
2110 id
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
2112 if (snd_BUG_ON(strlen(name
) >= sizeof(id
.name
)))
2114 strcpy(id
.name
, name
);
2115 return snd_ctl_find_id(codec
->bus
->card
, &id
);
2119 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2120 * @codec: HD-audio codec
2121 * @name: ctl id name string
2123 * Get the control element with the given id string and IFACE_MIXER.
2125 struct snd_kcontrol
*snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
2128 return _snd_hda_find_mixer_ctl(codec
, name
, 0);
2130 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl
);
2132 static int find_empty_mixer_ctl_idx(struct hda_codec
*codec
, const char *name
)
2135 for (idx
= 0; idx
< 16; idx
++) { /* 16 ctlrs should be large enough */
2136 if (!_snd_hda_find_mixer_ctl(codec
, name
, idx
))
2143 * snd_hda_ctl_add - Add a control element and assign to the codec
2144 * @codec: HD-audio codec
2145 * @nid: corresponding NID (optional)
2146 * @kctl: the control element to assign
2148 * Add the given control element to an array inside the codec instance.
2149 * All control elements belonging to a codec are supposed to be added
2150 * by this function so that a proper clean-up works at the free or
2151 * reconfiguration time.
2153 * If non-zero @nid is passed, the NID is assigned to the control element.
2154 * The assignment is shown in the codec proc file.
2156 * snd_hda_ctl_add() checks the control subdev id field whether
2157 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2158 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2159 * specifies if kctl->private_value is a HDA amplifier value.
2161 int snd_hda_ctl_add(struct hda_codec
*codec
, hda_nid_t nid
,
2162 struct snd_kcontrol
*kctl
)
2165 unsigned short flags
= 0;
2166 struct hda_nid_item
*item
;
2168 if (kctl
->id
.subdevice
& HDA_SUBDEV_AMP_FLAG
) {
2169 flags
|= HDA_NID_ITEM_AMP
;
2171 nid
= get_amp_nid_(kctl
->private_value
);
2173 if ((kctl
->id
.subdevice
& HDA_SUBDEV_NID_FLAG
) != 0 && nid
== 0)
2174 nid
= kctl
->id
.subdevice
& 0xffff;
2175 if (kctl
->id
.subdevice
& (HDA_SUBDEV_NID_FLAG
|HDA_SUBDEV_AMP_FLAG
))
2176 kctl
->id
.subdevice
= 0;
2177 err
= snd_ctl_add(codec
->bus
->card
, kctl
);
2180 item
= snd_array_new(&codec
->mixers
);
2185 item
->flags
= flags
;
2188 EXPORT_SYMBOL_HDA(snd_hda_ctl_add
);
2191 * snd_hda_add_nid - Assign a NID to a control element
2192 * @codec: HD-audio codec
2193 * @nid: corresponding NID (optional)
2194 * @kctl: the control element to assign
2195 * @index: index to kctl
2197 * Add the given control element to an array inside the codec instance.
2198 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2199 * NID:KCTL mapping - for example "Capture Source" selector.
2201 int snd_hda_add_nid(struct hda_codec
*codec
, struct snd_kcontrol
*kctl
,
2202 unsigned int index
, hda_nid_t nid
)
2204 struct hda_nid_item
*item
;
2207 item
= snd_array_new(&codec
->nids
);
2211 item
->index
= index
;
2215 printk(KERN_ERR
"hda-codec: no NID for mapping control %s:%d:%d\n",
2216 kctl
->id
.name
, kctl
->id
.index
, index
);
2219 EXPORT_SYMBOL_HDA(snd_hda_add_nid
);
2222 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2223 * @codec: HD-audio codec
2225 void snd_hda_ctls_clear(struct hda_codec
*codec
)
2228 struct hda_nid_item
*items
= codec
->mixers
.list
;
2229 for (i
= 0; i
< codec
->mixers
.used
; i
++)
2230 snd_ctl_remove(codec
->bus
->card
, items
[i
].kctl
);
2231 snd_array_free(&codec
->mixers
);
2232 snd_array_free(&codec
->nids
);
2235 /* pseudo device locking
2236 * toggle card->shutdown to allow/disallow the device access (as a hack)
2238 static int hda_lock_devices(struct snd_card
*card
)
2240 spin_lock(&card
->files_lock
);
2241 if (card
->shutdown
) {
2242 spin_unlock(&card
->files_lock
);
2246 spin_unlock(&card
->files_lock
);
2250 static void hda_unlock_devices(struct snd_card
*card
)
2252 spin_lock(&card
->files_lock
);
2254 spin_unlock(&card
->files_lock
);
2258 * snd_hda_codec_reset - Clear all objects assigned to the codec
2259 * @codec: HD-audio codec
2261 * This frees the all PCM and control elements assigned to the codec, and
2262 * clears the caches and restores the pin default configurations.
2264 * When a device is being used, it returns -EBSY. If successfully freed,
2267 int snd_hda_codec_reset(struct hda_codec
*codec
)
2269 struct snd_card
*card
= codec
->bus
->card
;
2272 if (hda_lock_devices(card
) < 0)
2274 /* check whether the codec isn't used by any mixer or PCM streams */
2275 if (!list_empty(&card
->ctl_files
)) {
2276 hda_unlock_devices(card
);
2279 for (pcm
= 0; pcm
< codec
->num_pcms
; pcm
++) {
2280 struct hda_pcm
*cpcm
= &codec
->pcm_info
[pcm
];
2283 if (cpcm
->pcm
->streams
[0].substream_opened
||
2284 cpcm
->pcm
->streams
[1].substream_opened
) {
2285 hda_unlock_devices(card
);
2290 /* OK, let it free */
2292 #ifdef CONFIG_SND_HDA_POWER_SAVE
2293 cancel_delayed_work(&codec
->power_work
);
2294 flush_workqueue(codec
->bus
->workq
);
2296 snd_hda_ctls_clear(codec
);
2298 for (i
= 0; i
< codec
->num_pcms
; i
++) {
2299 if (codec
->pcm_info
[i
].pcm
) {
2300 snd_device_free(card
, codec
->pcm_info
[i
].pcm
);
2301 clear_bit(codec
->pcm_info
[i
].device
,
2302 codec
->bus
->pcm_dev_bits
);
2305 if (codec
->patch_ops
.free
)
2306 codec
->patch_ops
.free(codec
);
2307 codec
->proc_widget_hook
= NULL
;
2309 free_hda_cache(&codec
->amp_cache
);
2310 free_hda_cache(&codec
->cmd_cache
);
2311 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
2312 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
2313 /* free only driver_pins so that init_pins + user_pins are restored */
2314 snd_array_free(&codec
->driver_pins
);
2315 restore_pincfgs(codec
);
2316 codec
->num_pcms
= 0;
2317 codec
->pcm_info
= NULL
;
2318 codec
->preset
= NULL
;
2319 memset(&codec
->patch_ops
, 0, sizeof(codec
->patch_ops
));
2320 codec
->slave_dig_outs
= NULL
;
2321 codec
->spdif_status_reset
= 0;
2322 module_put(codec
->owner
);
2323 codec
->owner
= NULL
;
2325 /* allow device access again */
2326 hda_unlock_devices(card
);
2331 * snd_hda_add_vmaster - create a virtual master control and add slaves
2332 * @codec: HD-audio codec
2333 * @name: vmaster control name
2334 * @tlv: TLV data (optional)
2335 * @slaves: slave control names (optional)
2337 * Create a virtual master control with the given name. The TLV data
2338 * must be either NULL or a valid data.
2340 * @slaves is a NULL-terminated array of strings, each of which is a
2341 * slave control name. All controls with these names are assigned to
2342 * the new virtual master control.
2344 * This function returns zero if successful or a negative error code.
2346 int snd_hda_add_vmaster(struct hda_codec
*codec
, char *name
,
2347 unsigned int *tlv
, const char * const *slaves
)
2349 struct snd_kcontrol
*kctl
;
2350 const char * const *s
;
2353 for (s
= slaves
; *s
&& !snd_hda_find_mixer_ctl(codec
, *s
); s
++)
2356 snd_printdd("No slave found for %s\n", name
);
2359 kctl
= snd_ctl_make_virtual_master(name
, tlv
);
2362 err
= snd_hda_ctl_add(codec
, 0, kctl
);
2366 for (s
= slaves
; *s
; s
++) {
2367 struct snd_kcontrol
*sctl
;
2370 sctl
= _snd_hda_find_mixer_ctl(codec
, *s
, i
);
2373 snd_printdd("Cannot find slave %s, "
2377 err
= snd_ctl_add_slave(kctl
, sctl
);
2385 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster
);
2388 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2390 * The control element is supposed to have the private_value field
2391 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2393 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol
*kcontrol
,
2394 struct snd_ctl_elem_info
*uinfo
)
2396 int chs
= get_amp_channels(kcontrol
);
2398 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
2399 uinfo
->count
= chs
== 3 ? 2 : 1;
2400 uinfo
->value
.integer
.min
= 0;
2401 uinfo
->value
.integer
.max
= 1;
2404 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info
);
2407 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2409 * The control element is supposed to have the private_value field
2410 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2412 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol
*kcontrol
,
2413 struct snd_ctl_elem_value
*ucontrol
)
2415 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2416 hda_nid_t nid
= get_amp_nid(kcontrol
);
2417 int chs
= get_amp_channels(kcontrol
);
2418 int dir
= get_amp_direction(kcontrol
);
2419 int idx
= get_amp_index(kcontrol
);
2420 long *valp
= ucontrol
->value
.integer
.value
;
2423 *valp
++ = (snd_hda_codec_amp_read(codec
, nid
, 0, dir
, idx
) &
2424 HDA_AMP_MUTE
) ? 0 : 1;
2426 *valp
= (snd_hda_codec_amp_read(codec
, nid
, 1, dir
, idx
) &
2427 HDA_AMP_MUTE
) ? 0 : 1;
2430 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get
);
2433 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2435 * The control element is supposed to have the private_value field
2436 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2438 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol
*kcontrol
,
2439 struct snd_ctl_elem_value
*ucontrol
)
2441 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2442 hda_nid_t nid
= get_amp_nid(kcontrol
);
2443 int chs
= get_amp_channels(kcontrol
);
2444 int dir
= get_amp_direction(kcontrol
);
2445 int idx
= get_amp_index(kcontrol
);
2446 long *valp
= ucontrol
->value
.integer
.value
;
2449 snd_hda_power_up(codec
);
2451 change
= snd_hda_codec_amp_update(codec
, nid
, 0, dir
, idx
,
2453 *valp
? 0 : HDA_AMP_MUTE
);
2457 change
|= snd_hda_codec_amp_update(codec
, nid
, 1, dir
, idx
,
2459 *valp
? 0 : HDA_AMP_MUTE
);
2460 hda_call_check_power_status(codec
, nid
);
2461 snd_hda_power_down(codec
);
2464 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put
);
2466 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2468 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2470 * This function calls snd_hda_enable_beep_device(), which behaves differently
2471 * depending on beep_mode option.
2473 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol
*kcontrol
,
2474 struct snd_ctl_elem_value
*ucontrol
)
2476 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2477 long *valp
= ucontrol
->value
.integer
.value
;
2479 snd_hda_enable_beep_device(codec
, *valp
);
2480 return snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
2482 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep
);
2483 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2486 * bound volume controls
2488 * bind multiple volumes (# indices, from 0)
2491 #define AMP_VAL_IDX_SHIFT 19
2492 #define AMP_VAL_IDX_MASK (0x0f<<19)
2495 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2497 * The control element is supposed to have the private_value field
2498 * set up via HDA_BIND_MUTE*() macros.
2500 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol
*kcontrol
,
2501 struct snd_ctl_elem_value
*ucontrol
)
2503 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2507 mutex_lock(&codec
->control_mutex
);
2508 pval
= kcontrol
->private_value
;
2509 kcontrol
->private_value
= pval
& ~AMP_VAL_IDX_MASK
; /* index 0 */
2510 err
= snd_hda_mixer_amp_switch_get(kcontrol
, ucontrol
);
2511 kcontrol
->private_value
= pval
;
2512 mutex_unlock(&codec
->control_mutex
);
2515 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get
);
2518 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2520 * The control element is supposed to have the private_value field
2521 * set up via HDA_BIND_MUTE*() macros.
2523 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol
*kcontrol
,
2524 struct snd_ctl_elem_value
*ucontrol
)
2526 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2528 int i
, indices
, err
= 0, change
= 0;
2530 mutex_lock(&codec
->control_mutex
);
2531 pval
= kcontrol
->private_value
;
2532 indices
= (pval
& AMP_VAL_IDX_MASK
) >> AMP_VAL_IDX_SHIFT
;
2533 for (i
= 0; i
< indices
; i
++) {
2534 kcontrol
->private_value
= (pval
& ~AMP_VAL_IDX_MASK
) |
2535 (i
<< AMP_VAL_IDX_SHIFT
);
2536 err
= snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
2541 kcontrol
->private_value
= pval
;
2542 mutex_unlock(&codec
->control_mutex
);
2543 return err
< 0 ? err
: change
;
2545 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put
);
2548 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2550 * The control element is supposed to have the private_value field
2551 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2553 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol
*kcontrol
,
2554 struct snd_ctl_elem_info
*uinfo
)
2556 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2557 struct hda_bind_ctls
*c
;
2560 mutex_lock(&codec
->control_mutex
);
2561 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2562 kcontrol
->private_value
= *c
->values
;
2563 err
= c
->ops
->info(kcontrol
, uinfo
);
2564 kcontrol
->private_value
= (long)c
;
2565 mutex_unlock(&codec
->control_mutex
);
2568 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info
);
2571 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2573 * The control element is supposed to have the private_value field
2574 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2576 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol
*kcontrol
,
2577 struct snd_ctl_elem_value
*ucontrol
)
2579 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2580 struct hda_bind_ctls
*c
;
2583 mutex_lock(&codec
->control_mutex
);
2584 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2585 kcontrol
->private_value
= *c
->values
;
2586 err
= c
->ops
->get(kcontrol
, ucontrol
);
2587 kcontrol
->private_value
= (long)c
;
2588 mutex_unlock(&codec
->control_mutex
);
2591 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get
);
2594 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2596 * The control element is supposed to have the private_value field
2597 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2599 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol
*kcontrol
,
2600 struct snd_ctl_elem_value
*ucontrol
)
2602 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2603 struct hda_bind_ctls
*c
;
2604 unsigned long *vals
;
2605 int err
= 0, change
= 0;
2607 mutex_lock(&codec
->control_mutex
);
2608 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2609 for (vals
= c
->values
; *vals
; vals
++) {
2610 kcontrol
->private_value
= *vals
;
2611 err
= c
->ops
->put(kcontrol
, ucontrol
);
2616 kcontrol
->private_value
= (long)c
;
2617 mutex_unlock(&codec
->control_mutex
);
2618 return err
< 0 ? err
: change
;
2620 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put
);
2623 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2625 * The control element is supposed to have the private_value field
2626 * set up via HDA_BIND_VOL() macro.
2628 int snd_hda_mixer_bind_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
2629 unsigned int size
, unsigned int __user
*tlv
)
2631 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2632 struct hda_bind_ctls
*c
;
2635 mutex_lock(&codec
->control_mutex
);
2636 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2637 kcontrol
->private_value
= *c
->values
;
2638 err
= c
->ops
->tlv(kcontrol
, op_flag
, size
, tlv
);
2639 kcontrol
->private_value
= (long)c
;
2640 mutex_unlock(&codec
->control_mutex
);
2643 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv
);
2645 struct hda_ctl_ops snd_hda_bind_vol
= {
2646 .info
= snd_hda_mixer_amp_volume_info
,
2647 .get
= snd_hda_mixer_amp_volume_get
,
2648 .put
= snd_hda_mixer_amp_volume_put
,
2649 .tlv
= snd_hda_mixer_amp_tlv
2651 EXPORT_SYMBOL_HDA(snd_hda_bind_vol
);
2653 struct hda_ctl_ops snd_hda_bind_sw
= {
2654 .info
= snd_hda_mixer_amp_switch_info
,
2655 .get
= snd_hda_mixer_amp_switch_get
,
2656 .put
= snd_hda_mixer_amp_switch_put
,
2657 .tlv
= snd_hda_mixer_amp_tlv
2659 EXPORT_SYMBOL_HDA(snd_hda_bind_sw
);
2662 * SPDIF out controls
2665 static int snd_hda_spdif_mask_info(struct snd_kcontrol
*kcontrol
,
2666 struct snd_ctl_elem_info
*uinfo
)
2668 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
2673 static int snd_hda_spdif_cmask_get(struct snd_kcontrol
*kcontrol
,
2674 struct snd_ctl_elem_value
*ucontrol
)
2676 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
2677 IEC958_AES0_NONAUDIO
|
2678 IEC958_AES0_CON_EMPHASIS_5015
|
2679 IEC958_AES0_CON_NOT_COPYRIGHT
;
2680 ucontrol
->value
.iec958
.status
[1] = IEC958_AES1_CON_CATEGORY
|
2681 IEC958_AES1_CON_ORIGINAL
;
2685 static int snd_hda_spdif_pmask_get(struct snd_kcontrol
*kcontrol
,
2686 struct snd_ctl_elem_value
*ucontrol
)
2688 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
2689 IEC958_AES0_NONAUDIO
|
2690 IEC958_AES0_PRO_EMPHASIS_5015
;
2694 static int snd_hda_spdif_default_get(struct snd_kcontrol
*kcontrol
,
2695 struct snd_ctl_elem_value
*ucontrol
)
2697 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2698 int idx
= kcontrol
->private_value
;
2699 struct hda_spdif_out
*spdif
= snd_array_elem(&codec
->spdif_out
, idx
);
2701 ucontrol
->value
.iec958
.status
[0] = spdif
->status
& 0xff;
2702 ucontrol
->value
.iec958
.status
[1] = (spdif
->status
>> 8) & 0xff;
2703 ucontrol
->value
.iec958
.status
[2] = (spdif
->status
>> 16) & 0xff;
2704 ucontrol
->value
.iec958
.status
[3] = (spdif
->status
>> 24) & 0xff;
2709 /* convert from SPDIF status bits to HDA SPDIF bits
2710 * bit 0 (DigEn) is always set zero (to be filled later)
2712 static unsigned short convert_from_spdif_status(unsigned int sbits
)
2714 unsigned short val
= 0;
2716 if (sbits
& IEC958_AES0_PROFESSIONAL
)
2717 val
|= AC_DIG1_PROFESSIONAL
;
2718 if (sbits
& IEC958_AES0_NONAUDIO
)
2719 val
|= AC_DIG1_NONAUDIO
;
2720 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
2721 if ((sbits
& IEC958_AES0_PRO_EMPHASIS
) ==
2722 IEC958_AES0_PRO_EMPHASIS_5015
)
2723 val
|= AC_DIG1_EMPHASIS
;
2725 if ((sbits
& IEC958_AES0_CON_EMPHASIS
) ==
2726 IEC958_AES0_CON_EMPHASIS_5015
)
2727 val
|= AC_DIG1_EMPHASIS
;
2728 if (!(sbits
& IEC958_AES0_CON_NOT_COPYRIGHT
))
2729 val
|= AC_DIG1_COPYRIGHT
;
2730 if (sbits
& (IEC958_AES1_CON_ORIGINAL
<< 8))
2731 val
|= AC_DIG1_LEVEL
;
2732 val
|= sbits
& (IEC958_AES1_CON_CATEGORY
<< 8);
2737 /* convert to SPDIF status bits from HDA SPDIF bits
2739 static unsigned int convert_to_spdif_status(unsigned short val
)
2741 unsigned int sbits
= 0;
2743 if (val
& AC_DIG1_NONAUDIO
)
2744 sbits
|= IEC958_AES0_NONAUDIO
;
2745 if (val
& AC_DIG1_PROFESSIONAL
)
2746 sbits
|= IEC958_AES0_PROFESSIONAL
;
2747 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
2748 if (sbits
& AC_DIG1_EMPHASIS
)
2749 sbits
|= IEC958_AES0_PRO_EMPHASIS_5015
;
2751 if (val
& AC_DIG1_EMPHASIS
)
2752 sbits
|= IEC958_AES0_CON_EMPHASIS_5015
;
2753 if (!(val
& AC_DIG1_COPYRIGHT
))
2754 sbits
|= IEC958_AES0_CON_NOT_COPYRIGHT
;
2755 if (val
& AC_DIG1_LEVEL
)
2756 sbits
|= (IEC958_AES1_CON_ORIGINAL
<< 8);
2757 sbits
|= val
& (0x7f << 8);
2762 /* set digital convert verbs both for the given NID and its slaves */
2763 static void set_dig_out(struct hda_codec
*codec
, hda_nid_t nid
,
2768 snd_hda_codec_write_cache(codec
, nid
, 0, verb
, val
);
2769 d
= codec
->slave_dig_outs
;
2773 snd_hda_codec_write_cache(codec
, *d
, 0, verb
, val
);
2776 static inline void set_dig_out_convert(struct hda_codec
*codec
, hda_nid_t nid
,
2780 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_1
, dig1
);
2782 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_2
, dig2
);
2785 static int snd_hda_spdif_default_put(struct snd_kcontrol
*kcontrol
,
2786 struct snd_ctl_elem_value
*ucontrol
)
2788 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2789 int idx
= kcontrol
->private_value
;
2790 struct hda_spdif_out
*spdif
= snd_array_elem(&codec
->spdif_out
, idx
);
2791 hda_nid_t nid
= spdif
->nid
;
2795 mutex_lock(&codec
->spdif_mutex
);
2796 spdif
->status
= ucontrol
->value
.iec958
.status
[0] |
2797 ((unsigned int)ucontrol
->value
.iec958
.status
[1] << 8) |
2798 ((unsigned int)ucontrol
->value
.iec958
.status
[2] << 16) |
2799 ((unsigned int)ucontrol
->value
.iec958
.status
[3] << 24);
2800 val
= convert_from_spdif_status(spdif
->status
);
2801 val
|= spdif
->ctls
& 1;
2802 change
= spdif
->ctls
!= val
;
2804 if (change
&& nid
!= (u16
)-1)
2805 set_dig_out_convert(codec
, nid
, val
& 0xff, (val
>> 8) & 0xff);
2806 mutex_unlock(&codec
->spdif_mutex
);
2810 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2812 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol
*kcontrol
,
2813 struct snd_ctl_elem_value
*ucontrol
)
2815 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2816 int idx
= kcontrol
->private_value
;
2817 struct hda_spdif_out
*spdif
= snd_array_elem(&codec
->spdif_out
, idx
);
2819 ucontrol
->value
.integer
.value
[0] = spdif
->ctls
& AC_DIG1_ENABLE
;
2823 static inline void set_spdif_ctls(struct hda_codec
*codec
, hda_nid_t nid
,
2826 set_dig_out_convert(codec
, nid
, dig1
, dig2
);
2827 /* unmute amp switch (if any) */
2828 if ((get_wcaps(codec
, nid
) & AC_WCAP_OUT_AMP
) &&
2829 (dig1
& AC_DIG1_ENABLE
))
2830 snd_hda_codec_amp_stereo(codec
, nid
, HDA_OUTPUT
, 0,
2834 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol
*kcontrol
,
2835 struct snd_ctl_elem_value
*ucontrol
)
2837 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2838 int idx
= kcontrol
->private_value
;
2839 struct hda_spdif_out
*spdif
= snd_array_elem(&codec
->spdif_out
, idx
);
2840 hda_nid_t nid
= spdif
->nid
;
2844 mutex_lock(&codec
->spdif_mutex
);
2845 val
= spdif
->ctls
& ~AC_DIG1_ENABLE
;
2846 if (ucontrol
->value
.integer
.value
[0])
2847 val
|= AC_DIG1_ENABLE
;
2848 change
= spdif
->ctls
!= val
;
2850 if (change
&& nid
!= (u16
)-1)
2851 set_spdif_ctls(codec
, nid
, val
& 0xff, -1);
2852 mutex_unlock(&codec
->spdif_mutex
);
2856 static struct snd_kcontrol_new dig_mixes
[] = {
2858 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2859 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2860 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, CON_MASK
),
2861 .info
= snd_hda_spdif_mask_info
,
2862 .get
= snd_hda_spdif_cmask_get
,
2865 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2866 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2867 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, PRO_MASK
),
2868 .info
= snd_hda_spdif_mask_info
,
2869 .get
= snd_hda_spdif_pmask_get
,
2872 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2873 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, DEFAULT
),
2874 .info
= snd_hda_spdif_mask_info
,
2875 .get
= snd_hda_spdif_default_get
,
2876 .put
= snd_hda_spdif_default_put
,
2879 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2880 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, SWITCH
),
2881 .info
= snd_hda_spdif_out_switch_info
,
2882 .get
= snd_hda_spdif_out_switch_get
,
2883 .put
= snd_hda_spdif_out_switch_put
,
2889 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2890 * @codec: the HDA codec
2891 * @nid: audio out widget NID
2893 * Creates controls related with the SPDIF output.
2894 * Called from each patch supporting the SPDIF out.
2896 * Returns 0 if successful, or a negative error code.
2898 int snd_hda_create_spdif_out_ctls(struct hda_codec
*codec
,
2899 hda_nid_t associated_nid
,
2903 struct snd_kcontrol
*kctl
;
2904 struct snd_kcontrol_new
*dig_mix
;
2906 struct hda_spdif_out
*spdif
;
2908 idx
= find_empty_mixer_ctl_idx(codec
, "IEC958 Playback Switch");
2910 printk(KERN_ERR
"hda_codec: too many IEC958 outputs\n");
2913 spdif
= snd_array_new(&codec
->spdif_out
);
2914 for (dig_mix
= dig_mixes
; dig_mix
->name
; dig_mix
++) {
2915 kctl
= snd_ctl_new1(dig_mix
, codec
);
2918 kctl
->id
.index
= idx
;
2919 kctl
->private_value
= codec
->spdif_out
.used
- 1;
2920 err
= snd_hda_ctl_add(codec
, associated_nid
, kctl
);
2924 spdif
->nid
= cvt_nid
;
2925 spdif
->ctls
= snd_hda_codec_read(codec
, cvt_nid
, 0,
2926 AC_VERB_GET_DIGI_CONVERT_1
, 0);
2927 spdif
->status
= convert_to_spdif_status(spdif
->ctls
);
2930 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls
);
2932 struct hda_spdif_out
*snd_hda_spdif_out_of_nid(struct hda_codec
*codec
,
2936 for (i
= 0; i
< codec
->spdif_out
.used
; i
++) {
2937 struct hda_spdif_out
*spdif
=
2938 snd_array_elem(&codec
->spdif_out
, i
);
2939 if (spdif
->nid
== nid
)
2944 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid
);
2946 void snd_hda_spdif_ctls_unassign(struct hda_codec
*codec
, int idx
)
2948 struct hda_spdif_out
*spdif
= snd_array_elem(&codec
->spdif_out
, idx
);
2950 mutex_lock(&codec
->spdif_mutex
);
2951 spdif
->nid
= (u16
)-1;
2952 mutex_unlock(&codec
->spdif_mutex
);
2954 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign
);
2956 void snd_hda_spdif_ctls_assign(struct hda_codec
*codec
, int idx
, hda_nid_t nid
)
2958 struct hda_spdif_out
*spdif
= snd_array_elem(&codec
->spdif_out
, idx
);
2961 mutex_lock(&codec
->spdif_mutex
);
2962 if (spdif
->nid
!= nid
) {
2965 set_spdif_ctls(codec
, nid
, val
& 0xff, (val
>> 8) & 0xff);
2967 mutex_unlock(&codec
->spdif_mutex
);
2969 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign
);
2972 * SPDIF sharing with analog output
2974 static int spdif_share_sw_get(struct snd_kcontrol
*kcontrol
,
2975 struct snd_ctl_elem_value
*ucontrol
)
2977 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
2978 ucontrol
->value
.integer
.value
[0] = mout
->share_spdif
;
2982 static int spdif_share_sw_put(struct snd_kcontrol
*kcontrol
,
2983 struct snd_ctl_elem_value
*ucontrol
)
2985 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
2986 mout
->share_spdif
= !!ucontrol
->value
.integer
.value
[0];
2990 static struct snd_kcontrol_new spdif_share_sw
= {
2991 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2992 .name
= "IEC958 Default PCM Playback Switch",
2993 .info
= snd_ctl_boolean_mono_info
,
2994 .get
= spdif_share_sw_get
,
2995 .put
= spdif_share_sw_put
,
2999 * snd_hda_create_spdif_share_sw - create Default PCM switch
3000 * @codec: the HDA codec
3001 * @mout: multi-out instance
3003 int snd_hda_create_spdif_share_sw(struct hda_codec
*codec
,
3004 struct hda_multi_out
*mout
)
3006 if (!mout
->dig_out_nid
)
3008 /* ATTENTION: here mout is passed as private_data, instead of codec */
3009 return snd_hda_ctl_add(codec
, mout
->dig_out_nid
,
3010 snd_ctl_new1(&spdif_share_sw
, mout
));
3012 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw
);
3018 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3020 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol
*kcontrol
,
3021 struct snd_ctl_elem_value
*ucontrol
)
3023 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3025 ucontrol
->value
.integer
.value
[0] = codec
->spdif_in_enable
;
3029 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol
*kcontrol
,
3030 struct snd_ctl_elem_value
*ucontrol
)
3032 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3033 hda_nid_t nid
= kcontrol
->private_value
;
3034 unsigned int val
= !!ucontrol
->value
.integer
.value
[0];
3037 mutex_lock(&codec
->spdif_mutex
);
3038 change
= codec
->spdif_in_enable
!= val
;
3040 codec
->spdif_in_enable
= val
;
3041 snd_hda_codec_write_cache(codec
, nid
, 0,
3042 AC_VERB_SET_DIGI_CONVERT_1
, val
);
3044 mutex_unlock(&codec
->spdif_mutex
);
3048 static int snd_hda_spdif_in_status_get(struct snd_kcontrol
*kcontrol
,
3049 struct snd_ctl_elem_value
*ucontrol
)
3051 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3052 hda_nid_t nid
= kcontrol
->private_value
;
3056 val
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_DIGI_CONVERT_1
, 0);
3057 sbits
= convert_to_spdif_status(val
);
3058 ucontrol
->value
.iec958
.status
[0] = sbits
;
3059 ucontrol
->value
.iec958
.status
[1] = sbits
>> 8;
3060 ucontrol
->value
.iec958
.status
[2] = sbits
>> 16;
3061 ucontrol
->value
.iec958
.status
[3] = sbits
>> 24;
3065 static struct snd_kcontrol_new dig_in_ctls
[] = {
3067 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3068 .name
= SNDRV_CTL_NAME_IEC958("", CAPTURE
, SWITCH
),
3069 .info
= snd_hda_spdif_in_switch_info
,
3070 .get
= snd_hda_spdif_in_switch_get
,
3071 .put
= snd_hda_spdif_in_switch_put
,
3074 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
3075 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3076 .name
= SNDRV_CTL_NAME_IEC958("", CAPTURE
, DEFAULT
),
3077 .info
= snd_hda_spdif_mask_info
,
3078 .get
= snd_hda_spdif_in_status_get
,
3084 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3085 * @codec: the HDA codec
3086 * @nid: audio in widget NID
3088 * Creates controls related with the SPDIF input.
3089 * Called from each patch supporting the SPDIF in.
3091 * Returns 0 if successful, or a negative error code.
3093 int snd_hda_create_spdif_in_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
3096 struct snd_kcontrol
*kctl
;
3097 struct snd_kcontrol_new
*dig_mix
;
3100 idx
= find_empty_mixer_ctl_idx(codec
, "IEC958 Capture Switch");
3102 printk(KERN_ERR
"hda_codec: too many IEC958 inputs\n");
3105 for (dig_mix
= dig_in_ctls
; dig_mix
->name
; dig_mix
++) {
3106 kctl
= snd_ctl_new1(dig_mix
, codec
);
3109 kctl
->private_value
= nid
;
3110 err
= snd_hda_ctl_add(codec
, nid
, kctl
);
3114 codec
->spdif_in_enable
=
3115 snd_hda_codec_read(codec
, nid
, 0,
3116 AC_VERB_GET_DIGI_CONVERT_1
, 0) &
3120 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls
);
3127 /* build a 32bit cache key with the widget id and the command parameter */
3128 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3129 #define get_cmd_cache_nid(key) ((key) & 0xff)
3130 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3133 * snd_hda_codec_write_cache - send a single command with caching
3134 * @codec: the HDA codec
3135 * @nid: NID to send the command
3136 * @direct: direct flag
3137 * @verb: the verb to send
3138 * @parm: the parameter for the verb
3140 * Send a single command without waiting for response.
3142 * Returns 0 if successful, or a negative error code.
3144 int snd_hda_codec_write_cache(struct hda_codec
*codec
, hda_nid_t nid
,
3145 int direct
, unsigned int verb
, unsigned int parm
)
3147 int err
= snd_hda_codec_write(codec
, nid
, direct
, verb
, parm
);
3148 struct hda_cache_head
*c
;
3153 /* parm may contain the verb stuff for get/set amp */
3154 verb
= verb
| (parm
>> 8);
3156 key
= build_cmd_cache_key(nid
, verb
);
3157 mutex_lock(&codec
->bus
->cmd_mutex
);
3158 c
= get_alloc_hash(&codec
->cmd_cache
, key
);
3161 mutex_unlock(&codec
->bus
->cmd_mutex
);
3164 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache
);
3167 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3168 * @codec: the HDA codec
3169 * @nid: NID to send the command
3170 * @direct: direct flag
3171 * @verb: the verb to send
3172 * @parm: the parameter for the verb
3174 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3175 * command if the parameter is already identical with the cached value.
3176 * If not, it sends the command and refreshes the cache.
3178 * Returns 0 if successful, or a negative error code.
3180 int snd_hda_codec_update_cache(struct hda_codec
*codec
, hda_nid_t nid
,
3181 int direct
, unsigned int verb
, unsigned int parm
)
3183 struct hda_cache_head
*c
;
3186 /* parm may contain the verb stuff for get/set amp */
3187 verb
= verb
| (parm
>> 8);
3189 key
= build_cmd_cache_key(nid
, verb
);
3190 mutex_lock(&codec
->bus
->cmd_mutex
);
3191 c
= get_hash(&codec
->cmd_cache
, key
);
3192 if (c
&& c
->val
== parm
) {
3193 mutex_unlock(&codec
->bus
->cmd_mutex
);
3196 mutex_unlock(&codec
->bus
->cmd_mutex
);
3197 return snd_hda_codec_write_cache(codec
, nid
, direct
, verb
, parm
);
3199 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache
);
3202 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3203 * @codec: HD-audio codec
3205 * Execute all verbs recorded in the command caches to resume.
3207 void snd_hda_codec_resume_cache(struct hda_codec
*codec
)
3209 struct hda_cache_head
*buffer
= codec
->cmd_cache
.buf
.list
;
3212 for (i
= 0; i
< codec
->cmd_cache
.buf
.used
; i
++, buffer
++) {
3213 u32 key
= buffer
->key
;
3216 snd_hda_codec_write(codec
, get_cmd_cache_nid(key
), 0,
3217 get_cmd_cache_cmd(key
), buffer
->val
);
3220 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache
);
3223 * snd_hda_sequence_write_cache - sequence writes with caching
3224 * @codec: the HDA codec
3225 * @seq: VERB array to send
3227 * Send the commands sequentially from the given array.
3228 * Thte commands are recorded on cache for power-save and resume.
3229 * The array must be terminated with NID=0.
3231 void snd_hda_sequence_write_cache(struct hda_codec
*codec
,
3232 const struct hda_verb
*seq
)
3234 for (; seq
->nid
; seq
++)
3235 snd_hda_codec_write_cache(codec
, seq
->nid
, 0, seq
->verb
,
3238 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache
);
3239 #endif /* CONFIG_PM */
3241 void snd_hda_codec_set_power_to_all(struct hda_codec
*codec
, hda_nid_t fg
,
3242 unsigned int power_state
,
3243 bool eapd_workaround
)
3245 hda_nid_t nid
= codec
->start_nid
;
3248 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
3249 unsigned int wcaps
= get_wcaps(codec
, nid
);
3250 if (!(wcaps
& AC_WCAP_POWER
))
3252 /* don't power down the widget if it controls eapd and
3253 * EAPD_BTLENABLE is set.
3255 if (eapd_workaround
&& power_state
== AC_PWRST_D3
&&
3256 get_wcaps_type(wcaps
) == AC_WID_PIN
&&
3257 (snd_hda_query_pin_caps(codec
, nid
) & AC_PINCAP_EAPD
)) {
3258 int eapd
= snd_hda_codec_read(codec
, nid
, 0,
3259 AC_VERB_GET_EAPD_BTLENABLE
, 0);
3263 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_POWER_STATE
,
3267 if (power_state
== AC_PWRST_D0
) {
3268 unsigned long end_time
;
3270 /* wait until the codec reachs to D0 */
3271 end_time
= jiffies
+ msecs_to_jiffies(500);
3273 state
= snd_hda_codec_read(codec
, fg
, 0,
3274 AC_VERB_GET_POWER_STATE
, 0);
3275 if (state
== power_state
)
3278 } while (time_after_eq(end_time
, jiffies
));
3281 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all
);
3284 * set power state of the codec
3286 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
3287 unsigned int power_state
)
3289 if (codec
->patch_ops
.set_power_state
) {
3290 codec
->patch_ops
.set_power_state(codec
, fg
, power_state
);
3294 /* this delay seems necessary to avoid click noise at power-down */
3295 if (power_state
== AC_PWRST_D3
)
3297 snd_hda_codec_read(codec
, fg
, 0, AC_VERB_SET_POWER_STATE
,
3299 snd_hda_codec_set_power_to_all(codec
, fg
, power_state
, true);
3302 #ifdef CONFIG_SND_HDA_HWDEP
3303 /* execute additional init verbs */
3304 static void hda_exec_init_verbs(struct hda_codec
*codec
)
3306 if (codec
->init_verbs
.list
)
3307 snd_hda_sequence_write(codec
, codec
->init_verbs
.list
);
3310 static inline void hda_exec_init_verbs(struct hda_codec
*codec
) {}
3315 * call suspend and power-down; used both from PM and power-save
3317 static void hda_call_codec_suspend(struct hda_codec
*codec
)
3319 if (codec
->patch_ops
.suspend
)
3320 codec
->patch_ops
.suspend(codec
, PMSG_SUSPEND
);
3321 hda_cleanup_all_streams(codec
);
3322 hda_set_power_state(codec
,
3323 codec
->afg
? codec
->afg
: codec
->mfg
,
3325 #ifdef CONFIG_SND_HDA_POWER_SAVE
3326 snd_hda_update_power_acct(codec
);
3327 cancel_delayed_work(&codec
->power_work
);
3328 codec
->power_on
= 0;
3329 codec
->power_transition
= 0;
3330 codec
->power_jiffies
= jiffies
;
3335 * kick up codec; used both from PM and power-save
3337 static void hda_call_codec_resume(struct hda_codec
*codec
)
3339 hda_set_power_state(codec
,
3340 codec
->afg
? codec
->afg
: codec
->mfg
,
3342 restore_pincfgs(codec
); /* restore all current pin configs */
3343 restore_shutup_pins(codec
);
3344 hda_exec_init_verbs(codec
);
3345 if (codec
->patch_ops
.resume
)
3346 codec
->patch_ops
.resume(codec
);
3348 if (codec
->patch_ops
.init
)
3349 codec
->patch_ops
.init(codec
);
3350 snd_hda_codec_resume_amp(codec
);
3351 snd_hda_codec_resume_cache(codec
);
3354 #endif /* CONFIG_PM */
3358 * snd_hda_build_controls - build mixer controls
3361 * Creates mixer controls for each codec included in the bus.
3363 * Returns 0 if successful, otherwise a negative error code.
3365 int /*__devinit*/ snd_hda_build_controls(struct hda_bus
*bus
)
3367 struct hda_codec
*codec
;
3369 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3370 int err
= snd_hda_codec_build_controls(codec
);
3372 printk(KERN_ERR
"hda_codec: cannot build controls "
3373 "for #%d (error %d)\n", codec
->addr
, err
);
3374 err
= snd_hda_codec_reset(codec
);
3377 "hda_codec: cannot revert codec\n");
3384 EXPORT_SYMBOL_HDA(snd_hda_build_controls
);
3386 int snd_hda_codec_build_controls(struct hda_codec
*codec
)
3389 hda_exec_init_verbs(codec
);
3390 /* continue to initialize... */
3391 if (codec
->patch_ops
.init
)
3392 err
= codec
->patch_ops
.init(codec
);
3393 if (!err
&& codec
->patch_ops
.build_controls
)
3394 err
= codec
->patch_ops
.build_controls(codec
);
3403 struct hda_rate_tbl
{
3405 unsigned int alsa_bits
;
3406 unsigned int hda_fmt
;
3409 /* rate = base * mult / div */
3410 #define HDA_RATE(base, mult, div) \
3411 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3412 (((div) - 1) << AC_FMT_DIV_SHIFT))
3414 static struct hda_rate_tbl rate_bits
[] = {
3415 /* rate in Hz, ALSA rate bitmask, HDA format value */
3417 /* autodetected value used in snd_hda_query_supported_pcm */
3418 { 8000, SNDRV_PCM_RATE_8000
, HDA_RATE(48, 1, 6) },
3419 { 11025, SNDRV_PCM_RATE_11025
, HDA_RATE(44, 1, 4) },
3420 { 16000, SNDRV_PCM_RATE_16000
, HDA_RATE(48, 1, 3) },
3421 { 22050, SNDRV_PCM_RATE_22050
, HDA_RATE(44, 1, 2) },
3422 { 32000, SNDRV_PCM_RATE_32000
, HDA_RATE(48, 2, 3) },
3423 { 44100, SNDRV_PCM_RATE_44100
, HDA_RATE(44, 1, 1) },
3424 { 48000, SNDRV_PCM_RATE_48000
, HDA_RATE(48, 1, 1) },
3425 { 88200, SNDRV_PCM_RATE_88200
, HDA_RATE(44, 2, 1) },
3426 { 96000, SNDRV_PCM_RATE_96000
, HDA_RATE(48, 2, 1) },
3427 { 176400, SNDRV_PCM_RATE_176400
, HDA_RATE(44, 4, 1) },
3428 { 192000, SNDRV_PCM_RATE_192000
, HDA_RATE(48, 4, 1) },
3429 #define AC_PAR_PCM_RATE_BITS 11
3430 /* up to bits 10, 384kHZ isn't supported properly */
3432 /* not autodetected value */
3433 { 9600, SNDRV_PCM_RATE_KNOT
, HDA_RATE(48, 1, 5) },
3435 { 0 } /* terminator */
3439 * snd_hda_calc_stream_format - calculate format bitset
3440 * @rate: the sample rate
3441 * @channels: the number of channels
3442 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3443 * @maxbps: the max. bps
3445 * Calculate the format bitset from the given rate, channels and th PCM format.
3447 * Return zero if invalid.
3449 unsigned int snd_hda_calc_stream_format(unsigned int rate
,
3450 unsigned int channels
,
3451 unsigned int format
,
3452 unsigned int maxbps
,
3453 unsigned short spdif_ctls
)
3456 unsigned int val
= 0;
3458 for (i
= 0; rate_bits
[i
].hz
; i
++)
3459 if (rate_bits
[i
].hz
== rate
) {
3460 val
= rate_bits
[i
].hda_fmt
;
3463 if (!rate_bits
[i
].hz
) {
3464 snd_printdd("invalid rate %d\n", rate
);
3468 if (channels
== 0 || channels
> 8) {
3469 snd_printdd("invalid channels %d\n", channels
);
3472 val
|= channels
- 1;
3474 switch (snd_pcm_format_width(format
)) {
3476 val
|= AC_FMT_BITS_8
;
3479 val
|= AC_FMT_BITS_16
;
3484 if (maxbps
>= 32 || format
== SNDRV_PCM_FORMAT_FLOAT_LE
)
3485 val
|= AC_FMT_BITS_32
;
3486 else if (maxbps
>= 24)
3487 val
|= AC_FMT_BITS_24
;
3489 val
|= AC_FMT_BITS_20
;
3492 snd_printdd("invalid format width %d\n",
3493 snd_pcm_format_width(format
));
3497 if (spdif_ctls
& AC_DIG1_NONAUDIO
)
3498 val
|= AC_FMT_TYPE_NON_PCM
;
3502 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format
);
3504 static unsigned int get_pcm_param(struct hda_codec
*codec
, hda_nid_t nid
)
3506 unsigned int val
= 0;
3507 if (nid
!= codec
->afg
&&
3508 (get_wcaps(codec
, nid
) & AC_WCAP_FORMAT_OVRD
))
3509 val
= snd_hda_param_read(codec
, nid
, AC_PAR_PCM
);
3510 if (!val
|| val
== -1)
3511 val
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_PCM
);
3512 if (!val
|| val
== -1)
3517 static unsigned int query_pcm_param(struct hda_codec
*codec
, hda_nid_t nid
)
3519 return query_caps_hash(codec
, nid
, HDA_HASH_PARPCM_KEY(nid
),
3523 static unsigned int get_stream_param(struct hda_codec
*codec
, hda_nid_t nid
)
3525 unsigned int streams
= snd_hda_param_read(codec
, nid
, AC_PAR_STREAM
);
3526 if (!streams
|| streams
== -1)
3527 streams
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_STREAM
);
3528 if (!streams
|| streams
== -1)
3533 static unsigned int query_stream_param(struct hda_codec
*codec
, hda_nid_t nid
)
3535 return query_caps_hash(codec
, nid
, HDA_HASH_PARSTR_KEY(nid
),
3540 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3541 * @codec: the HDA codec
3542 * @nid: NID to query
3543 * @ratesp: the pointer to store the detected rate bitflags
3544 * @formatsp: the pointer to store the detected formats
3545 * @bpsp: the pointer to store the detected format widths
3547 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3548 * or @bsps argument is ignored.
3550 * Returns 0 if successful, otherwise a negative error code.
3552 int snd_hda_query_supported_pcm(struct hda_codec
*codec
, hda_nid_t nid
,
3553 u32
*ratesp
, u64
*formatsp
, unsigned int *bpsp
)
3555 unsigned int i
, val
, wcaps
;
3557 wcaps
= get_wcaps(codec
, nid
);
3558 val
= query_pcm_param(codec
, nid
);
3562 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++) {
3564 rates
|= rate_bits
[i
].alsa_bits
;
3567 snd_printk(KERN_ERR
"hda_codec: rates == 0 "
3568 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3570 (wcaps
& AC_WCAP_FORMAT_OVRD
) ? 1 : 0);
3576 if (formatsp
|| bpsp
) {
3578 unsigned int streams
, bps
;
3580 streams
= query_stream_param(codec
, nid
);
3585 if (streams
& AC_SUPFMT_PCM
) {
3586 if (val
& AC_SUPPCM_BITS_8
) {
3587 formats
|= SNDRV_PCM_FMTBIT_U8
;
3590 if (val
& AC_SUPPCM_BITS_16
) {
3591 formats
|= SNDRV_PCM_FMTBIT_S16_LE
;
3594 if (wcaps
& AC_WCAP_DIGITAL
) {
3595 if (val
& AC_SUPPCM_BITS_32
)
3596 formats
|= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
;
3597 if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
))
3598 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
3599 if (val
& AC_SUPPCM_BITS_24
)
3601 else if (val
& AC_SUPPCM_BITS_20
)
3603 } else if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
|
3604 AC_SUPPCM_BITS_32
)) {
3605 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
3606 if (val
& AC_SUPPCM_BITS_32
)
3608 else if (val
& AC_SUPPCM_BITS_24
)
3610 else if (val
& AC_SUPPCM_BITS_20
)
3614 if (streams
& AC_SUPFMT_FLOAT32
) {
3615 formats
|= SNDRV_PCM_FMTBIT_FLOAT_LE
;
3619 if (streams
== AC_SUPFMT_AC3
) {
3620 /* should be exclusive */
3621 /* temporary hack: we have still no proper support
3622 * for the direct AC3 stream...
3624 formats
|= SNDRV_PCM_FMTBIT_U8
;
3628 snd_printk(KERN_ERR
"hda_codec: formats == 0 "
3629 "(nid=0x%x, val=0x%x, ovrd=%i, "
3632 (wcaps
& AC_WCAP_FORMAT_OVRD
) ? 1 : 0,
3637 *formatsp
= formats
;
3644 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm
);
3647 * snd_hda_is_supported_format - Check the validity of the format
3648 * @codec: HD-audio codec
3649 * @nid: NID to check
3650 * @format: the HD-audio format value to check
3652 * Check whether the given node supports the format value.
3654 * Returns 1 if supported, 0 if not.
3656 int snd_hda_is_supported_format(struct hda_codec
*codec
, hda_nid_t nid
,
3657 unsigned int format
)
3660 unsigned int val
= 0, rate
, stream
;
3662 val
= query_pcm_param(codec
, nid
);
3666 rate
= format
& 0xff00;
3667 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++)
3668 if (rate_bits
[i
].hda_fmt
== rate
) {
3673 if (i
>= AC_PAR_PCM_RATE_BITS
)
3676 stream
= query_stream_param(codec
, nid
);
3680 if (stream
& AC_SUPFMT_PCM
) {
3681 switch (format
& 0xf0) {
3683 if (!(val
& AC_SUPPCM_BITS_8
))
3687 if (!(val
& AC_SUPPCM_BITS_16
))
3691 if (!(val
& AC_SUPPCM_BITS_20
))
3695 if (!(val
& AC_SUPPCM_BITS_24
))
3699 if (!(val
& AC_SUPPCM_BITS_32
))
3706 /* FIXME: check for float32 and AC3? */
3711 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format
);
3716 static int hda_pcm_default_open_close(struct hda_pcm_stream
*hinfo
,
3717 struct hda_codec
*codec
,
3718 struct snd_pcm_substream
*substream
)
3723 static int hda_pcm_default_prepare(struct hda_pcm_stream
*hinfo
,
3724 struct hda_codec
*codec
,
3725 unsigned int stream_tag
,
3726 unsigned int format
,
3727 struct snd_pcm_substream
*substream
)
3729 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, stream_tag
, 0, format
);
3733 static int hda_pcm_default_cleanup(struct hda_pcm_stream
*hinfo
,
3734 struct hda_codec
*codec
,
3735 struct snd_pcm_substream
*substream
)
3737 snd_hda_codec_cleanup_stream(codec
, hinfo
->nid
);
3741 static int set_pcm_default_values(struct hda_codec
*codec
,
3742 struct hda_pcm_stream
*info
)
3746 /* query support PCM information from the given NID */
3747 if (info
->nid
&& (!info
->rates
|| !info
->formats
)) {
3748 err
= snd_hda_query_supported_pcm(codec
, info
->nid
,
3749 info
->rates
? NULL
: &info
->rates
,
3750 info
->formats
? NULL
: &info
->formats
,
3751 info
->maxbps
? NULL
: &info
->maxbps
);
3755 if (info
->ops
.open
== NULL
)
3756 info
->ops
.open
= hda_pcm_default_open_close
;
3757 if (info
->ops
.close
== NULL
)
3758 info
->ops
.close
= hda_pcm_default_open_close
;
3759 if (info
->ops
.prepare
== NULL
) {
3760 if (snd_BUG_ON(!info
->nid
))
3762 info
->ops
.prepare
= hda_pcm_default_prepare
;
3764 if (info
->ops
.cleanup
== NULL
) {
3765 if (snd_BUG_ON(!info
->nid
))
3767 info
->ops
.cleanup
= hda_pcm_default_cleanup
;
3773 * codec prepare/cleanup entries
3775 int snd_hda_codec_prepare(struct hda_codec
*codec
,
3776 struct hda_pcm_stream
*hinfo
,
3777 unsigned int stream
,
3778 unsigned int format
,
3779 struct snd_pcm_substream
*substream
)
3782 mutex_lock(&codec
->bus
->prepare_mutex
);
3783 ret
= hinfo
->ops
.prepare(hinfo
, codec
, stream
, format
, substream
);
3785 purify_inactive_streams(codec
);
3786 mutex_unlock(&codec
->bus
->prepare_mutex
);
3789 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare
);
3791 void snd_hda_codec_cleanup(struct hda_codec
*codec
,
3792 struct hda_pcm_stream
*hinfo
,
3793 struct snd_pcm_substream
*substream
)
3795 mutex_lock(&codec
->bus
->prepare_mutex
);
3796 hinfo
->ops
.cleanup(hinfo
, codec
, substream
);
3797 mutex_unlock(&codec
->bus
->prepare_mutex
);
3799 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup
);
3802 const char *snd_hda_pcm_type_name
[HDA_PCM_NTYPES
] = {
3803 "Audio", "SPDIF", "HDMI", "Modem"
3807 * get the empty PCM device number to assign
3809 * note the max device number is limited by HDA_MAX_PCMS, currently 10
3811 static int get_empty_pcm_device(struct hda_bus
*bus
, int type
)
3813 /* audio device indices; not linear to keep compatibility */
3814 static int audio_idx
[HDA_PCM_NTYPES
][5] = {
3815 [HDA_PCM_TYPE_AUDIO
] = { 0, 2, 4, 5, -1 },
3816 [HDA_PCM_TYPE_SPDIF
] = { 1, -1 },
3817 [HDA_PCM_TYPE_HDMI
] = { 3, 7, 8, 9, -1 },
3818 [HDA_PCM_TYPE_MODEM
] = { 6, -1 },
3822 if (type
>= HDA_PCM_NTYPES
) {
3823 snd_printk(KERN_WARNING
"Invalid PCM type %d\n", type
);
3827 for (i
= 0; audio_idx
[type
][i
] >= 0 ; i
++)
3828 if (!test_and_set_bit(audio_idx
[type
][i
], bus
->pcm_dev_bits
))
3829 return audio_idx
[type
][i
];
3831 snd_printk(KERN_WARNING
"Too many %s devices\n",
3832 snd_hda_pcm_type_name
[type
]);
3837 * attach a new PCM stream
3839 static int snd_hda_attach_pcm(struct hda_codec
*codec
, struct hda_pcm
*pcm
)
3841 struct hda_bus
*bus
= codec
->bus
;
3842 struct hda_pcm_stream
*info
;
3845 if (snd_BUG_ON(!pcm
->name
))
3847 for (stream
= 0; stream
< 2; stream
++) {
3848 info
= &pcm
->stream
[stream
];
3849 if (info
->substreams
) {
3850 err
= set_pcm_default_values(codec
, info
);
3855 return bus
->ops
.attach_pcm(bus
, codec
, pcm
);
3858 /* assign all PCMs of the given codec */
3859 int snd_hda_codec_build_pcms(struct hda_codec
*codec
)
3864 if (!codec
->num_pcms
) {
3865 if (!codec
->patch_ops
.build_pcms
)
3867 err
= codec
->patch_ops
.build_pcms(codec
);
3869 printk(KERN_ERR
"hda_codec: cannot build PCMs"
3870 "for #%d (error %d)\n", codec
->addr
, err
);
3871 err
= snd_hda_codec_reset(codec
);
3874 "hda_codec: cannot revert codec\n");
3879 for (pcm
= 0; pcm
< codec
->num_pcms
; pcm
++) {
3880 struct hda_pcm
*cpcm
= &codec
->pcm_info
[pcm
];
3883 if (!cpcm
->stream
[0].substreams
&& !cpcm
->stream
[1].substreams
)
3884 continue; /* no substreams assigned */
3887 dev
= get_empty_pcm_device(codec
->bus
, cpcm
->pcm_type
);
3889 continue; /* no fatal error */
3891 err
= snd_hda_attach_pcm(codec
, cpcm
);
3893 printk(KERN_ERR
"hda_codec: cannot attach "
3894 "PCM stream %d for codec #%d\n",
3896 continue; /* no fatal error */
3904 * snd_hda_build_pcms - build PCM information
3907 * Create PCM information for each codec included in the bus.
3909 * The build_pcms codec patch is requested to set up codec->num_pcms and
3910 * codec->pcm_info properly. The array is referred by the top-level driver
3911 * to create its PCM instances.
3912 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3915 * At least, substreams, channels_min and channels_max must be filled for
3916 * each stream. substreams = 0 indicates that the stream doesn't exist.
3917 * When rates and/or formats are zero, the supported values are queried
3918 * from the given nid. The nid is used also by the default ops.prepare
3919 * and ops.cleanup callbacks.
3921 * The driver needs to call ops.open in its open callback. Similarly,
3922 * ops.close is supposed to be called in the close callback.
3923 * ops.prepare should be called in the prepare or hw_params callback
3924 * with the proper parameters for set up.
3925 * ops.cleanup should be called in hw_free for clean up of streams.
3927 * This function returns 0 if successful, or a negative error code.
3929 int __devinit
snd_hda_build_pcms(struct hda_bus
*bus
)
3931 struct hda_codec
*codec
;
3933 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3934 int err
= snd_hda_codec_build_pcms(codec
);
3940 EXPORT_SYMBOL_HDA(snd_hda_build_pcms
);
3943 * snd_hda_check_board_config - compare the current codec with the config table
3944 * @codec: the HDA codec
3945 * @num_configs: number of config enums
3946 * @models: array of model name strings
3947 * @tbl: configuration table, terminated by null entries
3949 * Compares the modelname or PCI subsystem id of the current codec with the
3950 * given configuration table. If a matching entry is found, returns its
3951 * config value (supposed to be 0 or positive).
3953 * If no entries are matching, the function returns a negative value.
3955 int snd_hda_check_board_config(struct hda_codec
*codec
,
3956 int num_configs
, const char * const *models
,
3957 const struct snd_pci_quirk
*tbl
)
3959 if (codec
->modelname
&& models
) {
3961 for (i
= 0; i
< num_configs
; i
++) {
3963 !strcmp(codec
->modelname
, models
[i
])) {
3964 snd_printd(KERN_INFO
"hda_codec: model '%s' is "
3965 "selected\n", models
[i
]);
3971 if (!codec
->bus
->pci
|| !tbl
)
3974 tbl
= snd_pci_quirk_lookup(codec
->bus
->pci
, tbl
);
3977 if (tbl
->value
>= 0 && tbl
->value
< num_configs
) {
3978 #ifdef CONFIG_SND_DEBUG_VERBOSE
3980 const char *model
= NULL
;
3982 model
= models
[tbl
->value
];
3984 sprintf(tmp
, "#%d", tbl
->value
);
3987 snd_printdd(KERN_INFO
"hda_codec: model '%s' is selected "
3988 "for config %x:%x (%s)\n",
3989 model
, tbl
->subvendor
, tbl
->subdevice
,
3990 (tbl
->name
? tbl
->name
: "Unknown device"));
3996 EXPORT_SYMBOL_HDA(snd_hda_check_board_config
);
3999 * snd_hda_check_board_codec_sid_config - compare the current codec
4000 subsystem ID with the
4003 This is important for Gateway notebooks with SB450 HDA Audio
4004 where the vendor ID of the PCI device is:
4005 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4006 and the vendor/subvendor are found only at the codec.
4008 * @codec: the HDA codec
4009 * @num_configs: number of config enums
4010 * @models: array of model name strings
4011 * @tbl: configuration table, terminated by null entries
4013 * Compares the modelname or PCI subsystem id of the current codec with the
4014 * given configuration table. If a matching entry is found, returns its
4015 * config value (supposed to be 0 or positive).
4017 * If no entries are matching, the function returns a negative value.
4019 int snd_hda_check_board_codec_sid_config(struct hda_codec
*codec
,
4020 int num_configs
, const char * const *models
,
4021 const struct snd_pci_quirk
*tbl
)
4023 const struct snd_pci_quirk
*q
;
4025 /* Search for codec ID */
4026 for (q
= tbl
; q
->subvendor
; q
++) {
4027 unsigned long vendorid
= (q
->subdevice
) | (q
->subvendor
<< 16);
4029 if (vendorid
== codec
->subsystem_id
)
4038 if (tbl
->value
>= 0 && tbl
->value
< num_configs
) {
4039 #ifdef CONFIG_SND_DEBUG_VERBOSE
4041 const char *model
= NULL
;
4043 model
= models
[tbl
->value
];
4045 sprintf(tmp
, "#%d", tbl
->value
);
4048 snd_printdd(KERN_INFO
"hda_codec: model '%s' is selected "
4049 "for config %x:%x (%s)\n",
4050 model
, tbl
->subvendor
, tbl
->subdevice
,
4051 (tbl
->name
? tbl
->name
: "Unknown device"));
4057 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config
);
4060 * snd_hda_add_new_ctls - create controls from the array
4061 * @codec: the HDA codec
4062 * @knew: the array of struct snd_kcontrol_new
4064 * This helper function creates and add new controls in the given array.
4065 * The array must be terminated with an empty entry as terminator.
4067 * Returns 0 if successful, or a negative error code.
4069 int snd_hda_add_new_ctls(struct hda_codec
*codec
,
4070 const struct snd_kcontrol_new
*knew
)
4074 for (; knew
->name
; knew
++) {
4075 struct snd_kcontrol
*kctl
;
4076 int addr
= 0, idx
= 0;
4077 if (knew
->iface
== -1) /* skip this codec private value */
4080 kctl
= snd_ctl_new1(knew
, codec
);
4084 kctl
->id
.device
= addr
;
4086 kctl
->id
.index
= idx
;
4087 err
= snd_hda_ctl_add(codec
, 0, kctl
);
4090 /* try first with another device index corresponding to
4091 * the codec addr; if it still fails (or it's the
4092 * primary codec), then try another control index
4094 if (!addr
&& codec
->addr
)
4096 else if (!idx
&& !knew
->index
) {
4097 idx
= find_empty_mixer_ctl_idx(codec
,
4107 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls
);
4109 #ifdef CONFIG_SND_HDA_POWER_SAVE
4110 static void hda_power_work(struct work_struct
*work
)
4112 struct hda_codec
*codec
=
4113 container_of(work
, struct hda_codec
, power_work
.work
);
4114 struct hda_bus
*bus
= codec
->bus
;
4116 if (!codec
->power_on
|| codec
->power_count
) {
4117 codec
->power_transition
= 0;
4121 trace_hda_power_down(codec
);
4122 hda_call_codec_suspend(codec
);
4123 if (bus
->ops
.pm_notify
)
4124 bus
->ops
.pm_notify(bus
);
4127 static void hda_keep_power_on(struct hda_codec
*codec
)
4129 codec
->power_count
++;
4130 codec
->power_on
= 1;
4131 codec
->power_jiffies
= jiffies
;
4134 /* update the power on/off account with the current jiffies */
4135 void snd_hda_update_power_acct(struct hda_codec
*codec
)
4137 unsigned long delta
= jiffies
- codec
->power_jiffies
;
4138 if (codec
->power_on
)
4139 codec
->power_on_acct
+= delta
;
4141 codec
->power_off_acct
+= delta
;
4142 codec
->power_jiffies
+= delta
;
4146 * snd_hda_power_up - Power-up the codec
4147 * @codec: HD-audio codec
4149 * Increment the power-up counter and power up the hardware really when
4150 * not turned on yet.
4152 void snd_hda_power_up(struct hda_codec
*codec
)
4154 struct hda_bus
*bus
= codec
->bus
;
4156 codec
->power_count
++;
4157 if (codec
->power_on
|| codec
->power_transition
)
4160 trace_hda_power_up(codec
);
4161 snd_hda_update_power_acct(codec
);
4162 codec
->power_on
= 1;
4163 codec
->power_jiffies
= jiffies
;
4164 if (bus
->ops
.pm_notify
)
4165 bus
->ops
.pm_notify(bus
);
4166 hda_call_codec_resume(codec
);
4167 cancel_delayed_work(&codec
->power_work
);
4168 codec
->power_transition
= 0;
4170 EXPORT_SYMBOL_HDA(snd_hda_power_up
);
4172 #define power_save(codec) \
4173 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4176 * snd_hda_power_down - Power-down the codec
4177 * @codec: HD-audio codec
4179 * Decrement the power-up counter and schedules the power-off work if
4180 * the counter rearches to zero.
4182 void snd_hda_power_down(struct hda_codec
*codec
)
4184 --codec
->power_count
;
4185 if (!codec
->power_on
|| codec
->power_count
|| codec
->power_transition
)
4187 if (power_save(codec
)) {
4188 codec
->power_transition
= 1; /* avoid reentrance */
4189 queue_delayed_work(codec
->bus
->workq
, &codec
->power_work
,
4190 msecs_to_jiffies(power_save(codec
) * 1000));
4193 EXPORT_SYMBOL_HDA(snd_hda_power_down
);
4196 * snd_hda_check_amp_list_power - Check the amp list and update the power
4197 * @codec: HD-audio codec
4198 * @check: the object containing an AMP list and the status
4199 * @nid: NID to check / update
4201 * Check whether the given NID is in the amp list. If it's in the list,
4202 * check the current AMP status, and update the the power-status according
4203 * to the mute status.
4205 * This function is supposed to be set or called from the check_power_status
4208 int snd_hda_check_amp_list_power(struct hda_codec
*codec
,
4209 struct hda_loopback_check
*check
,
4212 const struct hda_amp_list
*p
;
4215 if (!check
->amplist
)
4217 for (p
= check
->amplist
; p
->nid
; p
++) {
4222 return 0; /* nothing changed */
4224 for (p
= check
->amplist
; p
->nid
; p
++) {
4225 for (ch
= 0; ch
< 2; ch
++) {
4226 v
= snd_hda_codec_amp_read(codec
, p
->nid
, ch
, p
->dir
,
4228 if (!(v
& HDA_AMP_MUTE
) && v
> 0) {
4229 if (!check
->power_on
) {
4230 check
->power_on
= 1;
4231 snd_hda_power_up(codec
);
4237 if (check
->power_on
) {
4238 check
->power_on
= 0;
4239 snd_hda_power_down(codec
);
4243 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power
);
4247 * Channel mode helper
4251 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4253 int snd_hda_ch_mode_info(struct hda_codec
*codec
,
4254 struct snd_ctl_elem_info
*uinfo
,
4255 const struct hda_channel_mode
*chmode
,
4258 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
4260 uinfo
->value
.enumerated
.items
= num_chmodes
;
4261 if (uinfo
->value
.enumerated
.item
>= num_chmodes
)
4262 uinfo
->value
.enumerated
.item
= num_chmodes
- 1;
4263 sprintf(uinfo
->value
.enumerated
.name
, "%dch",
4264 chmode
[uinfo
->value
.enumerated
.item
].channels
);
4267 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info
);
4270 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4272 int snd_hda_ch_mode_get(struct hda_codec
*codec
,
4273 struct snd_ctl_elem_value
*ucontrol
,
4274 const struct hda_channel_mode
*chmode
,
4280 for (i
= 0; i
< num_chmodes
; i
++) {
4281 if (max_channels
== chmode
[i
].channels
) {
4282 ucontrol
->value
.enumerated
.item
[0] = i
;
4288 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get
);
4291 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4293 int snd_hda_ch_mode_put(struct hda_codec
*codec
,
4294 struct snd_ctl_elem_value
*ucontrol
,
4295 const struct hda_channel_mode
*chmode
,
4301 mode
= ucontrol
->value
.enumerated
.item
[0];
4302 if (mode
>= num_chmodes
)
4304 if (*max_channelsp
== chmode
[mode
].channels
)
4306 /* change the current channel setting */
4307 *max_channelsp
= chmode
[mode
].channels
;
4308 if (chmode
[mode
].sequence
)
4309 snd_hda_sequence_write_cache(codec
, chmode
[mode
].sequence
);
4312 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put
);
4319 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4321 int snd_hda_input_mux_info(const struct hda_input_mux
*imux
,
4322 struct snd_ctl_elem_info
*uinfo
)
4326 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
4328 uinfo
->value
.enumerated
.items
= imux
->num_items
;
4329 if (!imux
->num_items
)
4331 index
= uinfo
->value
.enumerated
.item
;
4332 if (index
>= imux
->num_items
)
4333 index
= imux
->num_items
- 1;
4334 strcpy(uinfo
->value
.enumerated
.name
, imux
->items
[index
].label
);
4337 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info
);
4340 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4342 int snd_hda_input_mux_put(struct hda_codec
*codec
,
4343 const struct hda_input_mux
*imux
,
4344 struct snd_ctl_elem_value
*ucontrol
,
4346 unsigned int *cur_val
)
4350 if (!imux
->num_items
)
4352 idx
= ucontrol
->value
.enumerated
.item
[0];
4353 if (idx
>= imux
->num_items
)
4354 idx
= imux
->num_items
- 1;
4355 if (*cur_val
== idx
)
4357 snd_hda_codec_write_cache(codec
, nid
, 0, AC_VERB_SET_CONNECT_SEL
,
4358 imux
->items
[idx
].index
);
4362 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put
);
4366 * Multi-channel / digital-out PCM helper functions
4369 /* setup SPDIF output stream */
4370 static void setup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
,
4371 unsigned int stream_tag
, unsigned int format
)
4373 struct hda_spdif_out
*spdif
= snd_hda_spdif_out_of_nid(codec
, nid
);
4375 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4376 if (codec
->spdif_status_reset
&& (spdif
->ctls
& AC_DIG1_ENABLE
))
4377 set_dig_out_convert(codec
, nid
,
4378 spdif
->ctls
& ~AC_DIG1_ENABLE
& 0xff,
4380 snd_hda_codec_setup_stream(codec
, nid
, stream_tag
, 0, format
);
4381 if (codec
->slave_dig_outs
) {
4383 for (d
= codec
->slave_dig_outs
; *d
; d
++)
4384 snd_hda_codec_setup_stream(codec
, *d
, stream_tag
, 0,
4387 /* turn on again (if needed) */
4388 if (codec
->spdif_status_reset
&& (spdif
->ctls
& AC_DIG1_ENABLE
))
4389 set_dig_out_convert(codec
, nid
,
4390 spdif
->ctls
& 0xff, -1);
4393 static void cleanup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
)
4395 snd_hda_codec_cleanup_stream(codec
, nid
);
4396 if (codec
->slave_dig_outs
) {
4398 for (d
= codec
->slave_dig_outs
; *d
; d
++)
4399 snd_hda_codec_cleanup_stream(codec
, *d
);
4404 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4405 * @bus: HD-audio bus
4407 void snd_hda_bus_reboot_notify(struct hda_bus
*bus
)
4409 struct hda_codec
*codec
;
4413 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
4414 if (hda_codec_is_power_on(codec
) &&
4415 codec
->patch_ops
.reboot_notify
)
4416 codec
->patch_ops
.reboot_notify(codec
);
4419 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify
);
4422 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4424 int snd_hda_multi_out_dig_open(struct hda_codec
*codec
,
4425 struct hda_multi_out
*mout
)
4427 mutex_lock(&codec
->spdif_mutex
);
4428 if (mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
)
4429 /* already opened as analog dup; reset it once */
4430 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4431 mout
->dig_out_used
= HDA_DIG_EXCLUSIVE
;
4432 mutex_unlock(&codec
->spdif_mutex
);
4435 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open
);
4438 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4440 int snd_hda_multi_out_dig_prepare(struct hda_codec
*codec
,
4441 struct hda_multi_out
*mout
,
4442 unsigned int stream_tag
,
4443 unsigned int format
,
4444 struct snd_pcm_substream
*substream
)
4446 mutex_lock(&codec
->spdif_mutex
);
4447 setup_dig_out_stream(codec
, mout
->dig_out_nid
, stream_tag
, format
);
4448 mutex_unlock(&codec
->spdif_mutex
);
4451 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare
);
4454 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4456 int snd_hda_multi_out_dig_cleanup(struct hda_codec
*codec
,
4457 struct hda_multi_out
*mout
)
4459 mutex_lock(&codec
->spdif_mutex
);
4460 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4461 mutex_unlock(&codec
->spdif_mutex
);
4464 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup
);
4467 * snd_hda_multi_out_dig_close - release the digital out stream
4469 int snd_hda_multi_out_dig_close(struct hda_codec
*codec
,
4470 struct hda_multi_out
*mout
)
4472 mutex_lock(&codec
->spdif_mutex
);
4473 mout
->dig_out_used
= 0;
4474 mutex_unlock(&codec
->spdif_mutex
);
4477 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close
);
4480 * snd_hda_multi_out_analog_open - open analog outputs
4482 * Open analog outputs and set up the hw-constraints.
4483 * If the digital outputs can be opened as slave, open the digital
4486 int snd_hda_multi_out_analog_open(struct hda_codec
*codec
,
4487 struct hda_multi_out
*mout
,
4488 struct snd_pcm_substream
*substream
,
4489 struct hda_pcm_stream
*hinfo
)
4491 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
4492 runtime
->hw
.channels_max
= mout
->max_channels
;
4493 if (mout
->dig_out_nid
) {
4494 if (!mout
->analog_rates
) {
4495 mout
->analog_rates
= hinfo
->rates
;
4496 mout
->analog_formats
= hinfo
->formats
;
4497 mout
->analog_maxbps
= hinfo
->maxbps
;
4499 runtime
->hw
.rates
= mout
->analog_rates
;
4500 runtime
->hw
.formats
= mout
->analog_formats
;
4501 hinfo
->maxbps
= mout
->analog_maxbps
;
4503 if (!mout
->spdif_rates
) {
4504 snd_hda_query_supported_pcm(codec
, mout
->dig_out_nid
,
4506 &mout
->spdif_formats
,
4507 &mout
->spdif_maxbps
);
4509 mutex_lock(&codec
->spdif_mutex
);
4510 if (mout
->share_spdif
) {
4511 if ((runtime
->hw
.rates
& mout
->spdif_rates
) &&
4512 (runtime
->hw
.formats
& mout
->spdif_formats
)) {
4513 runtime
->hw
.rates
&= mout
->spdif_rates
;
4514 runtime
->hw
.formats
&= mout
->spdif_formats
;
4515 if (mout
->spdif_maxbps
< hinfo
->maxbps
)
4516 hinfo
->maxbps
= mout
->spdif_maxbps
;
4518 mout
->share_spdif
= 0;
4519 /* FIXME: need notify? */
4522 mutex_unlock(&codec
->spdif_mutex
);
4524 return snd_pcm_hw_constraint_step(substream
->runtime
, 0,
4525 SNDRV_PCM_HW_PARAM_CHANNELS
, 2);
4527 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open
);
4530 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4532 * Set up the i/o for analog out.
4533 * When the digital out is available, copy the front out to digital out, too.
4535 int snd_hda_multi_out_analog_prepare(struct hda_codec
*codec
,
4536 struct hda_multi_out
*mout
,
4537 unsigned int stream_tag
,
4538 unsigned int format
,
4539 struct snd_pcm_substream
*substream
)
4541 const hda_nid_t
*nids
= mout
->dac_nids
;
4542 int chs
= substream
->runtime
->channels
;
4543 struct hda_spdif_out
*spdif
=
4544 snd_hda_spdif_out_of_nid(codec
, mout
->dig_out_nid
);
4547 mutex_lock(&codec
->spdif_mutex
);
4548 if (mout
->dig_out_nid
&& mout
->share_spdif
&&
4549 mout
->dig_out_used
!= HDA_DIG_EXCLUSIVE
) {
4551 snd_hda_is_supported_format(codec
, mout
->dig_out_nid
,
4553 !(spdif
->status
& IEC958_AES0_NONAUDIO
)) {
4554 mout
->dig_out_used
= HDA_DIG_ANALOG_DUP
;
4555 setup_dig_out_stream(codec
, mout
->dig_out_nid
,
4556 stream_tag
, format
);
4558 mout
->dig_out_used
= 0;
4559 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4562 mutex_unlock(&codec
->spdif_mutex
);
4565 snd_hda_codec_setup_stream(codec
, nids
[HDA_FRONT
], stream_tag
,
4567 if (!mout
->no_share_stream
&&
4568 mout
->hp_nid
&& mout
->hp_nid
!= nids
[HDA_FRONT
])
4569 /* headphone out will just decode front left/right (stereo) */
4570 snd_hda_codec_setup_stream(codec
, mout
->hp_nid
, stream_tag
,
4572 /* extra outputs copied from front */
4573 for (i
= 0; i
< ARRAY_SIZE(mout
->hp_out_nid
); i
++)
4574 if (!mout
->no_share_stream
&& mout
->hp_out_nid
[i
])
4575 snd_hda_codec_setup_stream(codec
,
4576 mout
->hp_out_nid
[i
],
4577 stream_tag
, 0, format
);
4578 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
4579 if (!mout
->no_share_stream
&& mout
->extra_out_nid
[i
])
4580 snd_hda_codec_setup_stream(codec
,
4581 mout
->extra_out_nid
[i
],
4582 stream_tag
, 0, format
);
4585 for (i
= 1; i
< mout
->num_dacs
; i
++) {
4586 if (chs
>= (i
+ 1) * 2) /* independent out */
4587 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
4589 else if (!mout
->no_share_stream
) /* copy front */
4590 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
4595 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare
);
4598 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4600 int snd_hda_multi_out_analog_cleanup(struct hda_codec
*codec
,
4601 struct hda_multi_out
*mout
)
4603 const hda_nid_t
*nids
= mout
->dac_nids
;
4606 for (i
= 0; i
< mout
->num_dacs
; i
++)
4607 snd_hda_codec_cleanup_stream(codec
, nids
[i
]);
4609 snd_hda_codec_cleanup_stream(codec
, mout
->hp_nid
);
4610 for (i
= 0; i
< ARRAY_SIZE(mout
->hp_out_nid
); i
++)
4611 if (mout
->hp_out_nid
[i
])
4612 snd_hda_codec_cleanup_stream(codec
,
4613 mout
->hp_out_nid
[i
]);
4614 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
4615 if (mout
->extra_out_nid
[i
])
4616 snd_hda_codec_cleanup_stream(codec
,
4617 mout
->extra_out_nid
[i
]);
4618 mutex_lock(&codec
->spdif_mutex
);
4619 if (mout
->dig_out_nid
&& mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
) {
4620 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4621 mout
->dig_out_used
= 0;
4623 mutex_unlock(&codec
->spdif_mutex
);
4626 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup
);
4629 * Helper for automatic pin configuration
4632 static int is_in_nid_list(hda_nid_t nid
, const hda_nid_t
*list
)
4634 for (; *list
; list
++)
4642 * Sort an associated group of pins according to their sequence numbers.
4644 static void sort_pins_by_sequence(hda_nid_t
*pins
, short *sequences
,
4651 for (i
= 0; i
< num_pins
; i
++) {
4652 for (j
= i
+ 1; j
< num_pins
; j
++) {
4653 if (sequences
[i
] > sequences
[j
]) {
4655 sequences
[i
] = sequences
[j
];
4666 /* add the found input-pin to the cfg->inputs[] table */
4667 static void add_auto_cfg_input_pin(struct auto_pin_cfg
*cfg
, hda_nid_t nid
,
4670 if (cfg
->num_inputs
< AUTO_CFG_MAX_INS
) {
4671 cfg
->inputs
[cfg
->num_inputs
].pin
= nid
;
4672 cfg
->inputs
[cfg
->num_inputs
].type
= type
;
4677 /* sort inputs in the order of AUTO_PIN_* type */
4678 static void sort_autocfg_input_pins(struct auto_pin_cfg
*cfg
)
4682 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
4683 for (j
= i
+ 1; j
< cfg
->num_inputs
; j
++) {
4684 if (cfg
->inputs
[i
].type
> cfg
->inputs
[j
].type
) {
4685 struct auto_pin_cfg_item tmp
;
4686 tmp
= cfg
->inputs
[i
];
4687 cfg
->inputs
[i
] = cfg
->inputs
[j
];
4688 cfg
->inputs
[j
] = tmp
;
4695 * Parse all pin widgets and store the useful pin nids to cfg
4697 * The number of line-outs or any primary output is stored in line_outs,
4698 * and the corresponding output pins are assigned to line_out_pins[],
4699 * in the order of front, rear, CLFE, side, ...
4701 * If more extra outputs (speaker and headphone) are found, the pins are
4702 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
4703 * is detected, one of speaker of HP pins is assigned as the primary
4704 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4705 * if any analog output exists.
4707 * The analog input pins are assigned to inputs array.
4708 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4711 int snd_hda_parse_pin_defcfg(struct hda_codec
*codec
,
4712 struct auto_pin_cfg
*cfg
,
4713 const hda_nid_t
*ignore_nids
,
4714 unsigned int cond_flags
)
4716 hda_nid_t nid
, end_nid
;
4717 short seq
, assoc_line_out
;
4718 short sequences_line_out
[ARRAY_SIZE(cfg
->line_out_pins
)];
4719 short sequences_speaker
[ARRAY_SIZE(cfg
->speaker_pins
)];
4720 short sequences_hp
[ARRAY_SIZE(cfg
->hp_pins
)];
4723 memset(cfg
, 0, sizeof(*cfg
));
4725 memset(sequences_line_out
, 0, sizeof(sequences_line_out
));
4726 memset(sequences_speaker
, 0, sizeof(sequences_speaker
));
4727 memset(sequences_hp
, 0, sizeof(sequences_hp
));
4730 end_nid
= codec
->start_nid
+ codec
->num_nodes
;
4731 for (nid
= codec
->start_nid
; nid
< end_nid
; nid
++) {
4732 unsigned int wid_caps
= get_wcaps(codec
, nid
);
4733 unsigned int wid_type
= get_wcaps_type(wid_caps
);
4734 unsigned int def_conf
;
4735 short assoc
, loc
, conn
, dev
;
4737 /* read all default configuration for pin complex */
4738 if (wid_type
!= AC_WID_PIN
)
4740 /* ignore the given nids (e.g. pc-beep returns error) */
4741 if (ignore_nids
&& is_in_nid_list(nid
, ignore_nids
))
4744 def_conf
= snd_hda_codec_get_pincfg(codec
, nid
);
4745 conn
= get_defcfg_connect(def_conf
);
4746 if (conn
== AC_JACK_PORT_NONE
)
4748 loc
= get_defcfg_location(def_conf
);
4749 dev
= get_defcfg_device(def_conf
);
4751 /* workaround for buggy BIOS setups */
4752 if (dev
== AC_JACK_LINE_OUT
) {
4753 if (conn
== AC_JACK_PORT_FIXED
)
4754 dev
= AC_JACK_SPEAKER
;
4758 case AC_JACK_LINE_OUT
:
4759 seq
= get_defcfg_sequence(def_conf
);
4760 assoc
= get_defcfg_association(def_conf
);
4762 if (!(wid_caps
& AC_WCAP_STEREO
))
4763 if (!cfg
->mono_out_pin
)
4764 cfg
->mono_out_pin
= nid
;
4767 if (!assoc_line_out
)
4768 assoc_line_out
= assoc
;
4769 else if (assoc_line_out
!= assoc
)
4771 if (cfg
->line_outs
>= ARRAY_SIZE(cfg
->line_out_pins
))
4773 cfg
->line_out_pins
[cfg
->line_outs
] = nid
;
4774 sequences_line_out
[cfg
->line_outs
] = seq
;
4777 case AC_JACK_SPEAKER
:
4778 seq
= get_defcfg_sequence(def_conf
);
4779 assoc
= get_defcfg_association(def_conf
);
4780 if (cfg
->speaker_outs
>= ARRAY_SIZE(cfg
->speaker_pins
))
4782 cfg
->speaker_pins
[cfg
->speaker_outs
] = nid
;
4783 sequences_speaker
[cfg
->speaker_outs
] = (assoc
<< 4) | seq
;
4784 cfg
->speaker_outs
++;
4786 case AC_JACK_HP_OUT
:
4787 seq
= get_defcfg_sequence(def_conf
);
4788 assoc
= get_defcfg_association(def_conf
);
4789 if (cfg
->hp_outs
>= ARRAY_SIZE(cfg
->hp_pins
))
4791 cfg
->hp_pins
[cfg
->hp_outs
] = nid
;
4792 sequences_hp
[cfg
->hp_outs
] = (assoc
<< 4) | seq
;
4795 case AC_JACK_MIC_IN
:
4796 add_auto_cfg_input_pin(cfg
, nid
, AUTO_PIN_MIC
);
4798 case AC_JACK_LINE_IN
:
4799 add_auto_cfg_input_pin(cfg
, nid
, AUTO_PIN_LINE_IN
);
4802 add_auto_cfg_input_pin(cfg
, nid
, AUTO_PIN_CD
);
4805 add_auto_cfg_input_pin(cfg
, nid
, AUTO_PIN_AUX
);
4807 case AC_JACK_SPDIF_OUT
:
4808 case AC_JACK_DIG_OTHER_OUT
:
4809 if (cfg
->dig_outs
>= ARRAY_SIZE(cfg
->dig_out_pins
))
4811 cfg
->dig_out_pins
[cfg
->dig_outs
] = nid
;
4812 cfg
->dig_out_type
[cfg
->dig_outs
] =
4813 (loc
== AC_JACK_LOC_HDMI
) ?
4814 HDA_PCM_TYPE_HDMI
: HDA_PCM_TYPE_SPDIF
;
4817 case AC_JACK_SPDIF_IN
:
4818 case AC_JACK_DIG_OTHER_IN
:
4819 cfg
->dig_in_pin
= nid
;
4820 if (loc
== AC_JACK_LOC_HDMI
)
4821 cfg
->dig_in_type
= HDA_PCM_TYPE_HDMI
;
4823 cfg
->dig_in_type
= HDA_PCM_TYPE_SPDIF
;
4829 * If no line-out is defined but multiple HPs are found,
4830 * some of them might be the real line-outs.
4832 if (!cfg
->line_outs
&& cfg
->hp_outs
> 1 &&
4833 !(cond_flags
& HDA_PINCFG_NO_HP_FIXUP
)) {
4835 while (i
< cfg
->hp_outs
) {
4836 /* The real HPs should have the sequence 0x0f */
4837 if ((sequences_hp
[i
] & 0x0f) == 0x0f) {
4841 /* Move it to the line-out table */
4842 cfg
->line_out_pins
[cfg
->line_outs
] = cfg
->hp_pins
[i
];
4843 sequences_line_out
[cfg
->line_outs
] = sequences_hp
[i
];
4846 memmove(cfg
->hp_pins
+ i
, cfg
->hp_pins
+ i
+ 1,
4847 sizeof(cfg
->hp_pins
[0]) * (cfg
->hp_outs
- i
));
4848 memmove(sequences_hp
+ i
, sequences_hp
+ i
+ 1,
4849 sizeof(sequences_hp
[0]) * (cfg
->hp_outs
- i
));
4851 memset(cfg
->hp_pins
+ cfg
->hp_outs
, 0,
4852 sizeof(hda_nid_t
) * (AUTO_CFG_MAX_OUTS
- cfg
->hp_outs
));
4854 cfg
->line_out_type
= AUTO_PIN_HP_OUT
;
4858 /* sort by sequence */
4859 sort_pins_by_sequence(cfg
->line_out_pins
, sequences_line_out
,
4861 sort_pins_by_sequence(cfg
->speaker_pins
, sequences_speaker
,
4863 sort_pins_by_sequence(cfg
->hp_pins
, sequences_hp
,
4867 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4868 * as a primary output
4870 if (!cfg
->line_outs
&&
4871 !(cond_flags
& HDA_PINCFG_NO_LO_FIXUP
)) {
4872 if (cfg
->speaker_outs
) {
4873 cfg
->line_outs
= cfg
->speaker_outs
;
4874 memcpy(cfg
->line_out_pins
, cfg
->speaker_pins
,
4875 sizeof(cfg
->speaker_pins
));
4876 cfg
->speaker_outs
= 0;
4877 memset(cfg
->speaker_pins
, 0, sizeof(cfg
->speaker_pins
));
4878 cfg
->line_out_type
= AUTO_PIN_SPEAKER_OUT
;
4879 } else if (cfg
->hp_outs
) {
4880 cfg
->line_outs
= cfg
->hp_outs
;
4881 memcpy(cfg
->line_out_pins
, cfg
->hp_pins
,
4882 sizeof(cfg
->hp_pins
));
4884 memset(cfg
->hp_pins
, 0, sizeof(cfg
->hp_pins
));
4885 cfg
->line_out_type
= AUTO_PIN_HP_OUT
;
4889 /* Reorder the surround channels
4890 * ALSA sequence is front/surr/clfe/side
4892 * 4-ch: front/surr => OK as it is
4893 * 6-ch: front/clfe/surr
4894 * 8-ch: front/clfe/rear/side|fc
4896 switch (cfg
->line_outs
) {
4899 nid
= cfg
->line_out_pins
[1];
4900 cfg
->line_out_pins
[1] = cfg
->line_out_pins
[2];
4901 cfg
->line_out_pins
[2] = nid
;
4905 sort_autocfg_input_pins(cfg
);
4908 * debug prints of the parsed results
4910 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
4911 cfg
->line_outs
, cfg
->line_out_pins
[0], cfg
->line_out_pins
[1],
4912 cfg
->line_out_pins
[2], cfg
->line_out_pins
[3],
4913 cfg
->line_out_pins
[4],
4914 cfg
->line_out_type
== AUTO_PIN_HP_OUT
? "hp" :
4915 (cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
?
4916 "speaker" : "line"));
4917 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4918 cfg
->speaker_outs
, cfg
->speaker_pins
[0],
4919 cfg
->speaker_pins
[1], cfg
->speaker_pins
[2],
4920 cfg
->speaker_pins
[3], cfg
->speaker_pins
[4]);
4921 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4922 cfg
->hp_outs
, cfg
->hp_pins
[0],
4923 cfg
->hp_pins
[1], cfg
->hp_pins
[2],
4924 cfg
->hp_pins
[3], cfg
->hp_pins
[4]);
4925 snd_printd(" mono: mono_out=0x%x\n", cfg
->mono_out_pin
);
4927 snd_printd(" dig-out=0x%x/0x%x\n",
4928 cfg
->dig_out_pins
[0], cfg
->dig_out_pins
[1]);
4929 snd_printd(" inputs:");
4930 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
4931 snd_printd(" %s=0x%x",
4932 hda_get_autocfg_input_label(codec
, cfg
, i
),
4933 cfg
->inputs
[i
].pin
);
4936 if (cfg
->dig_in_pin
)
4937 snd_printd(" dig-in=0x%x\n", cfg
->dig_in_pin
);
4941 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_defcfg
);
4943 int snd_hda_get_input_pin_attr(unsigned int def_conf
)
4945 unsigned int loc
= get_defcfg_location(def_conf
);
4946 unsigned int conn
= get_defcfg_connect(def_conf
);
4947 if (conn
== AC_JACK_PORT_NONE
)
4948 return INPUT_PIN_ATTR_UNUSED
;
4949 /* Windows may claim the internal mic to be BOTH, too */
4950 if (conn
== AC_JACK_PORT_FIXED
|| conn
== AC_JACK_PORT_BOTH
)
4951 return INPUT_PIN_ATTR_INT
;
4952 if ((loc
& 0x30) == AC_JACK_LOC_INTERNAL
)
4953 return INPUT_PIN_ATTR_INT
;
4954 if ((loc
& 0x30) == AC_JACK_LOC_SEPARATE
)
4955 return INPUT_PIN_ATTR_DOCK
;
4956 if (loc
== AC_JACK_LOC_REAR
)
4957 return INPUT_PIN_ATTR_REAR
;
4958 if (loc
== AC_JACK_LOC_FRONT
)
4959 return INPUT_PIN_ATTR_FRONT
;
4960 return INPUT_PIN_ATTR_NORMAL
;
4962 EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr
);
4965 * hda_get_input_pin_label - Give a label for the given input pin
4967 * When check_location is true, the function checks the pin location
4968 * for mic and line-in pins, and set an appropriate prefix like "Front",
4969 * "Rear", "Internal".
4972 const char *hda_get_input_pin_label(struct hda_codec
*codec
, hda_nid_t pin
,
4975 unsigned int def_conf
;
4976 static const char * const mic_names
[] = {
4977 "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic",
4981 def_conf
= snd_hda_codec_get_pincfg(codec
, pin
);
4983 switch (get_defcfg_device(def_conf
)) {
4984 case AC_JACK_MIC_IN
:
4985 if (!check_location
)
4987 attr
= snd_hda_get_input_pin_attr(def_conf
);
4990 return mic_names
[attr
- 1];
4991 case AC_JACK_LINE_IN
:
4992 if (!check_location
)
4994 attr
= snd_hda_get_input_pin_attr(def_conf
);
4997 if (attr
== INPUT_PIN_ATTR_DOCK
)
5004 case AC_JACK_SPDIF_IN
:
5006 case AC_JACK_DIG_OTHER_IN
:
5007 return "Digital In";
5012 EXPORT_SYMBOL_HDA(hda_get_input_pin_label
);
5014 /* Check whether the location prefix needs to be added to the label.
5015 * If all mic-jacks are in the same location (e.g. rear panel), we don't
5016 * have to put "Front" prefix to each label. In such a case, returns false.
5018 static int check_mic_location_need(struct hda_codec
*codec
,
5019 const struct auto_pin_cfg
*cfg
,
5025 defc
= snd_hda_codec_get_pincfg(codec
, cfg
->inputs
[input
].pin
);
5026 attr
= snd_hda_get_input_pin_attr(defc
);
5027 /* for internal or docking mics, we need locations */
5028 if (attr
<= INPUT_PIN_ATTR_NORMAL
)
5032 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
5033 defc
= snd_hda_codec_get_pincfg(codec
, cfg
->inputs
[i
].pin
);
5034 attr2
= snd_hda_get_input_pin_attr(defc
);
5035 if (attr2
>= INPUT_PIN_ATTR_NORMAL
) {
5036 if (attr
&& attr
!= attr2
)
5037 return 1; /* different locations found */
5045 * hda_get_autocfg_input_label - Get a label for the given input
5047 * Get a label for the given input pin defined by the autocfg item.
5048 * Unlike hda_get_input_pin_label(), this function checks all inputs
5049 * defined in autocfg and avoids the redundant mic/line prefix as much as
5052 const char *hda_get_autocfg_input_label(struct hda_codec
*codec
,
5053 const struct auto_pin_cfg
*cfg
,
5056 int type
= cfg
->inputs
[input
].type
;
5057 int has_multiple_pins
= 0;
5059 if ((input
> 0 && cfg
->inputs
[input
- 1].type
== type
) ||
5060 (input
< cfg
->num_inputs
- 1 && cfg
->inputs
[input
+ 1].type
== type
))
5061 has_multiple_pins
= 1;
5062 if (has_multiple_pins
&& type
== AUTO_PIN_MIC
)
5063 has_multiple_pins
&= check_mic_location_need(codec
, cfg
, input
);
5064 return hda_get_input_pin_label(codec
, cfg
->inputs
[input
].pin
,
5067 EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label
);
5070 * snd_hda_add_imux_item - Add an item to input_mux
5072 * When the same label is used already in the existing items, the number
5073 * suffix is appended to the label. This label index number is stored
5074 * to type_idx when non-NULL pointer is given.
5076 int snd_hda_add_imux_item(struct hda_input_mux
*imux
, const char *label
,
5077 int index
, int *type_idx
)
5079 int i
, label_idx
= 0;
5080 if (imux
->num_items
>= HDA_MAX_NUM_INPUTS
) {
5081 snd_printd(KERN_ERR
"hda_codec: Too many imux items!\n");
5084 for (i
= 0; i
< imux
->num_items
; i
++) {
5085 if (!strncmp(label
, imux
->items
[i
].label
, strlen(label
)))
5089 *type_idx
= label_idx
;
5091 snprintf(imux
->items
[imux
->num_items
].label
,
5092 sizeof(imux
->items
[imux
->num_items
].label
),
5093 "%s %d", label
, label_idx
);
5095 strlcpy(imux
->items
[imux
->num_items
].label
, label
,
5096 sizeof(imux
->items
[imux
->num_items
].label
));
5097 imux
->items
[imux
->num_items
].index
= index
;
5101 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item
);
5110 * snd_hda_suspend - suspend the codecs
5113 * Returns 0 if successful.
5115 int snd_hda_suspend(struct hda_bus
*bus
)
5117 struct hda_codec
*codec
;
5119 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
5120 if (hda_codec_is_power_on(codec
))
5121 hda_call_codec_suspend(codec
);
5122 if (codec
->patch_ops
.post_suspend
)
5123 codec
->patch_ops
.post_suspend(codec
);
5127 EXPORT_SYMBOL_HDA(snd_hda_suspend
);
5130 * snd_hda_resume - resume the codecs
5133 * Returns 0 if successful.
5135 * This function is defined only when POWER_SAVE isn't set.
5136 * In the power-save mode, the codec is resumed dynamically.
5138 int snd_hda_resume(struct hda_bus
*bus
)
5140 struct hda_codec
*codec
;
5142 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
5143 if (codec
->patch_ops
.pre_resume
)
5144 codec
->patch_ops
.pre_resume(codec
);
5145 if (snd_hda_codec_needs_resume(codec
))
5146 hda_call_codec_resume(codec
);
5150 EXPORT_SYMBOL_HDA(snd_hda_resume
);
5151 #endif /* CONFIG_PM */
5158 * snd_array_new - get a new element from the given array
5159 * @array: the array object
5161 * Get a new element from the given array. If it exceeds the
5162 * pre-allocated array size, re-allocate the array.
5164 * Returns NULL if allocation failed.
5166 void *snd_array_new(struct snd_array
*array
)
5168 if (array
->used
>= array
->alloced
) {
5169 int num
= array
->alloced
+ array
->alloc_align
;
5170 int size
= (num
+ 1) * array
->elem_size
;
5171 int oldsize
= array
->alloced
* array
->elem_size
;
5173 if (snd_BUG_ON(num
>= 4096))
5175 nlist
= krealloc(array
->list
, size
, GFP_KERNEL
);
5178 memset(nlist
+ oldsize
, 0, size
- oldsize
);
5179 array
->list
= nlist
;
5180 array
->alloced
= num
;
5182 return snd_array_elem(array
, array
->used
++);
5184 EXPORT_SYMBOL_HDA(snd_array_new
);
5187 * snd_array_free - free the given array elements
5188 * @array: the array object
5190 void snd_array_free(struct snd_array
*array
)
5197 EXPORT_SYMBOL_HDA(snd_array_free
);
5200 * snd_print_pcm_rates - Print the supported PCM rates to the string buffer
5201 * @pcm: PCM caps bits
5202 * @buf: the string buffer to write
5203 * @buflen: the max buffer length
5205 * used by hda_proc.c and hda_eld.c
5207 void snd_print_pcm_rates(int pcm
, char *buf
, int buflen
)
5209 static unsigned int rates
[] = {
5210 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
5211 96000, 176400, 192000, 384000
5215 for (i
= 0, j
= 0; i
< ARRAY_SIZE(rates
); i
++)
5217 j
+= snprintf(buf
+ j
, buflen
- j
, " %d", rates
[i
]);
5219 buf
[j
] = '\0'; /* necessary when j == 0 */
5221 EXPORT_SYMBOL_HDA(snd_print_pcm_rates
);
5224 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5225 * @pcm: PCM caps bits
5226 * @buf: the string buffer to write
5227 * @buflen: the max buffer length
5229 * used by hda_proc.c and hda_eld.c
5231 void snd_print_pcm_bits(int pcm
, char *buf
, int buflen
)
5233 static unsigned int bits
[] = { 8, 16, 20, 24, 32 };
5236 for (i
= 0, j
= 0; i
< ARRAY_SIZE(bits
); i
++)
5237 if (pcm
& (AC_SUPPCM_BITS_8
<< i
))
5238 j
+= snprintf(buf
+ j
, buflen
- j
, " %d", bits
[i
]);
5240 buf
[j
] = '\0'; /* necessary when j == 0 */
5242 EXPORT_SYMBOL_HDA(snd_print_pcm_bits
);
5244 #ifdef CONFIG_SND_HDA_INPUT_JACK
5246 * Input-jack notification support
5248 struct hda_jack_item
{
5251 struct snd_jack
*jack
;
5254 static const char *get_jack_default_name(struct hda_codec
*codec
, hda_nid_t nid
,
5258 case SND_JACK_HEADPHONE
:
5260 case SND_JACK_MICROPHONE
:
5262 case SND_JACK_LINEOUT
:
5264 case SND_JACK_HEADSET
:
5266 case SND_JACK_VIDEOOUT
:
5273 static void hda_free_jack_priv(struct snd_jack
*jack
)
5275 struct hda_jack_item
*jacks
= jack
->private_data
;
5280 int snd_hda_input_jack_add(struct hda_codec
*codec
, hda_nid_t nid
, int type
,
5283 struct hda_jack_item
*jack
;
5286 snd_array_init(&codec
->jacks
, sizeof(*jack
), 32);
5287 jack
= snd_array_new(&codec
->jacks
);
5294 name
= get_jack_default_name(codec
, nid
, type
);
5295 err
= snd_jack_new(codec
->bus
->card
, name
, type
, &jack
->jack
);
5300 jack
->jack
->private_data
= jack
;
5301 jack
->jack
->private_free
= hda_free_jack_priv
;
5304 EXPORT_SYMBOL_HDA(snd_hda_input_jack_add
);
5306 void snd_hda_input_jack_report(struct hda_codec
*codec
, hda_nid_t nid
)
5308 struct hda_jack_item
*jacks
= codec
->jacks
.list
;
5314 for (i
= 0; i
< codec
->jacks
.used
; i
++, jacks
++) {
5315 unsigned int pin_ctl
;
5316 unsigned int present
;
5319 if (jacks
->nid
!= nid
)
5321 present
= snd_hda_jack_detect(codec
, nid
);
5323 if (type
== (SND_JACK_HEADPHONE
| SND_JACK_LINEOUT
)) {
5324 pin_ctl
= snd_hda_codec_read(codec
, nid
, 0,
5325 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
5326 type
= (pin_ctl
& AC_PINCTL_HP_EN
) ?
5327 SND_JACK_HEADPHONE
: SND_JACK_LINEOUT
;
5329 snd_jack_report(jacks
->jack
, present
? type
: 0);
5332 EXPORT_SYMBOL_HDA(snd_hda_input_jack_report
);
5334 /* free jack instances manually when clearing/reconfiguring */
5335 void snd_hda_input_jack_free(struct hda_codec
*codec
)
5337 if (!codec
->bus
->shutdown
&& codec
->jacks
.list
) {
5338 struct hda_jack_item
*jacks
= codec
->jacks
.list
;
5340 for (i
= 0; i
< codec
->jacks
.used
; i
++, jacks
++) {
5342 snd_device_free(codec
->bus
->card
, jacks
->jack
);
5345 snd_array_free(&codec
->jacks
);
5347 EXPORT_SYMBOL_HDA(snd_hda_input_jack_free
);
5348 #endif /* CONFIG_SND_HDA_INPUT_JACK */
5350 MODULE_DESCRIPTION("HDA codec core");
5351 MODULE_LICENSE("GPL");