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
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/slab.h>
26 #include <linux/mutex.h>
27 #include <linux/module.h>
28 #include <linux/async.h>
30 #include <linux/pm_runtime.h>
31 #include <sound/core.h>
32 #include "hda_codec.h"
33 #include <sound/asoundef.h>
34 #include <sound/tlv.h>
35 #include <sound/initval.h>
36 #include <sound/jack.h>
37 #include "hda_local.h"
40 #include <sound/hda_hwdep.h>
43 #define codec_in_pm(codec) atomic_read(&(codec)->core.in_pm)
44 #define hda_codec_is_power_on(codec) \
45 (!pm_runtime_suspended(hda_codec_dev(codec)))
47 #define codec_in_pm(codec) 0
48 #define hda_codec_is_power_on(codec) 1
51 #define codec_has_epss(codec) \
52 ((codec)->core.power_caps & AC_PWRST_EPSS)
53 #define codec_has_clkstop(codec) \
54 ((codec)->core.power_caps & AC_PWRST_CLKSTOP)
57 * snd_hda_get_jack_location - Give a location string of the jack
58 * @cfg: pin default config value
60 * Parse the pin default config value and returns the string of the
61 * jack location, e.g. "Rear", "Front", etc.
63 const char *snd_hda_get_jack_location(u32 cfg
)
65 static char *bases
[7] = {
66 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
68 static unsigned char specials_idx
[] = {
73 static char *specials
[] = {
74 "Rear Panel", "Drive Bar",
75 "Riser", "HDMI", "ATAPI",
76 "Mobile-In", "Mobile-Out"
79 cfg
= (cfg
& AC_DEFCFG_LOCATION
) >> AC_DEFCFG_LOCATION_SHIFT
;
81 return bases
[cfg
& 0x0f];
82 for (i
= 0; i
< ARRAY_SIZE(specials_idx
); i
++) {
83 if (cfg
== specials_idx
[i
])
88 EXPORT_SYMBOL_GPL(snd_hda_get_jack_location
);
91 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
92 * @cfg: pin default config value
94 * Parse the pin default config value and returns the string of the
95 * jack connectivity, i.e. external or internal connection.
97 const char *snd_hda_get_jack_connectivity(u32 cfg
)
99 static char *jack_locations
[4] = { "Ext", "Int", "Sep", "Oth" };
101 return jack_locations
[(cfg
>> (AC_DEFCFG_LOCATION_SHIFT
+ 4)) & 3];
103 EXPORT_SYMBOL_GPL(snd_hda_get_jack_connectivity
);
106 * snd_hda_get_jack_type - Give a type string of the jack
107 * @cfg: pin default config value
109 * Parse the pin default config value and returns the string of the
110 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
112 const char *snd_hda_get_jack_type(u32 cfg
)
114 static char *jack_types
[16] = {
115 "Line Out", "Speaker", "HP Out", "CD",
116 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
117 "Line In", "Aux", "Mic", "Telephony",
118 "SPDIF In", "Digital In", "Reserved", "Other"
121 return jack_types
[(cfg
& AC_DEFCFG_DEVICE
)
122 >> AC_DEFCFG_DEVICE_SHIFT
];
124 EXPORT_SYMBOL_GPL(snd_hda_get_jack_type
);
127 * Send and receive a verb - passed to exec_verb override for hdac_device
129 static int codec_exec_verb(struct hdac_device
*dev
, unsigned int cmd
,
130 unsigned int flags
, unsigned int *res
)
132 struct hda_codec
*codec
= container_of(dev
, struct hda_codec
, core
);
133 struct hda_bus
*bus
= codec
->bus
;
140 snd_hda_power_up(codec
);
141 mutex_lock(&bus
->core
.cmd_mutex
);
142 if (flags
& HDA_RW_NO_RESPONSE_FALLBACK
)
143 bus
->no_response_fallback
= 1;
144 err
= snd_hdac_bus_exec_verb_unlocked(&bus
->core
, codec
->core
.addr
,
146 bus
->no_response_fallback
= 0;
147 mutex_unlock(&bus
->core
.cmd_mutex
);
148 snd_hda_power_down(codec
);
149 if (!codec_in_pm(codec
) && res
&& err
< 0 && bus
->rirb_error
) {
150 if (bus
->response_reset
) {
152 "resetting BUS due to fatal communication error\n");
153 bus
->ops
.bus_reset(bus
);
157 /* clear reset-flag when the communication gets recovered */
158 if (!err
|| codec_in_pm(codec
))
159 bus
->response_reset
= 0;
164 * snd_hda_codec_read - send a command and get the response
165 * @codec: the HDA codec
166 * @nid: NID to send the command
167 * @flags: optional bit flags
168 * @verb: the verb to send
169 * @parm: the parameter for the verb
171 * Send a single command and read the corresponding response.
173 * Returns the obtained response value, or -1 for an error.
175 unsigned int snd_hda_codec_read(struct hda_codec
*codec
, hda_nid_t nid
,
177 unsigned int verb
, unsigned int parm
)
179 unsigned int cmd
= snd_hdac_make_cmd(&codec
->core
, nid
, verb
, parm
);
181 if (snd_hdac_exec_verb(&codec
->core
, cmd
, flags
, &res
))
185 EXPORT_SYMBOL_GPL(snd_hda_codec_read
);
188 * snd_hda_codec_write - send a single command without waiting for response
189 * @codec: the HDA codec
190 * @nid: NID to send the command
191 * @flags: optional bit flags
192 * @verb: the verb to send
193 * @parm: the parameter for the verb
195 * Send a single command without waiting for response.
197 * Returns 0 if successful, or a negative error code.
199 int snd_hda_codec_write(struct hda_codec
*codec
, hda_nid_t nid
, int flags
,
200 unsigned int verb
, unsigned int parm
)
202 unsigned int cmd
= snd_hdac_make_cmd(&codec
->core
, nid
, verb
, parm
);
203 return snd_hdac_exec_verb(&codec
->core
, cmd
, flags
, NULL
);
205 EXPORT_SYMBOL_GPL(snd_hda_codec_write
);
208 * snd_hda_sequence_write - sequence writes
209 * @codec: the HDA codec
210 * @seq: VERB array to send
212 * Send the commands sequentially from the given array.
213 * The array must be terminated with NID=0.
215 void snd_hda_sequence_write(struct hda_codec
*codec
, const struct hda_verb
*seq
)
217 for (; seq
->nid
; seq
++)
218 snd_hda_codec_write(codec
, seq
->nid
, 0, seq
->verb
, seq
->param
);
220 EXPORT_SYMBOL_GPL(snd_hda_sequence_write
);
222 /* connection list element */
223 struct hda_conn_list
{
224 struct list_head list
;
230 /* look up the cached results */
231 static struct hda_conn_list
*
232 lookup_conn_list(struct hda_codec
*codec
, hda_nid_t nid
)
234 struct hda_conn_list
*p
;
235 list_for_each_entry(p
, &codec
->conn_list
, list
) {
242 static int add_conn_list(struct hda_codec
*codec
, hda_nid_t nid
, int len
,
243 const hda_nid_t
*list
)
245 struct hda_conn_list
*p
;
247 p
= kmalloc(sizeof(*p
) + len
* sizeof(hda_nid_t
), GFP_KERNEL
);
252 memcpy(p
->conns
, list
, len
* sizeof(hda_nid_t
));
253 list_add(&p
->list
, &codec
->conn_list
);
257 static void remove_conn_list(struct hda_codec
*codec
)
259 while (!list_empty(&codec
->conn_list
)) {
260 struct hda_conn_list
*p
;
261 p
= list_first_entry(&codec
->conn_list
, typeof(*p
), list
);
267 /* read the connection and add to the cache */
268 static int read_and_add_raw_conns(struct hda_codec
*codec
, hda_nid_t nid
)
271 hda_nid_t
*result
= list
;
274 len
= snd_hda_get_raw_connections(codec
, nid
, list
, ARRAY_SIZE(list
));
275 if (len
== -ENOSPC
) {
276 len
= snd_hda_get_num_raw_conns(codec
, nid
);
277 result
= kmalloc(sizeof(hda_nid_t
) * len
, GFP_KERNEL
);
280 len
= snd_hda_get_raw_connections(codec
, nid
, result
, len
);
283 len
= snd_hda_override_conn_list(codec
, nid
, len
, result
);
290 * snd_hda_get_conn_list - get connection list
291 * @codec: the HDA codec
293 * @listp: the pointer to store NID list
295 * Parses the connection list of the given widget and stores the pointer
296 * to the list of NIDs.
298 * Returns the number of connections, or a negative error code.
300 * Note that the returned pointer isn't protected against the list
301 * modification. If snd_hda_override_conn_list() might be called
302 * concurrently, protect with a mutex appropriately.
304 int snd_hda_get_conn_list(struct hda_codec
*codec
, hda_nid_t nid
,
305 const hda_nid_t
**listp
)
311 const struct hda_conn_list
*p
;
313 /* if the connection-list is already cached, read it */
314 p
= lookup_conn_list(codec
, nid
);
320 if (snd_BUG_ON(added
))
323 err
= read_and_add_raw_conns(codec
, nid
);
329 EXPORT_SYMBOL_GPL(snd_hda_get_conn_list
);
332 * snd_hda_get_connections - copy connection list
333 * @codec: the HDA codec
335 * @conn_list: connection list array; when NULL, checks only the size
336 * @max_conns: max. number of connections to store
338 * Parses the connection list of the given widget and stores the list
341 * Returns the number of connections, or a negative error code.
343 int snd_hda_get_connections(struct hda_codec
*codec
, hda_nid_t nid
,
344 hda_nid_t
*conn_list
, int max_conns
)
346 const hda_nid_t
*list
;
347 int len
= snd_hda_get_conn_list(codec
, nid
, &list
);
349 if (len
> 0 && conn_list
) {
350 if (len
> max_conns
) {
351 codec_err(codec
, "Too many connections %d for NID 0x%x\n",
355 memcpy(conn_list
, list
, len
* sizeof(hda_nid_t
));
360 EXPORT_SYMBOL_GPL(snd_hda_get_connections
);
363 * snd_hda_override_conn_list - add/modify the connection-list to cache
364 * @codec: the HDA codec
366 * @len: number of connection list entries
367 * @list: the list of connection entries
369 * Add or modify the given connection-list to the cache. If the corresponding
370 * cache already exists, invalidate it and append a new one.
372 * Returns zero or a negative error code.
374 int snd_hda_override_conn_list(struct hda_codec
*codec
, hda_nid_t nid
, int len
,
375 const hda_nid_t
*list
)
377 struct hda_conn_list
*p
;
379 p
= lookup_conn_list(codec
, nid
);
385 return add_conn_list(codec
, nid
, len
, list
);
387 EXPORT_SYMBOL_GPL(snd_hda_override_conn_list
);
390 * snd_hda_get_conn_index - get the connection index of the given NID
391 * @codec: the HDA codec
392 * @mux: NID containing the list
393 * @nid: NID to select
394 * @recursive: 1 when searching NID recursively, otherwise 0
396 * Parses the connection list of the widget @mux and checks whether the
397 * widget @nid is present. If it is, return the connection index.
398 * Otherwise it returns -1.
400 int snd_hda_get_conn_index(struct hda_codec
*codec
, hda_nid_t mux
,
401 hda_nid_t nid
, int recursive
)
403 const hda_nid_t
*conn
;
406 nums
= snd_hda_get_conn_list(codec
, mux
, &conn
);
407 for (i
= 0; i
< nums
; i
++)
412 if (recursive
> 10) {
413 codec_dbg(codec
, "too deep connection for 0x%x\n", nid
);
417 for (i
= 0; i
< nums
; i
++) {
418 unsigned int type
= get_wcaps_type(get_wcaps(codec
, conn
[i
]));
419 if (type
== AC_WID_PIN
|| type
== AC_WID_AUD_OUT
)
421 if (snd_hda_get_conn_index(codec
, conn
[i
], nid
, recursive
) >= 0)
426 EXPORT_SYMBOL_GPL(snd_hda_get_conn_index
);
429 /* return DEVLIST_LEN parameter of the given widget */
430 static unsigned int get_num_devices(struct hda_codec
*codec
, hda_nid_t nid
)
432 unsigned int wcaps
= get_wcaps(codec
, nid
);
435 if (!codec
->dp_mst
|| !(wcaps
& AC_WCAP_DIGITAL
) ||
436 get_wcaps_type(wcaps
) != AC_WID_PIN
)
439 parm
= snd_hda_param_read(codec
, nid
, AC_PAR_DEVLIST_LEN
);
440 if (parm
== -1 && codec
->bus
->rirb_error
)
442 return parm
& AC_DEV_LIST_LEN_MASK
;
446 * snd_hda_get_devices - copy device list without cache
447 * @codec: the HDA codec
448 * @nid: NID of the pin to parse
449 * @dev_list: device list array
450 * @max_devices: max. number of devices to store
452 * Copy the device list. This info is dynamic and so not cached.
453 * Currently called only from hda_proc.c, so not exported.
455 int snd_hda_get_devices(struct hda_codec
*codec
, hda_nid_t nid
,
456 u8
*dev_list
, int max_devices
)
459 int i
, dev_len
, devices
;
461 parm
= get_num_devices(codec
, nid
);
462 if (!parm
) /* not multi-stream capable */
466 dev_len
= dev_len
< max_devices
? dev_len
: max_devices
;
469 while (devices
< dev_len
) {
470 parm
= snd_hda_codec_read(codec
, nid
, 0,
471 AC_VERB_GET_DEVICE_LIST
, devices
);
472 if (parm
== -1 && codec
->bus
->rirb_error
)
475 for (i
= 0; i
< 8; i
++) {
476 dev_list
[devices
] = (u8
)parm
;
479 if (devices
>= dev_len
)
489 static void snd_hda_bus_free(struct hda_bus
*bus
)
493 if (bus
->ops
.private_free
)
494 bus
->ops
.private_free(bus
);
495 snd_hdac_bus_exit(&bus
->core
);
499 static int snd_hda_bus_dev_free(struct snd_device
*device
)
501 snd_hda_bus_free(device
->device_data
);
505 static int snd_hda_bus_dev_disconnect(struct snd_device
*device
)
507 struct hda_bus
*bus
= device
->device_data
;
512 /* hdac_bus_ops translations */
513 static int _hda_bus_command(struct hdac_bus
*_bus
, unsigned int cmd
)
515 struct hda_bus
*bus
= container_of(_bus
, struct hda_bus
, core
);
516 return bus
->ops
.command(bus
, cmd
);
519 static int _hda_bus_get_response(struct hdac_bus
*_bus
, unsigned int addr
,
522 struct hda_bus
*bus
= container_of(_bus
, struct hda_bus
, core
);
523 *res
= bus
->ops
.get_response(bus
, addr
);
524 return bus
->rirb_error
? -EIO
: 0;
527 static const struct hdac_bus_ops bus_ops
= {
528 .command
= _hda_bus_command
,
529 .get_response
= _hda_bus_get_response
,
533 * snd_hda_bus_new - create a HDA bus
534 * @card: the card entry
535 * @busp: the pointer to store the created bus instance
537 * Returns 0 if successful, or a negative error code.
539 int snd_hda_bus_new(struct snd_card
*card
,
540 struct hda_bus
**busp
)
544 static struct snd_device_ops dev_ops
= {
545 .dev_disconnect
= snd_hda_bus_dev_disconnect
,
546 .dev_free
= snd_hda_bus_dev_free
,
552 bus
= kzalloc(sizeof(*bus
), GFP_KERNEL
);
556 err
= snd_hdac_bus_init(&bus
->core
, card
->dev
, &bus_ops
);
563 mutex_init(&bus
->prepare_mutex
);
565 err
= snd_device_new(card
, SNDRV_DEV_BUS
, bus
, &dev_ops
);
567 snd_hda_bus_free(bus
);
574 EXPORT_SYMBOL_GPL(snd_hda_bus_new
);
577 * read widget caps for each widget and store in cache
579 static int read_widget_caps(struct hda_codec
*codec
, hda_nid_t fg_node
)
584 codec
->wcaps
= kmalloc(codec
->core
.num_nodes
* 4, GFP_KERNEL
);
587 nid
= codec
->core
.start_nid
;
588 for (i
= 0; i
< codec
->core
.num_nodes
; i
++, nid
++)
589 codec
->wcaps
[i
] = snd_hdac_read_parm_uncached(&codec
->core
,
590 nid
, AC_PAR_AUDIO_WIDGET_CAP
);
594 /* read all pin default configurations and save codec->init_pins */
595 static int read_pin_defaults(struct hda_codec
*codec
)
599 for_each_hda_codec_node(nid
, codec
) {
600 struct hda_pincfg
*pin
;
601 unsigned int wcaps
= get_wcaps(codec
, nid
);
602 unsigned int wid_type
= get_wcaps_type(wcaps
);
603 if (wid_type
!= AC_WID_PIN
)
605 pin
= snd_array_new(&codec
->init_pins
);
609 pin
->cfg
= snd_hda_codec_read(codec
, nid
, 0,
610 AC_VERB_GET_CONFIG_DEFAULT
, 0);
611 pin
->ctrl
= snd_hda_codec_read(codec
, nid
, 0,
612 AC_VERB_GET_PIN_WIDGET_CONTROL
,
618 /* look up the given pin config list and return the item matching with NID */
619 static struct hda_pincfg
*look_up_pincfg(struct hda_codec
*codec
,
620 struct snd_array
*array
,
624 for (i
= 0; i
< array
->used
; i
++) {
625 struct hda_pincfg
*pin
= snd_array_elem(array
, i
);
632 /* set the current pin config value for the given NID.
633 * the value is cached, and read via snd_hda_codec_get_pincfg()
635 int snd_hda_add_pincfg(struct hda_codec
*codec
, struct snd_array
*list
,
636 hda_nid_t nid
, unsigned int cfg
)
638 struct hda_pincfg
*pin
;
640 /* the check below may be invalid when pins are added by a fixup
641 * dynamically (e.g. via snd_hda_codec_update_widgets()), so disabled
645 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
649 pin
= look_up_pincfg(codec
, list
, nid
);
651 pin
= snd_array_new(list
);
661 * snd_hda_codec_set_pincfg - Override a pin default configuration
662 * @codec: the HDA codec
663 * @nid: NID to set the pin config
664 * @cfg: the pin default config value
666 * Override a pin default configuration value in the cache.
667 * This value can be read by snd_hda_codec_get_pincfg() in a higher
668 * priority than the real hardware value.
670 int snd_hda_codec_set_pincfg(struct hda_codec
*codec
,
671 hda_nid_t nid
, unsigned int cfg
)
673 return snd_hda_add_pincfg(codec
, &codec
->driver_pins
, nid
, cfg
);
675 EXPORT_SYMBOL_GPL(snd_hda_codec_set_pincfg
);
678 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
679 * @codec: the HDA codec
680 * @nid: NID to get the pin config
682 * Get the current pin config value of the given pin NID.
683 * If the pincfg value is cached or overridden via sysfs or driver,
684 * returns the cached value.
686 unsigned int snd_hda_codec_get_pincfg(struct hda_codec
*codec
, hda_nid_t nid
)
688 struct hda_pincfg
*pin
;
690 #ifdef CONFIG_SND_HDA_RECONFIG
692 unsigned int cfg
= 0;
693 mutex_lock(&codec
->user_mutex
);
694 pin
= look_up_pincfg(codec
, &codec
->user_pins
, nid
);
697 mutex_unlock(&codec
->user_mutex
);
702 pin
= look_up_pincfg(codec
, &codec
->driver_pins
, nid
);
705 pin
= look_up_pincfg(codec
, &codec
->init_pins
, nid
);
710 EXPORT_SYMBOL_GPL(snd_hda_codec_get_pincfg
);
713 * snd_hda_codec_set_pin_target - remember the current pinctl target value
714 * @codec: the HDA codec
716 * @val: assigned pinctl value
718 * This function stores the given value to a pinctl target value in the
719 * pincfg table. This isn't always as same as the actually written value
720 * but can be referred at any time via snd_hda_codec_get_pin_target().
722 int snd_hda_codec_set_pin_target(struct hda_codec
*codec
, hda_nid_t nid
,
725 struct hda_pincfg
*pin
;
727 pin
= look_up_pincfg(codec
, &codec
->init_pins
, nid
);
733 EXPORT_SYMBOL_GPL(snd_hda_codec_set_pin_target
);
736 * snd_hda_codec_get_pin_target - return the current pinctl target value
737 * @codec: the HDA codec
740 int snd_hda_codec_get_pin_target(struct hda_codec
*codec
, hda_nid_t nid
)
742 struct hda_pincfg
*pin
;
744 pin
= look_up_pincfg(codec
, &codec
->init_pins
, nid
);
749 EXPORT_SYMBOL_GPL(snd_hda_codec_get_pin_target
);
752 * snd_hda_shutup_pins - Shut up all pins
753 * @codec: the HDA codec
755 * Clear all pin controls to shup up before suspend for avoiding click noise.
756 * The controls aren't cached so that they can be resumed properly.
758 void snd_hda_shutup_pins(struct hda_codec
*codec
)
761 /* don't shut up pins when unloading the driver; otherwise it breaks
762 * the default pin setup at the next load of the driver
764 if (codec
->bus
->shutdown
)
766 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
767 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
768 /* use read here for syncing after issuing each verb */
769 snd_hda_codec_read(codec
, pin
->nid
, 0,
770 AC_VERB_SET_PIN_WIDGET_CONTROL
, 0);
772 codec
->pins_shutup
= 1;
774 EXPORT_SYMBOL_GPL(snd_hda_shutup_pins
);
777 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
778 static void restore_shutup_pins(struct hda_codec
*codec
)
781 if (!codec
->pins_shutup
)
783 if (codec
->bus
->shutdown
)
785 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
786 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
787 snd_hda_codec_write(codec
, pin
->nid
, 0,
788 AC_VERB_SET_PIN_WIDGET_CONTROL
,
791 codec
->pins_shutup
= 0;
795 static void hda_jackpoll_work(struct work_struct
*work
)
797 struct hda_codec
*codec
=
798 container_of(work
, struct hda_codec
, jackpoll_work
.work
);
800 snd_hda_jack_set_dirty_all(codec
);
801 snd_hda_jack_poll_all(codec
);
803 if (!codec
->jackpoll_interval
)
806 schedule_delayed_work(&codec
->jackpoll_work
,
807 codec
->jackpoll_interval
);
810 static void init_hda_cache(struct hda_cache_rec
*cache
,
811 unsigned int record_size
);
812 static void free_hda_cache(struct hda_cache_rec
*cache
);
814 /* release all pincfg lists */
815 static void free_init_pincfgs(struct hda_codec
*codec
)
817 snd_array_free(&codec
->driver_pins
);
818 #ifdef CONFIG_SND_HDA_RECONFIG
819 snd_array_free(&codec
->user_pins
);
821 snd_array_free(&codec
->init_pins
);
825 * audio-converter setup caches
827 struct hda_cvt_setup
{
832 unsigned char active
; /* cvt is currently used */
833 unsigned char dirty
; /* setups should be cleared */
836 /* get or create a cache entry for the given audio converter NID */
837 static struct hda_cvt_setup
*
838 get_hda_cvt_setup(struct hda_codec
*codec
, hda_nid_t nid
)
840 struct hda_cvt_setup
*p
;
843 for (i
= 0; i
< codec
->cvt_setups
.used
; i
++) {
844 p
= snd_array_elem(&codec
->cvt_setups
, i
);
848 p
= snd_array_new(&codec
->cvt_setups
);
857 static void release_pcm(struct kref
*kref
)
859 struct hda_pcm
*pcm
= container_of(kref
, struct hda_pcm
, kref
);
862 snd_device_free(pcm
->codec
->card
, pcm
->pcm
);
863 clear_bit(pcm
->device
, pcm
->codec
->bus
->pcm_dev_bits
);
868 void snd_hda_codec_pcm_put(struct hda_pcm
*pcm
)
870 kref_put(&pcm
->kref
, release_pcm
);
872 EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_put
);
874 struct hda_pcm
*snd_hda_codec_pcm_new(struct hda_codec
*codec
,
875 const char *fmt
, ...)
881 pcm
= kzalloc(sizeof(*pcm
), GFP_KERNEL
);
886 kref_init(&pcm
->kref
);
887 pcm
->name
= kvasprintf(GFP_KERNEL
, fmt
, args
);
893 list_add_tail(&pcm
->list
, &codec
->pcm_list_head
);
896 EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_new
);
901 static void codec_release_pcms(struct hda_codec
*codec
)
903 struct hda_pcm
*pcm
, *n
;
905 list_for_each_entry_safe(pcm
, n
, &codec
->pcm_list_head
, list
) {
906 list_del_init(&pcm
->list
);
908 snd_device_disconnect(codec
->card
, pcm
->pcm
);
909 snd_hda_codec_pcm_put(pcm
);
913 void snd_hda_codec_cleanup_for_unbind(struct hda_codec
*codec
)
915 if (codec
->registered
) {
916 /* pm_runtime_put() is called in snd_hdac_device_exit() */
917 pm_runtime_get_noresume(hda_codec_dev(codec
));
918 pm_runtime_disable(hda_codec_dev(codec
));
919 codec
->registered
= 0;
922 cancel_delayed_work_sync(&codec
->jackpoll_work
);
923 if (!codec
->in_freeing
)
924 snd_hda_ctls_clear(codec
);
925 codec_release_pcms(codec
);
926 snd_hda_detach_beep_device(codec
);
927 memset(&codec
->patch_ops
, 0, sizeof(codec
->patch_ops
));
928 snd_hda_jack_tbl_clear(codec
);
929 codec
->proc_widget_hook
= NULL
;
932 free_hda_cache(&codec
->amp_cache
);
933 free_hda_cache(&codec
->cmd_cache
);
934 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
935 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
937 /* free only driver_pins so that init_pins + user_pins are restored */
938 snd_array_free(&codec
->driver_pins
);
939 snd_array_free(&codec
->cvt_setups
);
940 snd_array_free(&codec
->spdif_out
);
941 snd_array_free(&codec
->verbs
);
942 codec
->preset
= NULL
;
943 codec
->slave_dig_outs
= NULL
;
944 codec
->spdif_status_reset
= 0;
945 snd_array_free(&codec
->mixers
);
946 snd_array_free(&codec
->nids
);
947 remove_conn_list(codec
);
948 snd_hdac_regmap_exit(&codec
->core
);
951 static unsigned int hda_set_power_state(struct hda_codec
*codec
,
952 unsigned int power_state
);
954 /* also called from hda_bind.c */
955 void snd_hda_codec_register(struct hda_codec
*codec
)
957 if (codec
->registered
)
959 if (device_is_registered(hda_codec_dev(codec
))) {
960 snd_hda_register_beep_device(codec
);
961 pm_runtime_enable(hda_codec_dev(codec
));
962 /* it was powered up in snd_hda_codec_new(), now all done */
963 snd_hda_power_down(codec
);
964 codec
->registered
= 1;
968 static int snd_hda_codec_dev_register(struct snd_device
*device
)
970 snd_hda_codec_register(device
->device_data
);
974 static int snd_hda_codec_dev_disconnect(struct snd_device
*device
)
976 struct hda_codec
*codec
= device
->device_data
;
978 snd_hda_detach_beep_device(codec
);
982 static int snd_hda_codec_dev_free(struct snd_device
*device
)
984 struct hda_codec
*codec
= device
->device_data
;
986 codec
->in_freeing
= 1;
987 snd_hdac_device_unregister(&codec
->core
);
988 put_device(hda_codec_dev(codec
));
992 static void snd_hda_codec_dev_release(struct device
*dev
)
994 struct hda_codec
*codec
= dev_to_hda_codec(dev
);
996 free_init_pincfgs(codec
);
997 snd_hdac_device_exit(&codec
->core
);
998 snd_hda_sysfs_clear(codec
);
999 free_hda_cache(&codec
->amp_cache
);
1000 free_hda_cache(&codec
->cmd_cache
);
1001 kfree(codec
->modelname
);
1002 kfree(codec
->wcaps
);
1007 * snd_hda_codec_new - create a HDA codec
1008 * @bus: the bus to assign
1009 * @codec_addr: the codec address
1010 * @codecp: the pointer to store the generated codec
1012 * Returns 0 if successful, or a negative error code.
1014 int snd_hda_codec_new(struct hda_bus
*bus
, struct snd_card
*card
,
1015 unsigned int codec_addr
, struct hda_codec
**codecp
)
1017 struct hda_codec
*codec
;
1021 static struct snd_device_ops dev_ops
= {
1022 .dev_register
= snd_hda_codec_dev_register
,
1023 .dev_disconnect
= snd_hda_codec_dev_disconnect
,
1024 .dev_free
= snd_hda_codec_dev_free
,
1027 if (snd_BUG_ON(!bus
))
1029 if (snd_BUG_ON(codec_addr
> HDA_MAX_CODEC_ADDRESS
))
1032 codec
= kzalloc(sizeof(*codec
), GFP_KERNEL
);
1036 sprintf(component
, "hdaudioC%dD%d", card
->number
, codec_addr
);
1037 err
= snd_hdac_device_init(&codec
->core
, &bus
->core
, component
,
1044 codec
->core
.dev
.release
= snd_hda_codec_dev_release
;
1045 codec
->core
.type
= HDA_DEV_LEGACY
;
1046 codec
->core
.exec_verb
= codec_exec_verb
;
1050 codec
->addr
= codec_addr
;
1051 mutex_init(&codec
->spdif_mutex
);
1052 mutex_init(&codec
->control_mutex
);
1053 mutex_init(&codec
->hash_mutex
);
1054 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
1055 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
1056 snd_array_init(&codec
->mixers
, sizeof(struct hda_nid_item
), 32);
1057 snd_array_init(&codec
->nids
, sizeof(struct hda_nid_item
), 32);
1058 snd_array_init(&codec
->init_pins
, sizeof(struct hda_pincfg
), 16);
1059 snd_array_init(&codec
->driver_pins
, sizeof(struct hda_pincfg
), 16);
1060 snd_array_init(&codec
->cvt_setups
, sizeof(struct hda_cvt_setup
), 8);
1061 snd_array_init(&codec
->spdif_out
, sizeof(struct hda_spdif_out
), 16);
1062 snd_array_init(&codec
->jacktbl
, sizeof(struct hda_jack_tbl
), 16);
1063 snd_array_init(&codec
->verbs
, sizeof(struct hda_verb
*), 8);
1064 INIT_LIST_HEAD(&codec
->conn_list
);
1065 INIT_LIST_HEAD(&codec
->pcm_list_head
);
1067 INIT_DELAYED_WORK(&codec
->jackpoll_work
, hda_jackpoll_work
);
1068 codec
->depop_delay
= -1;
1069 codec
->fixup_id
= HDA_FIXUP_ID_NOT_SET
;
1072 codec
->power_jiffies
= jiffies
;
1075 snd_hda_sysfs_init(codec
);
1077 if (codec
->bus
->modelname
) {
1078 codec
->modelname
= kstrdup(codec
->bus
->modelname
, GFP_KERNEL
);
1079 if (!codec
->modelname
) {
1085 fg
= codec
->core
.afg
? codec
->core
.afg
: codec
->core
.mfg
;
1086 err
= read_widget_caps(codec
, fg
);
1089 err
= read_pin_defaults(codec
);
1093 /* power-up all before initialization */
1094 hda_set_power_state(codec
, AC_PWRST_D0
);
1096 snd_hda_codec_proc_new(codec
);
1098 snd_hda_create_hwdep(codec
);
1100 sprintf(component
, "HDA:%08x,%08x,%08x", codec
->core
.vendor_id
,
1101 codec
->core
.subsystem_id
, codec
->core
.revision_id
);
1102 snd_component_add(card
, component
);
1104 err
= snd_device_new(card
, SNDRV_DEV_CODEC
, codec
, &dev_ops
);
1113 put_device(hda_codec_dev(codec
));
1116 EXPORT_SYMBOL_GPL(snd_hda_codec_new
);
1119 * snd_hda_codec_update_widgets - Refresh widget caps and pin defaults
1120 * @codec: the HDA codec
1122 * Forcibly refresh the all widget caps and the init pin configurations of
1125 int snd_hda_codec_update_widgets(struct hda_codec
*codec
)
1130 err
= snd_hdac_refresh_widgets(&codec
->core
);
1134 /* Assume the function group node does not change,
1135 * only the widget nodes may change.
1137 kfree(codec
->wcaps
);
1138 fg
= codec
->core
.afg
? codec
->core
.afg
: codec
->core
.mfg
;
1139 err
= read_widget_caps(codec
, fg
);
1143 snd_array_free(&codec
->init_pins
);
1144 err
= read_pin_defaults(codec
);
1148 EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets
);
1150 /* update the stream-id if changed */
1151 static void update_pcm_stream_id(struct hda_codec
*codec
,
1152 struct hda_cvt_setup
*p
, hda_nid_t nid
,
1153 u32 stream_tag
, int channel_id
)
1155 unsigned int oldval
, newval
;
1157 if (p
->stream_tag
!= stream_tag
|| p
->channel_id
!= channel_id
) {
1158 oldval
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_CONV
, 0);
1159 newval
= (stream_tag
<< 4) | channel_id
;
1160 if (oldval
!= newval
)
1161 snd_hda_codec_write(codec
, nid
, 0,
1162 AC_VERB_SET_CHANNEL_STREAMID
,
1164 p
->stream_tag
= stream_tag
;
1165 p
->channel_id
= channel_id
;
1169 /* update the format-id if changed */
1170 static void update_pcm_format(struct hda_codec
*codec
, struct hda_cvt_setup
*p
,
1171 hda_nid_t nid
, int format
)
1173 unsigned int oldval
;
1175 if (p
->format_id
!= format
) {
1176 oldval
= snd_hda_codec_read(codec
, nid
, 0,
1177 AC_VERB_GET_STREAM_FORMAT
, 0);
1178 if (oldval
!= format
) {
1180 snd_hda_codec_write(codec
, nid
, 0,
1181 AC_VERB_SET_STREAM_FORMAT
,
1184 p
->format_id
= format
;
1189 * snd_hda_codec_setup_stream - set up the codec for streaming
1190 * @codec: the CODEC to set up
1191 * @nid: the NID to set up
1192 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1193 * @channel_id: channel id to pass, zero based.
1194 * @format: stream format.
1196 void snd_hda_codec_setup_stream(struct hda_codec
*codec
, hda_nid_t nid
,
1198 int channel_id
, int format
)
1200 struct hda_codec
*c
;
1201 struct hda_cvt_setup
*p
;
1209 "hda_codec_setup_stream: NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1210 nid
, stream_tag
, channel_id
, format
);
1211 p
= get_hda_cvt_setup(codec
, nid
);
1215 if (codec
->patch_ops
.stream_pm
)
1216 codec
->patch_ops
.stream_pm(codec
, nid
, true);
1217 if (codec
->pcm_format_first
)
1218 update_pcm_format(codec
, p
, nid
, format
);
1219 update_pcm_stream_id(codec
, p
, nid
, stream_tag
, channel_id
);
1220 if (!codec
->pcm_format_first
)
1221 update_pcm_format(codec
, p
, nid
, format
);
1226 /* make other inactive cvts with the same stream-tag dirty */
1227 type
= get_wcaps_type(get_wcaps(codec
, nid
));
1228 list_for_each_codec(c
, codec
->bus
) {
1229 for (i
= 0; i
< c
->cvt_setups
.used
; i
++) {
1230 p
= snd_array_elem(&c
->cvt_setups
, i
);
1231 if (!p
->active
&& p
->stream_tag
== stream_tag
&&
1232 get_wcaps_type(get_wcaps(c
, p
->nid
)) == type
)
1237 EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream
);
1239 static void really_cleanup_stream(struct hda_codec
*codec
,
1240 struct hda_cvt_setup
*q
);
1243 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1244 * @codec: the CODEC to clean up
1245 * @nid: the NID to clean up
1246 * @do_now: really clean up the stream instead of clearing the active flag
1248 void __snd_hda_codec_cleanup_stream(struct hda_codec
*codec
, hda_nid_t nid
,
1251 struct hda_cvt_setup
*p
;
1256 if (codec
->no_sticky_stream
)
1259 codec_dbg(codec
, "hda_codec_cleanup_stream: NID=0x%x\n", nid
);
1260 p
= get_hda_cvt_setup(codec
, nid
);
1262 /* here we just clear the active flag when do_now isn't set;
1263 * actual clean-ups will be done later in
1264 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1267 really_cleanup_stream(codec
, p
);
1272 EXPORT_SYMBOL_GPL(__snd_hda_codec_cleanup_stream
);
1274 static void really_cleanup_stream(struct hda_codec
*codec
,
1275 struct hda_cvt_setup
*q
)
1277 hda_nid_t nid
= q
->nid
;
1278 if (q
->stream_tag
|| q
->channel_id
)
1279 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CHANNEL_STREAMID
, 0);
1281 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_STREAM_FORMAT
, 0
1283 memset(q
, 0, sizeof(*q
));
1285 if (codec
->patch_ops
.stream_pm
)
1286 codec
->patch_ops
.stream_pm(codec
, nid
, false);
1289 /* clean up the all conflicting obsolete streams */
1290 static void purify_inactive_streams(struct hda_codec
*codec
)
1292 struct hda_codec
*c
;
1295 list_for_each_codec(c
, codec
->bus
) {
1296 for (i
= 0; i
< c
->cvt_setups
.used
; i
++) {
1297 struct hda_cvt_setup
*p
;
1298 p
= snd_array_elem(&c
->cvt_setups
, i
);
1300 really_cleanup_stream(c
, p
);
1306 /* clean up all streams; called from suspend */
1307 static void hda_cleanup_all_streams(struct hda_codec
*codec
)
1311 for (i
= 0; i
< codec
->cvt_setups
.used
; i
++) {
1312 struct hda_cvt_setup
*p
= snd_array_elem(&codec
->cvt_setups
, i
);
1314 really_cleanup_stream(codec
, p
);
1320 * amp access functions
1323 /* FIXME: more better hash key? */
1324 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1325 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1326 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1327 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1328 #define INFO_AMP_CAPS (1<<0)
1329 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1331 /* initialize the hash table */
1332 static void init_hda_cache(struct hda_cache_rec
*cache
,
1333 unsigned int record_size
)
1335 memset(cache
, 0, sizeof(*cache
));
1336 memset(cache
->hash
, 0xff, sizeof(cache
->hash
));
1337 snd_array_init(&cache
->buf
, record_size
, 64);
1340 static void free_hda_cache(struct hda_cache_rec
*cache
)
1342 snd_array_free(&cache
->buf
);
1345 /* query the hash. allocate an entry if not found. */
1346 static struct hda_cache_head
*get_hash(struct hda_cache_rec
*cache
, u32 key
)
1348 u16 idx
= key
% (u16
)ARRAY_SIZE(cache
->hash
);
1349 u16 cur
= cache
->hash
[idx
];
1350 struct hda_cache_head
*info
;
1352 while (cur
!= 0xffff) {
1353 info
= snd_array_elem(&cache
->buf
, cur
);
1354 if (info
->key
== key
)
1361 /* query the hash. allocate an entry if not found. */
1362 static struct hda_cache_head
*get_alloc_hash(struct hda_cache_rec
*cache
,
1365 struct hda_cache_head
*info
= get_hash(cache
, key
);
1368 /* add a new hash entry */
1369 info
= snd_array_new(&cache
->buf
);
1372 cur
= snd_array_index(&cache
->buf
, info
);
1376 idx
= key
% (u16
)ARRAY_SIZE(cache
->hash
);
1377 info
->next
= cache
->hash
[idx
];
1378 cache
->hash
[idx
] = cur
;
1383 /* query and allocate an amp hash entry */
1384 static inline struct hda_amp_info
*
1385 get_alloc_amp_hash(struct hda_codec
*codec
, u32 key
)
1387 return (struct hda_amp_info
*)get_alloc_hash(&codec
->amp_cache
, key
);
1390 /* overwrite the value with the key in the caps hash */
1391 static int write_caps_hash(struct hda_codec
*codec
, u32 key
, unsigned int val
)
1393 struct hda_amp_info
*info
;
1395 mutex_lock(&codec
->hash_mutex
);
1396 info
= get_alloc_amp_hash(codec
, key
);
1398 mutex_unlock(&codec
->hash_mutex
);
1401 info
->amp_caps
= val
;
1402 info
->head
.val
|= INFO_AMP_CAPS
;
1403 mutex_unlock(&codec
->hash_mutex
);
1407 /* query the value from the caps hash; if not found, fetch the current
1408 * value from the given function and store in the hash
1411 query_caps_hash(struct hda_codec
*codec
, hda_nid_t nid
, int dir
, u32 key
,
1412 unsigned int (*func
)(struct hda_codec
*, hda_nid_t
, int))
1414 struct hda_amp_info
*info
;
1417 mutex_lock(&codec
->hash_mutex
);
1418 info
= get_alloc_amp_hash(codec
, key
);
1420 mutex_unlock(&codec
->hash_mutex
);
1423 if (!(info
->head
.val
& INFO_AMP_CAPS
)) {
1424 mutex_unlock(&codec
->hash_mutex
); /* for reentrance */
1425 val
= func(codec
, nid
, dir
);
1426 write_caps_hash(codec
, key
, val
);
1428 val
= info
->amp_caps
;
1429 mutex_unlock(&codec
->hash_mutex
);
1434 static unsigned int read_amp_cap(struct hda_codec
*codec
, hda_nid_t nid
,
1437 if (!(get_wcaps(codec
, nid
) & AC_WCAP_AMP_OVRD
))
1438 nid
= codec
->core
.afg
;
1439 return snd_hda_param_read(codec
, nid
,
1440 direction
== HDA_OUTPUT
?
1441 AC_PAR_AMP_OUT_CAP
: AC_PAR_AMP_IN_CAP
);
1445 * query_amp_caps - query AMP capabilities
1446 * @codec: the HD-auio codec
1447 * @nid: the NID to query
1448 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1450 * Query AMP capabilities for the given widget and direction.
1451 * Returns the obtained capability bits.
1453 * When cap bits have been already read, this doesn't read again but
1454 * returns the cached value.
1456 u32
query_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int direction
)
1458 return query_caps_hash(codec
, nid
, direction
,
1459 HDA_HASH_KEY(nid
, direction
, 0),
1462 EXPORT_SYMBOL_GPL(query_amp_caps
);
1465 * snd_hda_check_amp_caps - query AMP capabilities
1466 * @codec: the HD-audio codec
1467 * @nid: the NID to query
1468 * @dir: either #HDA_INPUT or #HDA_OUTPUT
1469 * @bits: bit mask to check the result
1471 * Check whether the widget has the given amp capability for the direction.
1473 bool snd_hda_check_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
,
1474 int dir
, unsigned int bits
)
1478 if (get_wcaps(codec
, nid
) & (1 << (dir
+ 1)))
1479 if (query_amp_caps(codec
, nid
, dir
) & bits
)
1483 EXPORT_SYMBOL_GPL(snd_hda_check_amp_caps
);
1486 * snd_hda_override_amp_caps - Override the AMP capabilities
1487 * @codec: the CODEC to clean up
1488 * @nid: the NID to clean up
1489 * @dir: either #HDA_INPUT or #HDA_OUTPUT
1490 * @caps: the capability bits to set
1492 * Override the cached AMP caps bits value by the given one.
1493 * This function is useful if the driver needs to adjust the AMP ranges,
1494 * e.g. limit to 0dB, etc.
1496 * Returns zero if successful or a negative error code.
1498 int snd_hda_override_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1501 return write_caps_hash(codec
, HDA_HASH_KEY(nid
, dir
, 0), caps
);
1503 EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps
);
1505 static unsigned int read_pin_cap(struct hda_codec
*codec
, hda_nid_t nid
,
1508 return snd_hda_param_read(codec
, nid
, AC_PAR_PIN_CAP
);
1512 * snd_hda_query_pin_caps - Query PIN capabilities
1513 * @codec: the HD-auio codec
1514 * @nid: the NID to query
1516 * Query PIN capabilities for the given widget.
1517 * Returns the obtained capability bits.
1519 * When cap bits have been already read, this doesn't read again but
1520 * returns the cached value.
1522 u32
snd_hda_query_pin_caps(struct hda_codec
*codec
, hda_nid_t nid
)
1524 return query_caps_hash(codec
, nid
, 0, HDA_HASH_PINCAP_KEY(nid
),
1527 EXPORT_SYMBOL_GPL(snd_hda_query_pin_caps
);
1530 * snd_hda_override_pin_caps - Override the pin capabilities
1532 * @nid: the NID to override
1533 * @caps: the capability bits to set
1535 * Override the cached PIN capabilitiy bits value by the given one.
1537 * Returns zero if successful or a negative error code.
1539 int snd_hda_override_pin_caps(struct hda_codec
*codec
, hda_nid_t nid
,
1542 return write_caps_hash(codec
, HDA_HASH_PINCAP_KEY(nid
), caps
);
1544 EXPORT_SYMBOL_GPL(snd_hda_override_pin_caps
);
1546 /* read or sync the hash value with the current value;
1547 * call within hash_mutex
1549 static struct hda_amp_info
*
1550 update_amp_hash(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1551 int direction
, int index
, bool init_only
)
1553 struct hda_amp_info
*info
;
1554 unsigned int parm
, val
= 0;
1555 bool val_read
= false;
1558 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, index
));
1561 if (!(info
->head
.val
& INFO_AMP_VOL(ch
))) {
1563 mutex_unlock(&codec
->hash_mutex
);
1564 parm
= ch
? AC_AMP_GET_RIGHT
: AC_AMP_GET_LEFT
;
1565 parm
|= direction
== HDA_OUTPUT
?
1566 AC_AMP_GET_OUTPUT
: AC_AMP_GET_INPUT
;
1568 val
= snd_hda_codec_read(codec
, nid
, 0,
1569 AC_VERB_GET_AMP_GAIN_MUTE
, parm
);
1572 mutex_lock(&codec
->hash_mutex
);
1575 info
->vol
[ch
] = val
;
1576 info
->head
.val
|= INFO_AMP_VOL(ch
);
1577 } else if (init_only
)
1583 * write the current volume in info to the h/w
1585 static void put_vol_mute(struct hda_codec
*codec
, unsigned int amp_caps
,
1586 hda_nid_t nid
, int ch
, int direction
, int index
,
1591 parm
= ch
? AC_AMP_SET_RIGHT
: AC_AMP_SET_LEFT
;
1592 parm
|= direction
== HDA_OUTPUT
? AC_AMP_SET_OUTPUT
: AC_AMP_SET_INPUT
;
1593 parm
|= index
<< AC_AMP_SET_INDEX_SHIFT
;
1594 if ((val
& HDA_AMP_MUTE
) && !(amp_caps
& AC_AMPCAP_MUTE
) &&
1595 (amp_caps
& AC_AMPCAP_MIN_MUTE
))
1596 ; /* set the zero value as a fake mute */
1599 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, parm
);
1603 * snd_hda_codec_amp_read - Read AMP value
1604 * @codec: HD-audio codec
1605 * @nid: NID to read the AMP value
1606 * @ch: channel (left=0 or right=1)
1607 * @direction: #HDA_INPUT or #HDA_OUTPUT
1608 * @index: the index value (only for input direction)
1610 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1612 int snd_hda_codec_amp_read(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1613 int direction
, int index
)
1615 struct hda_amp_info
*info
;
1616 unsigned int val
= 0;
1618 mutex_lock(&codec
->hash_mutex
);
1619 info
= update_amp_hash(codec
, nid
, ch
, direction
, index
, false);
1621 val
= info
->vol
[ch
];
1622 mutex_unlock(&codec
->hash_mutex
);
1625 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_read
);
1627 static int codec_amp_update(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1628 int direction
, int idx
, int mask
, int val
,
1629 bool init_only
, bool cache_only
)
1631 struct hda_amp_info
*info
;
1634 if (snd_BUG_ON(mask
& ~0xff))
1638 mutex_lock(&codec
->hash_mutex
);
1639 info
= update_amp_hash(codec
, nid
, ch
, direction
, idx
, init_only
);
1641 mutex_unlock(&codec
->hash_mutex
);
1644 val
|= info
->vol
[ch
] & ~mask
;
1645 if (info
->vol
[ch
] == val
) {
1646 mutex_unlock(&codec
->hash_mutex
);
1649 info
->vol
[ch
] = val
;
1650 info
->head
.dirty
|= cache_only
;
1651 caps
= info
->amp_caps
;
1652 mutex_unlock(&codec
->hash_mutex
);
1654 put_vol_mute(codec
, caps
, nid
, ch
, direction
, idx
, val
);
1659 * snd_hda_codec_amp_update - update the AMP value
1660 * @codec: HD-audio codec
1661 * @nid: NID to read the AMP value
1662 * @ch: channel (left=0 or right=1)
1663 * @direction: #HDA_INPUT or #HDA_OUTPUT
1664 * @idx: the index value (only for input direction)
1665 * @mask: bit mask to set
1666 * @val: the bits value to set
1668 * Update the AMP value with a bit mask.
1669 * Returns 0 if the value is unchanged, 1 if changed.
1671 int snd_hda_codec_amp_update(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1672 int direction
, int idx
, int mask
, int val
)
1674 return codec_amp_update(codec
, nid
, ch
, direction
, idx
, mask
, val
,
1675 false, codec
->cached_write
);
1677 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update
);
1680 * snd_hda_codec_amp_stereo - update the AMP stereo values
1681 * @codec: HD-audio codec
1682 * @nid: NID to read the AMP value
1683 * @direction: #HDA_INPUT or #HDA_OUTPUT
1684 * @idx: the index value (only for input direction)
1685 * @mask: bit mask to set
1686 * @val: the bits value to set
1688 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1689 * stereo widget with the same mask and value.
1691 int snd_hda_codec_amp_stereo(struct hda_codec
*codec
, hda_nid_t nid
,
1692 int direction
, int idx
, int mask
, int val
)
1696 if (snd_BUG_ON(mask
& ~0xff))
1698 for (ch
= 0; ch
< 2; ch
++)
1699 ret
|= snd_hda_codec_amp_update(codec
, nid
, ch
, direction
,
1703 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo
);
1706 * snd_hda_codec_amp_init - initialize the AMP value
1707 * @codec: the HDA codec
1708 * @nid: NID to read the AMP value
1709 * @ch: channel (left=0 or right=1)
1710 * @dir: #HDA_INPUT or #HDA_OUTPUT
1711 * @idx: the index value (only for input direction)
1712 * @mask: bit mask to set
1713 * @val: the bits value to set
1715 * Works like snd_hda_codec_amp_update() but it writes the value only at
1716 * the first access. If the amp was already initialized / updated beforehand,
1717 * this does nothing.
1719 int snd_hda_codec_amp_init(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1720 int dir
, int idx
, int mask
, int val
)
1722 return codec_amp_update(codec
, nid
, ch
, dir
, idx
, mask
, val
, true,
1723 codec
->cached_write
);
1725 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init
);
1728 * snd_hda_codec_amp_init_stereo - initialize the stereo AMP value
1729 * @codec: the HDA codec
1730 * @nid: NID to read the AMP value
1731 * @dir: #HDA_INPUT or #HDA_OUTPUT
1732 * @idx: the index value (only for input direction)
1733 * @mask: bit mask to set
1734 * @val: the bits value to set
1736 * Call snd_hda_codec_amp_init() for both stereo channels.
1738 int snd_hda_codec_amp_init_stereo(struct hda_codec
*codec
, hda_nid_t nid
,
1739 int dir
, int idx
, int mask
, int val
)
1743 if (snd_BUG_ON(mask
& ~0xff))
1745 for (ch
= 0; ch
< 2; ch
++)
1746 ret
|= snd_hda_codec_amp_init(codec
, nid
, ch
, dir
,
1750 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo
);
1753 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1754 * @codec: HD-audio codec
1756 * Resume the all amp commands from the cache.
1758 void snd_hda_codec_resume_amp(struct hda_codec
*codec
)
1762 mutex_lock(&codec
->hash_mutex
);
1763 codec
->cached_write
= 0;
1764 for (i
= 0; i
< codec
->amp_cache
.buf
.used
; i
++) {
1765 struct hda_amp_info
*buffer
;
1768 unsigned int idx
, dir
, ch
;
1769 struct hda_amp_info info
;
1771 buffer
= snd_array_elem(&codec
->amp_cache
.buf
, i
);
1772 if (!buffer
->head
.dirty
)
1774 buffer
->head
.dirty
= 0;
1776 key
= info
.head
.key
;
1780 idx
= (key
>> 16) & 0xff;
1781 dir
= (key
>> 24) & 0xff;
1782 for (ch
= 0; ch
< 2; ch
++) {
1783 if (!(info
.head
.val
& INFO_AMP_VOL(ch
)))
1785 mutex_unlock(&codec
->hash_mutex
);
1786 put_vol_mute(codec
, info
.amp_caps
, nid
, ch
, dir
, idx
,
1788 mutex_lock(&codec
->hash_mutex
);
1791 mutex_unlock(&codec
->hash_mutex
);
1793 EXPORT_SYMBOL_GPL(snd_hda_codec_resume_amp
);
1795 static u32
get_amp_max_value(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1798 u32 caps
= query_amp_caps(codec
, nid
, dir
);
1800 caps
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1807 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1808 * @kcontrol: referred ctl element
1809 * @uinfo: pointer to get/store the data
1811 * The control element is supposed to have the private_value field
1812 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1814 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol
*kcontrol
,
1815 struct snd_ctl_elem_info
*uinfo
)
1817 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1818 u16 nid
= get_amp_nid(kcontrol
);
1819 u8 chs
= get_amp_channels(kcontrol
);
1820 int dir
= get_amp_direction(kcontrol
);
1821 unsigned int ofs
= get_amp_offset(kcontrol
);
1823 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1824 uinfo
->count
= chs
== 3 ? 2 : 1;
1825 uinfo
->value
.integer
.min
= 0;
1826 uinfo
->value
.integer
.max
= get_amp_max_value(codec
, nid
, dir
, ofs
);
1827 if (!uinfo
->value
.integer
.max
) {
1829 "num_steps = 0 for NID=0x%x (ctl = %s)\n",
1830 nid
, kcontrol
->id
.name
);
1835 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info
);
1838 static inline unsigned int
1839 read_amp_value(struct hda_codec
*codec
, hda_nid_t nid
,
1840 int ch
, int dir
, int idx
, unsigned int ofs
)
1843 val
= snd_hda_codec_amp_read(codec
, nid
, ch
, dir
, idx
);
1844 val
&= HDA_AMP_VOLMASK
;
1853 update_amp_value(struct hda_codec
*codec
, hda_nid_t nid
,
1854 int ch
, int dir
, int idx
, unsigned int ofs
,
1857 unsigned int maxval
;
1861 /* ofs = 0: raw max value */
1862 maxval
= get_amp_max_value(codec
, nid
, dir
, 0);
1865 return codec_amp_update(codec
, nid
, ch
, dir
, idx
, HDA_AMP_VOLMASK
, val
,
1866 false, !hda_codec_is_power_on(codec
));
1870 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1871 * @kcontrol: ctl element
1872 * @ucontrol: pointer to get/store the data
1874 * The control element is supposed to have the private_value field
1875 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1877 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol
*kcontrol
,
1878 struct snd_ctl_elem_value
*ucontrol
)
1880 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1881 hda_nid_t nid
= get_amp_nid(kcontrol
);
1882 int chs
= get_amp_channels(kcontrol
);
1883 int dir
= get_amp_direction(kcontrol
);
1884 int idx
= get_amp_index(kcontrol
);
1885 unsigned int ofs
= get_amp_offset(kcontrol
);
1886 long *valp
= ucontrol
->value
.integer
.value
;
1889 *valp
++ = read_amp_value(codec
, nid
, 0, dir
, idx
, ofs
);
1891 *valp
= read_amp_value(codec
, nid
, 1, dir
, idx
, ofs
);
1894 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get
);
1897 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1898 * @kcontrol: ctl element
1899 * @ucontrol: pointer to get/store the data
1901 * The control element is supposed to have the private_value field
1902 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1904 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol
*kcontrol
,
1905 struct snd_ctl_elem_value
*ucontrol
)
1907 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1908 hda_nid_t nid
= get_amp_nid(kcontrol
);
1909 int chs
= get_amp_channels(kcontrol
);
1910 int dir
= get_amp_direction(kcontrol
);
1911 int idx
= get_amp_index(kcontrol
);
1912 unsigned int ofs
= get_amp_offset(kcontrol
);
1913 long *valp
= ucontrol
->value
.integer
.value
;
1917 change
= update_amp_value(codec
, nid
, 0, dir
, idx
, ofs
, *valp
);
1921 change
|= update_amp_value(codec
, nid
, 1, dir
, idx
, ofs
, *valp
);
1924 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put
);
1927 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
1928 * @kcontrol: ctl element
1929 * @op_flag: operation flag
1930 * @size: byte size of input TLV
1933 * The control element is supposed to have the private_value field
1934 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1936 int snd_hda_mixer_amp_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
1937 unsigned int size
, unsigned int __user
*_tlv
)
1939 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1940 hda_nid_t nid
= get_amp_nid(kcontrol
);
1941 int dir
= get_amp_direction(kcontrol
);
1942 unsigned int ofs
= get_amp_offset(kcontrol
);
1943 bool min_mute
= get_amp_min_mute(kcontrol
);
1944 u32 caps
, val1
, val2
;
1946 if (size
< 4 * sizeof(unsigned int))
1948 caps
= query_amp_caps(codec
, nid
, dir
);
1949 val2
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1950 val2
= (val2
+ 1) * 25;
1951 val1
= -((caps
& AC_AMPCAP_OFFSET
) >> AC_AMPCAP_OFFSET_SHIFT
);
1953 val1
= ((int)val1
) * ((int)val2
);
1954 if (min_mute
|| (caps
& AC_AMPCAP_MIN_MUTE
))
1955 val2
|= TLV_DB_SCALE_MUTE
;
1956 if (put_user(SNDRV_CTL_TLVT_DB_SCALE
, _tlv
))
1958 if (put_user(2 * sizeof(unsigned int), _tlv
+ 1))
1960 if (put_user(val1
, _tlv
+ 2))
1962 if (put_user(val2
, _tlv
+ 3))
1966 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv
);
1969 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1970 * @codec: HD-audio codec
1971 * @nid: NID of a reference widget
1972 * @dir: #HDA_INPUT or #HDA_OUTPUT
1973 * @tlv: TLV data to be stored, at least 4 elements
1975 * Set (static) TLV data for a virtual master volume using the AMP caps
1976 * obtained from the reference NID.
1977 * The volume range is recalculated as if the max volume is 0dB.
1979 void snd_hda_set_vmaster_tlv(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1985 caps
= query_amp_caps(codec
, nid
, dir
);
1986 nums
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1987 step
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1988 step
= (step
+ 1) * 25;
1989 tlv
[0] = SNDRV_CTL_TLVT_DB_SCALE
;
1990 tlv
[1] = 2 * sizeof(unsigned int);
1991 tlv
[2] = -nums
* step
;
1994 EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv
);
1996 /* find a mixer control element with the given name */
1997 static struct snd_kcontrol
*
1998 find_mixer_ctl(struct hda_codec
*codec
, const char *name
, int dev
, int idx
)
2000 struct snd_ctl_elem_id id
;
2001 memset(&id
, 0, sizeof(id
));
2002 id
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
2005 if (snd_BUG_ON(strlen(name
) >= sizeof(id
.name
)))
2007 strcpy(id
.name
, name
);
2008 return snd_ctl_find_id(codec
->card
, &id
);
2012 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2013 * @codec: HD-audio codec
2014 * @name: ctl id name string
2016 * Get the control element with the given id string and IFACE_MIXER.
2018 struct snd_kcontrol
*snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
2021 return find_mixer_ctl(codec
, name
, 0, 0);
2023 EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl
);
2025 static int find_empty_mixer_ctl_idx(struct hda_codec
*codec
, const char *name
,
2029 /* 16 ctlrs should be large enough */
2030 for (i
= 0, idx
= start_idx
; i
< 16; i
++, idx
++) {
2031 if (!find_mixer_ctl(codec
, name
, 0, idx
))
2038 * snd_hda_ctl_add - Add a control element and assign to the codec
2039 * @codec: HD-audio codec
2040 * @nid: corresponding NID (optional)
2041 * @kctl: the control element to assign
2043 * Add the given control element to an array inside the codec instance.
2044 * All control elements belonging to a codec are supposed to be added
2045 * by this function so that a proper clean-up works at the free or
2046 * reconfiguration time.
2048 * If non-zero @nid is passed, the NID is assigned to the control element.
2049 * The assignment is shown in the codec proc file.
2051 * snd_hda_ctl_add() checks the control subdev id field whether
2052 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2053 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2054 * specifies if kctl->private_value is a HDA amplifier value.
2056 int snd_hda_ctl_add(struct hda_codec
*codec
, hda_nid_t nid
,
2057 struct snd_kcontrol
*kctl
)
2060 unsigned short flags
= 0;
2061 struct hda_nid_item
*item
;
2063 if (kctl
->id
.subdevice
& HDA_SUBDEV_AMP_FLAG
) {
2064 flags
|= HDA_NID_ITEM_AMP
;
2066 nid
= get_amp_nid_(kctl
->private_value
);
2068 if ((kctl
->id
.subdevice
& HDA_SUBDEV_NID_FLAG
) != 0 && nid
== 0)
2069 nid
= kctl
->id
.subdevice
& 0xffff;
2070 if (kctl
->id
.subdevice
& (HDA_SUBDEV_NID_FLAG
|HDA_SUBDEV_AMP_FLAG
))
2071 kctl
->id
.subdevice
= 0;
2072 err
= snd_ctl_add(codec
->card
, kctl
);
2075 item
= snd_array_new(&codec
->mixers
);
2080 item
->flags
= flags
;
2083 EXPORT_SYMBOL_GPL(snd_hda_ctl_add
);
2086 * snd_hda_add_nid - Assign a NID to a control element
2087 * @codec: HD-audio codec
2088 * @nid: corresponding NID (optional)
2089 * @kctl: the control element to assign
2090 * @index: index to kctl
2092 * Add the given control element to an array inside the codec instance.
2093 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2094 * NID:KCTL mapping - for example "Capture Source" selector.
2096 int snd_hda_add_nid(struct hda_codec
*codec
, struct snd_kcontrol
*kctl
,
2097 unsigned int index
, hda_nid_t nid
)
2099 struct hda_nid_item
*item
;
2102 item
= snd_array_new(&codec
->nids
);
2106 item
->index
= index
;
2110 codec_err(codec
, "no NID for mapping control %s:%d:%d\n",
2111 kctl
->id
.name
, kctl
->id
.index
, index
);
2114 EXPORT_SYMBOL_GPL(snd_hda_add_nid
);
2117 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2118 * @codec: HD-audio codec
2120 void snd_hda_ctls_clear(struct hda_codec
*codec
)
2123 struct hda_nid_item
*items
= codec
->mixers
.list
;
2124 for (i
= 0; i
< codec
->mixers
.used
; i
++)
2125 snd_ctl_remove(codec
->card
, items
[i
].kctl
);
2126 snd_array_free(&codec
->mixers
);
2127 snd_array_free(&codec
->nids
);
2131 * snd_hda_lock_devices - pseudo device locking
2134 * toggle card->shutdown to allow/disallow the device access (as a hack)
2136 int snd_hda_lock_devices(struct hda_bus
*bus
)
2138 struct snd_card
*card
= bus
->card
;
2139 struct hda_codec
*codec
;
2141 spin_lock(&card
->files_lock
);
2145 if (!list_empty(&card
->ctl_files
))
2148 list_for_each_codec(codec
, bus
) {
2149 struct hda_pcm
*cpcm
;
2150 list_for_each_entry(cpcm
, &codec
->pcm_list_head
, list
) {
2153 if (cpcm
->pcm
->streams
[0].substream_opened
||
2154 cpcm
->pcm
->streams
[1].substream_opened
)
2158 spin_unlock(&card
->files_lock
);
2164 spin_unlock(&card
->files_lock
);
2167 EXPORT_SYMBOL_GPL(snd_hda_lock_devices
);
2170 * snd_hda_unlock_devices - pseudo device unlocking
2173 void snd_hda_unlock_devices(struct hda_bus
*bus
)
2175 struct snd_card
*card
= bus
->card
;
2177 spin_lock(&card
->files_lock
);
2179 spin_unlock(&card
->files_lock
);
2181 EXPORT_SYMBOL_GPL(snd_hda_unlock_devices
);
2184 * snd_hda_codec_reset - Clear all objects assigned to the codec
2185 * @codec: HD-audio codec
2187 * This frees the all PCM and control elements assigned to the codec, and
2188 * clears the caches and restores the pin default configurations.
2190 * When a device is being used, it returns -EBSY. If successfully freed,
2193 int snd_hda_codec_reset(struct hda_codec
*codec
)
2195 struct hda_bus
*bus
= codec
->bus
;
2197 if (snd_hda_lock_devices(bus
) < 0)
2200 /* OK, let it free */
2201 snd_hdac_device_unregister(&codec
->core
);
2203 /* allow device access again */
2204 snd_hda_unlock_devices(bus
);
2208 typedef int (*map_slave_func_t
)(struct hda_codec
*, void *, struct snd_kcontrol
*);
2210 /* apply the function to all matching slave ctls in the mixer list */
2211 static int map_slaves(struct hda_codec
*codec
, const char * const *slaves
,
2212 const char *suffix
, map_slave_func_t func
, void *data
)
2214 struct hda_nid_item
*items
;
2215 const char * const *s
;
2218 items
= codec
->mixers
.list
;
2219 for (i
= 0; i
< codec
->mixers
.used
; i
++) {
2220 struct snd_kcontrol
*sctl
= items
[i
].kctl
;
2221 if (!sctl
|| sctl
->id
.iface
!= SNDRV_CTL_ELEM_IFACE_MIXER
)
2223 for (s
= slaves
; *s
; s
++) {
2224 char tmpname
[sizeof(sctl
->id
.name
)];
2225 const char *name
= *s
;
2227 snprintf(tmpname
, sizeof(tmpname
), "%s %s",
2231 if (!strcmp(sctl
->id
.name
, name
)) {
2232 err
= func(codec
, data
, sctl
);
2242 static int check_slave_present(struct hda_codec
*codec
,
2243 void *data
, struct snd_kcontrol
*sctl
)
2248 /* guess the value corresponding to 0dB */
2249 static int get_kctl_0dB_offset(struct hda_codec
*codec
,
2250 struct snd_kcontrol
*kctl
, int *step_to_check
)
2253 const int *tlv
= NULL
;
2256 if (kctl
->vd
[0].access
& SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
) {
2257 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2258 mm_segment_t fs
= get_fs();
2260 if (!kctl
->tlv
.c(kctl
, 0, sizeof(_tlv
), _tlv
))
2263 } else if (kctl
->vd
[0].access
& SNDRV_CTL_ELEM_ACCESS_TLV_READ
)
2265 if (tlv
&& tlv
[0] == SNDRV_CTL_TLVT_DB_SCALE
) {
2267 step
&= ~TLV_DB_SCALE_MUTE
;
2270 if (*step_to_check
&& *step_to_check
!= step
) {
2271 codec_err(codec
, "Mismatching dB step for vmaster slave (%d!=%d)\n",
2272 - *step_to_check
, step
);
2275 *step_to_check
= step
;
2276 val
= -tlv
[2] / step
;
2281 /* call kctl->put with the given value(s) */
2282 static int put_kctl_with_value(struct snd_kcontrol
*kctl
, int val
)
2284 struct snd_ctl_elem_value
*ucontrol
;
2285 ucontrol
= kzalloc(sizeof(*ucontrol
), GFP_KERNEL
);
2288 ucontrol
->value
.integer
.value
[0] = val
;
2289 ucontrol
->value
.integer
.value
[1] = val
;
2290 kctl
->put(kctl
, ucontrol
);
2295 /* initialize the slave volume with 0dB */
2296 static int init_slave_0dB(struct hda_codec
*codec
,
2297 void *data
, struct snd_kcontrol
*slave
)
2299 int offset
= get_kctl_0dB_offset(codec
, slave
, data
);
2301 put_kctl_with_value(slave
, offset
);
2305 /* unmute the slave */
2306 static int init_slave_unmute(struct hda_codec
*codec
,
2307 void *data
, struct snd_kcontrol
*slave
)
2309 return put_kctl_with_value(slave
, 1);
2312 static int add_slave(struct hda_codec
*codec
,
2313 void *data
, struct snd_kcontrol
*slave
)
2315 return snd_ctl_add_slave(data
, slave
);
2319 * __snd_hda_add_vmaster - create a virtual master control and add slaves
2320 * @codec: HD-audio codec
2321 * @name: vmaster control name
2322 * @tlv: TLV data (optional)
2323 * @slaves: slave control names (optional)
2324 * @suffix: suffix string to each slave name (optional)
2325 * @init_slave_vol: initialize slaves to unmute/0dB
2326 * @ctl_ret: store the vmaster kcontrol in return
2328 * Create a virtual master control with the given name. The TLV data
2329 * must be either NULL or a valid data.
2331 * @slaves is a NULL-terminated array of strings, each of which is a
2332 * slave control name. All controls with these names are assigned to
2333 * the new virtual master control.
2335 * This function returns zero if successful or a negative error code.
2337 int __snd_hda_add_vmaster(struct hda_codec
*codec
, char *name
,
2338 unsigned int *tlv
, const char * const *slaves
,
2339 const char *suffix
, bool init_slave_vol
,
2340 struct snd_kcontrol
**ctl_ret
)
2342 struct snd_kcontrol
*kctl
;
2348 err
= map_slaves(codec
, slaves
, suffix
, check_slave_present
, NULL
);
2350 codec_dbg(codec
, "No slave found for %s\n", name
);
2353 kctl
= snd_ctl_make_virtual_master(name
, tlv
);
2356 err
= snd_hda_ctl_add(codec
, 0, kctl
);
2360 err
= map_slaves(codec
, slaves
, suffix
, add_slave
, kctl
);
2364 /* init with master mute & zero volume */
2365 put_kctl_with_value(kctl
, 0);
2366 if (init_slave_vol
) {
2368 map_slaves(codec
, slaves
, suffix
,
2369 tlv
? init_slave_0dB
: init_slave_unmute
, &step
);
2376 EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster
);
2379 * mute-LED control using vmaster
2381 static int vmaster_mute_mode_info(struct snd_kcontrol
*kcontrol
,
2382 struct snd_ctl_elem_info
*uinfo
)
2384 static const char * const texts
[] = {
2385 "On", "Off", "Follow Master"
2388 return snd_ctl_enum_info(uinfo
, 1, 3, texts
);
2391 static int vmaster_mute_mode_get(struct snd_kcontrol
*kcontrol
,
2392 struct snd_ctl_elem_value
*ucontrol
)
2394 struct hda_vmaster_mute_hook
*hook
= snd_kcontrol_chip(kcontrol
);
2395 ucontrol
->value
.enumerated
.item
[0] = hook
->mute_mode
;
2399 static int vmaster_mute_mode_put(struct snd_kcontrol
*kcontrol
,
2400 struct snd_ctl_elem_value
*ucontrol
)
2402 struct hda_vmaster_mute_hook
*hook
= snd_kcontrol_chip(kcontrol
);
2403 unsigned int old_mode
= hook
->mute_mode
;
2405 hook
->mute_mode
= ucontrol
->value
.enumerated
.item
[0];
2406 if (hook
->mute_mode
> HDA_VMUTE_FOLLOW_MASTER
)
2407 hook
->mute_mode
= HDA_VMUTE_FOLLOW_MASTER
;
2408 if (old_mode
== hook
->mute_mode
)
2410 snd_hda_sync_vmaster_hook(hook
);
2414 static struct snd_kcontrol_new vmaster_mute_mode
= {
2415 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2416 .name
= "Mute-LED Mode",
2417 .info
= vmaster_mute_mode_info
,
2418 .get
= vmaster_mute_mode_get
,
2419 .put
= vmaster_mute_mode_put
,
2423 * snd_hda_add_vmaster_hook - Add a vmaster hook for mute-LED
2424 * @codec: the HDA codec
2425 * @hook: the vmaster hook object
2426 * @expose_enum_ctl: flag to create an enum ctl
2428 * Add a mute-LED hook with the given vmaster switch kctl.
2429 * When @expose_enum_ctl is set, "Mute-LED Mode" control is automatically
2430 * created and associated with the given hook.
2432 int snd_hda_add_vmaster_hook(struct hda_codec
*codec
,
2433 struct hda_vmaster_mute_hook
*hook
,
2434 bool expose_enum_ctl
)
2436 struct snd_kcontrol
*kctl
;
2438 if (!hook
->hook
|| !hook
->sw_kctl
)
2440 snd_ctl_add_vmaster_hook(hook
->sw_kctl
, hook
->hook
, codec
);
2441 hook
->codec
= codec
;
2442 hook
->mute_mode
= HDA_VMUTE_FOLLOW_MASTER
;
2443 if (!expose_enum_ctl
)
2445 kctl
= snd_ctl_new1(&vmaster_mute_mode
, hook
);
2448 return snd_hda_ctl_add(codec
, 0, kctl
);
2450 EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook
);
2453 * snd_hda_sync_vmaster_hook - Sync vmaster hook
2454 * @hook: the vmaster hook
2456 * Call the hook with the current value for synchronization.
2457 * Should be called in init callback.
2459 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook
*hook
)
2461 if (!hook
->hook
|| !hook
->codec
)
2463 /* don't call vmaster hook in the destructor since it might have
2464 * been already destroyed
2466 if (hook
->codec
->bus
->shutdown
)
2468 switch (hook
->mute_mode
) {
2469 case HDA_VMUTE_FOLLOW_MASTER
:
2470 snd_ctl_sync_vmaster_hook(hook
->sw_kctl
);
2473 hook
->hook(hook
->codec
, hook
->mute_mode
);
2477 EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook
);
2481 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2482 * @kcontrol: referred ctl element
2483 * @uinfo: pointer to get/store the data
2485 * The control element is supposed to have the private_value field
2486 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2488 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol
*kcontrol
,
2489 struct snd_ctl_elem_info
*uinfo
)
2491 int chs
= get_amp_channels(kcontrol
);
2493 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
2494 uinfo
->count
= chs
== 3 ? 2 : 1;
2495 uinfo
->value
.integer
.min
= 0;
2496 uinfo
->value
.integer
.max
= 1;
2499 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info
);
2502 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2503 * @kcontrol: ctl element
2504 * @ucontrol: pointer to get/store the data
2506 * The control element is supposed to have the private_value field
2507 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2509 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol
*kcontrol
,
2510 struct snd_ctl_elem_value
*ucontrol
)
2512 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2513 hda_nid_t nid
= get_amp_nid(kcontrol
);
2514 int chs
= get_amp_channels(kcontrol
);
2515 int dir
= get_amp_direction(kcontrol
);
2516 int idx
= get_amp_index(kcontrol
);
2517 long *valp
= ucontrol
->value
.integer
.value
;
2520 *valp
++ = (snd_hda_codec_amp_read(codec
, nid
, 0, dir
, idx
) &
2521 HDA_AMP_MUTE
) ? 0 : 1;
2523 *valp
= (snd_hda_codec_amp_read(codec
, nid
, 1, dir
, idx
) &
2524 HDA_AMP_MUTE
) ? 0 : 1;
2527 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get
);
2530 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2531 * @kcontrol: ctl element
2532 * @ucontrol: pointer to get/store the data
2534 * The control element is supposed to have the private_value field
2535 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2537 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol
*kcontrol
,
2538 struct snd_ctl_elem_value
*ucontrol
)
2540 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2541 hda_nid_t nid
= get_amp_nid(kcontrol
);
2542 int chs
= get_amp_channels(kcontrol
);
2543 int dir
= get_amp_direction(kcontrol
);
2544 int idx
= get_amp_index(kcontrol
);
2545 long *valp
= ucontrol
->value
.integer
.value
;
2549 change
= codec_amp_update(codec
, nid
, 0, dir
, idx
,
2551 *valp
? 0 : HDA_AMP_MUTE
, false,
2552 !hda_codec_is_power_on(codec
));
2556 change
|= codec_amp_update(codec
, nid
, 1, dir
, idx
,
2558 *valp
? 0 : HDA_AMP_MUTE
, false,
2559 !hda_codec_is_power_on(codec
));
2560 hda_call_check_power_status(codec
, nid
);
2563 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put
);
2566 * bound volume controls
2568 * bind multiple volumes (# indices, from 0)
2571 #define AMP_VAL_IDX_SHIFT 19
2572 #define AMP_VAL_IDX_MASK (0x0f<<19)
2575 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2576 * @kcontrol: ctl element
2577 * @ucontrol: pointer to get/store the data
2579 * The control element is supposed to have the private_value field
2580 * set up via HDA_BIND_MUTE*() macros.
2582 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol
*kcontrol
,
2583 struct snd_ctl_elem_value
*ucontrol
)
2585 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2589 mutex_lock(&codec
->control_mutex
);
2590 pval
= kcontrol
->private_value
;
2591 kcontrol
->private_value
= pval
& ~AMP_VAL_IDX_MASK
; /* index 0 */
2592 err
= snd_hda_mixer_amp_switch_get(kcontrol
, ucontrol
);
2593 kcontrol
->private_value
= pval
;
2594 mutex_unlock(&codec
->control_mutex
);
2597 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_get
);
2600 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2601 * @kcontrol: ctl element
2602 * @ucontrol: pointer to get/store the data
2604 * The control element is supposed to have the private_value field
2605 * set up via HDA_BIND_MUTE*() macros.
2607 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol
*kcontrol
,
2608 struct snd_ctl_elem_value
*ucontrol
)
2610 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2612 int i
, indices
, err
= 0, change
= 0;
2614 mutex_lock(&codec
->control_mutex
);
2615 pval
= kcontrol
->private_value
;
2616 indices
= (pval
& AMP_VAL_IDX_MASK
) >> AMP_VAL_IDX_SHIFT
;
2617 for (i
= 0; i
< indices
; i
++) {
2618 kcontrol
->private_value
= (pval
& ~AMP_VAL_IDX_MASK
) |
2619 (i
<< AMP_VAL_IDX_SHIFT
);
2620 err
= snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
2625 kcontrol
->private_value
= pval
;
2626 mutex_unlock(&codec
->control_mutex
);
2627 return err
< 0 ? err
: change
;
2629 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_put
);
2632 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2633 * @kcontrol: referred ctl element
2634 * @uinfo: pointer to get/store the data
2636 * The control element is supposed to have the private_value field
2637 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2639 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol
*kcontrol
,
2640 struct snd_ctl_elem_info
*uinfo
)
2642 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2643 struct hda_bind_ctls
*c
;
2646 mutex_lock(&codec
->control_mutex
);
2647 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2648 kcontrol
->private_value
= *c
->values
;
2649 err
= c
->ops
->info(kcontrol
, uinfo
);
2650 kcontrol
->private_value
= (long)c
;
2651 mutex_unlock(&codec
->control_mutex
);
2654 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_info
);
2657 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2658 * @kcontrol: ctl element
2659 * @ucontrol: pointer to get/store the data
2661 * The control element is supposed to have the private_value field
2662 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2664 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol
*kcontrol
,
2665 struct snd_ctl_elem_value
*ucontrol
)
2667 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2668 struct hda_bind_ctls
*c
;
2671 mutex_lock(&codec
->control_mutex
);
2672 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2673 kcontrol
->private_value
= *c
->values
;
2674 err
= c
->ops
->get(kcontrol
, ucontrol
);
2675 kcontrol
->private_value
= (long)c
;
2676 mutex_unlock(&codec
->control_mutex
);
2679 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_get
);
2682 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2683 * @kcontrol: ctl element
2684 * @ucontrol: pointer to get/store the data
2686 * The control element is supposed to have the private_value field
2687 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2689 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol
*kcontrol
,
2690 struct snd_ctl_elem_value
*ucontrol
)
2692 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2693 struct hda_bind_ctls
*c
;
2694 unsigned long *vals
;
2695 int err
= 0, change
= 0;
2697 mutex_lock(&codec
->control_mutex
);
2698 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2699 for (vals
= c
->values
; *vals
; vals
++) {
2700 kcontrol
->private_value
= *vals
;
2701 err
= c
->ops
->put(kcontrol
, ucontrol
);
2706 kcontrol
->private_value
= (long)c
;
2707 mutex_unlock(&codec
->control_mutex
);
2708 return err
< 0 ? err
: change
;
2710 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_put
);
2713 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2714 * @kcontrol: ctl element
2715 * @op_flag: operation flag
2716 * @size: byte size of input TLV
2719 * The control element is supposed to have the private_value field
2720 * set up via HDA_BIND_VOL() macro.
2722 int snd_hda_mixer_bind_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
2723 unsigned int size
, unsigned int __user
*tlv
)
2725 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2726 struct hda_bind_ctls
*c
;
2729 mutex_lock(&codec
->control_mutex
);
2730 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2731 kcontrol
->private_value
= *c
->values
;
2732 err
= c
->ops
->tlv(kcontrol
, op_flag
, size
, tlv
);
2733 kcontrol
->private_value
= (long)c
;
2734 mutex_unlock(&codec
->control_mutex
);
2737 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_tlv
);
2739 struct hda_ctl_ops snd_hda_bind_vol
= {
2740 .info
= snd_hda_mixer_amp_volume_info
,
2741 .get
= snd_hda_mixer_amp_volume_get
,
2742 .put
= snd_hda_mixer_amp_volume_put
,
2743 .tlv
= snd_hda_mixer_amp_tlv
2745 EXPORT_SYMBOL_GPL(snd_hda_bind_vol
);
2747 struct hda_ctl_ops snd_hda_bind_sw
= {
2748 .info
= snd_hda_mixer_amp_switch_info
,
2749 .get
= snd_hda_mixer_amp_switch_get
,
2750 .put
= snd_hda_mixer_amp_switch_put
,
2751 .tlv
= snd_hda_mixer_amp_tlv
2753 EXPORT_SYMBOL_GPL(snd_hda_bind_sw
);
2756 * SPDIF out controls
2759 static int snd_hda_spdif_mask_info(struct snd_kcontrol
*kcontrol
,
2760 struct snd_ctl_elem_info
*uinfo
)
2762 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
2767 static int snd_hda_spdif_cmask_get(struct snd_kcontrol
*kcontrol
,
2768 struct snd_ctl_elem_value
*ucontrol
)
2770 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
2771 IEC958_AES0_NONAUDIO
|
2772 IEC958_AES0_CON_EMPHASIS_5015
|
2773 IEC958_AES0_CON_NOT_COPYRIGHT
;
2774 ucontrol
->value
.iec958
.status
[1] = IEC958_AES1_CON_CATEGORY
|
2775 IEC958_AES1_CON_ORIGINAL
;
2779 static int snd_hda_spdif_pmask_get(struct snd_kcontrol
*kcontrol
,
2780 struct snd_ctl_elem_value
*ucontrol
)
2782 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
2783 IEC958_AES0_NONAUDIO
|
2784 IEC958_AES0_PRO_EMPHASIS_5015
;
2788 static int snd_hda_spdif_default_get(struct snd_kcontrol
*kcontrol
,
2789 struct snd_ctl_elem_value
*ucontrol
)
2791 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2792 int idx
= kcontrol
->private_value
;
2793 struct hda_spdif_out
*spdif
;
2795 mutex_lock(&codec
->spdif_mutex
);
2796 spdif
= snd_array_elem(&codec
->spdif_out
, idx
);
2797 ucontrol
->value
.iec958
.status
[0] = spdif
->status
& 0xff;
2798 ucontrol
->value
.iec958
.status
[1] = (spdif
->status
>> 8) & 0xff;
2799 ucontrol
->value
.iec958
.status
[2] = (spdif
->status
>> 16) & 0xff;
2800 ucontrol
->value
.iec958
.status
[3] = (spdif
->status
>> 24) & 0xff;
2801 mutex_unlock(&codec
->spdif_mutex
);
2806 /* convert from SPDIF status bits to HDA SPDIF bits
2807 * bit 0 (DigEn) is always set zero (to be filled later)
2809 static unsigned short convert_from_spdif_status(unsigned int sbits
)
2811 unsigned short val
= 0;
2813 if (sbits
& IEC958_AES0_PROFESSIONAL
)
2814 val
|= AC_DIG1_PROFESSIONAL
;
2815 if (sbits
& IEC958_AES0_NONAUDIO
)
2816 val
|= AC_DIG1_NONAUDIO
;
2817 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
2818 if ((sbits
& IEC958_AES0_PRO_EMPHASIS
) ==
2819 IEC958_AES0_PRO_EMPHASIS_5015
)
2820 val
|= AC_DIG1_EMPHASIS
;
2822 if ((sbits
& IEC958_AES0_CON_EMPHASIS
) ==
2823 IEC958_AES0_CON_EMPHASIS_5015
)
2824 val
|= AC_DIG1_EMPHASIS
;
2825 if (!(sbits
& IEC958_AES0_CON_NOT_COPYRIGHT
))
2826 val
|= AC_DIG1_COPYRIGHT
;
2827 if (sbits
& (IEC958_AES1_CON_ORIGINAL
<< 8))
2828 val
|= AC_DIG1_LEVEL
;
2829 val
|= sbits
& (IEC958_AES1_CON_CATEGORY
<< 8);
2834 /* convert to SPDIF status bits from HDA SPDIF bits
2836 static unsigned int convert_to_spdif_status(unsigned short val
)
2838 unsigned int sbits
= 0;
2840 if (val
& AC_DIG1_NONAUDIO
)
2841 sbits
|= IEC958_AES0_NONAUDIO
;
2842 if (val
& AC_DIG1_PROFESSIONAL
)
2843 sbits
|= IEC958_AES0_PROFESSIONAL
;
2844 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
2845 if (val
& AC_DIG1_EMPHASIS
)
2846 sbits
|= IEC958_AES0_PRO_EMPHASIS_5015
;
2848 if (val
& AC_DIG1_EMPHASIS
)
2849 sbits
|= IEC958_AES0_CON_EMPHASIS_5015
;
2850 if (!(val
& AC_DIG1_COPYRIGHT
))
2851 sbits
|= IEC958_AES0_CON_NOT_COPYRIGHT
;
2852 if (val
& AC_DIG1_LEVEL
)
2853 sbits
|= (IEC958_AES1_CON_ORIGINAL
<< 8);
2854 sbits
|= val
& (0x7f << 8);
2859 /* set digital convert verbs both for the given NID and its slaves */
2860 static void set_dig_out(struct hda_codec
*codec
, hda_nid_t nid
,
2865 snd_hda_codec_write_cache(codec
, nid
, 0, verb
, val
);
2866 d
= codec
->slave_dig_outs
;
2870 snd_hda_codec_write_cache(codec
, *d
, 0, verb
, val
);
2873 static inline void set_dig_out_convert(struct hda_codec
*codec
, hda_nid_t nid
,
2877 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_1
, dig1
);
2879 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_2
, dig2
);
2882 static int snd_hda_spdif_default_put(struct snd_kcontrol
*kcontrol
,
2883 struct snd_ctl_elem_value
*ucontrol
)
2885 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2886 int idx
= kcontrol
->private_value
;
2887 struct hda_spdif_out
*spdif
;
2892 mutex_lock(&codec
->spdif_mutex
);
2893 spdif
= snd_array_elem(&codec
->spdif_out
, idx
);
2895 spdif
->status
= ucontrol
->value
.iec958
.status
[0] |
2896 ((unsigned int)ucontrol
->value
.iec958
.status
[1] << 8) |
2897 ((unsigned int)ucontrol
->value
.iec958
.status
[2] << 16) |
2898 ((unsigned int)ucontrol
->value
.iec958
.status
[3] << 24);
2899 val
= convert_from_spdif_status(spdif
->status
);
2900 val
|= spdif
->ctls
& 1;
2901 change
= spdif
->ctls
!= val
;
2903 if (change
&& nid
!= (u16
)-1)
2904 set_dig_out_convert(codec
, nid
, val
& 0xff, (val
>> 8) & 0xff);
2905 mutex_unlock(&codec
->spdif_mutex
);
2909 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2911 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol
*kcontrol
,
2912 struct snd_ctl_elem_value
*ucontrol
)
2914 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2915 int idx
= kcontrol
->private_value
;
2916 struct hda_spdif_out
*spdif
;
2918 mutex_lock(&codec
->spdif_mutex
);
2919 spdif
= snd_array_elem(&codec
->spdif_out
, idx
);
2920 ucontrol
->value
.integer
.value
[0] = spdif
->ctls
& AC_DIG1_ENABLE
;
2921 mutex_unlock(&codec
->spdif_mutex
);
2925 static inline void set_spdif_ctls(struct hda_codec
*codec
, hda_nid_t nid
,
2928 set_dig_out_convert(codec
, nid
, dig1
, dig2
);
2929 /* unmute amp switch (if any) */
2930 if ((get_wcaps(codec
, nid
) & AC_WCAP_OUT_AMP
) &&
2931 (dig1
& AC_DIG1_ENABLE
))
2932 snd_hda_codec_amp_stereo(codec
, nid
, HDA_OUTPUT
, 0,
2936 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol
*kcontrol
,
2937 struct snd_ctl_elem_value
*ucontrol
)
2939 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2940 int idx
= kcontrol
->private_value
;
2941 struct hda_spdif_out
*spdif
;
2946 mutex_lock(&codec
->spdif_mutex
);
2947 spdif
= snd_array_elem(&codec
->spdif_out
, idx
);
2949 val
= spdif
->ctls
& ~AC_DIG1_ENABLE
;
2950 if (ucontrol
->value
.integer
.value
[0])
2951 val
|= AC_DIG1_ENABLE
;
2952 change
= spdif
->ctls
!= val
;
2954 if (change
&& nid
!= (u16
)-1)
2955 set_spdif_ctls(codec
, nid
, val
& 0xff, -1);
2956 mutex_unlock(&codec
->spdif_mutex
);
2960 static struct snd_kcontrol_new dig_mixes
[] = {
2962 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2963 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2964 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, CON_MASK
),
2965 .info
= snd_hda_spdif_mask_info
,
2966 .get
= snd_hda_spdif_cmask_get
,
2969 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2970 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2971 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, PRO_MASK
),
2972 .info
= snd_hda_spdif_mask_info
,
2973 .get
= snd_hda_spdif_pmask_get
,
2976 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2977 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, DEFAULT
),
2978 .info
= snd_hda_spdif_mask_info
,
2979 .get
= snd_hda_spdif_default_get
,
2980 .put
= snd_hda_spdif_default_put
,
2983 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2984 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, SWITCH
),
2985 .info
= snd_hda_spdif_out_switch_info
,
2986 .get
= snd_hda_spdif_out_switch_get
,
2987 .put
= snd_hda_spdif_out_switch_put
,
2993 * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
2994 * @codec: the HDA codec
2995 * @associated_nid: NID that new ctls associated with
2996 * @cvt_nid: converter NID
2997 * @type: HDA_PCM_TYPE_*
2998 * Creates controls related with the digital output.
2999 * Called from each patch supporting the digital out.
3001 * Returns 0 if successful, or a negative error code.
3003 int snd_hda_create_dig_out_ctls(struct hda_codec
*codec
,
3004 hda_nid_t associated_nid
,
3009 struct snd_kcontrol
*kctl
;
3010 struct snd_kcontrol_new
*dig_mix
;
3012 const int spdif_index
= 16;
3013 struct hda_spdif_out
*spdif
;
3014 struct hda_bus
*bus
= codec
->bus
;
3016 if (bus
->primary_dig_out_type
== HDA_PCM_TYPE_HDMI
&&
3017 type
== HDA_PCM_TYPE_SPDIF
) {
3019 } else if (bus
->primary_dig_out_type
== HDA_PCM_TYPE_SPDIF
&&
3020 type
== HDA_PCM_TYPE_HDMI
) {
3021 /* suppose a single SPDIF device */
3022 for (dig_mix
= dig_mixes
; dig_mix
->name
; dig_mix
++) {
3023 kctl
= find_mixer_ctl(codec
, dig_mix
->name
, 0, 0);
3026 kctl
->id
.index
= spdif_index
;
3028 bus
->primary_dig_out_type
= HDA_PCM_TYPE_HDMI
;
3030 if (!bus
->primary_dig_out_type
)
3031 bus
->primary_dig_out_type
= type
;
3033 idx
= find_empty_mixer_ctl_idx(codec
, "IEC958 Playback Switch", idx
);
3035 codec_err(codec
, "too many IEC958 outputs\n");
3038 spdif
= snd_array_new(&codec
->spdif_out
);
3041 for (dig_mix
= dig_mixes
; dig_mix
->name
; dig_mix
++) {
3042 kctl
= snd_ctl_new1(dig_mix
, codec
);
3045 kctl
->id
.index
= idx
;
3046 kctl
->private_value
= codec
->spdif_out
.used
- 1;
3047 err
= snd_hda_ctl_add(codec
, associated_nid
, kctl
);
3051 spdif
->nid
= cvt_nid
;
3052 spdif
->ctls
= snd_hda_codec_read(codec
, cvt_nid
, 0,
3053 AC_VERB_GET_DIGI_CONVERT_1
, 0);
3054 spdif
->status
= convert_to_spdif_status(spdif
->ctls
);
3057 EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls
);
3060 * snd_hda_spdif_out_of_nid - get the hda_spdif_out entry from the given NID
3061 * @codec: the HDA codec
3064 * call within spdif_mutex lock
3066 struct hda_spdif_out
*snd_hda_spdif_out_of_nid(struct hda_codec
*codec
,
3070 for (i
= 0; i
< codec
->spdif_out
.used
; i
++) {
3071 struct hda_spdif_out
*spdif
=
3072 snd_array_elem(&codec
->spdif_out
, i
);
3073 if (spdif
->nid
== nid
)
3078 EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_nid
);
3081 * snd_hda_spdif_ctls_unassign - Unassign the given SPDIF ctl
3082 * @codec: the HDA codec
3083 * @idx: the SPDIF ctl index
3085 * Unassign the widget from the given SPDIF control.
3087 void snd_hda_spdif_ctls_unassign(struct hda_codec
*codec
, int idx
)
3089 struct hda_spdif_out
*spdif
;
3091 mutex_lock(&codec
->spdif_mutex
);
3092 spdif
= snd_array_elem(&codec
->spdif_out
, idx
);
3093 spdif
->nid
= (u16
)-1;
3094 mutex_unlock(&codec
->spdif_mutex
);
3096 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign
);
3099 * snd_hda_spdif_ctls_assign - Assign the SPDIF controls to the given NID
3100 * @codec: the HDA codec
3101 * @idx: the SPDIF ctl idx
3104 * Assign the widget to the SPDIF control with the given index.
3106 void snd_hda_spdif_ctls_assign(struct hda_codec
*codec
, int idx
, hda_nid_t nid
)
3108 struct hda_spdif_out
*spdif
;
3111 mutex_lock(&codec
->spdif_mutex
);
3112 spdif
= snd_array_elem(&codec
->spdif_out
, idx
);
3113 if (spdif
->nid
!= nid
) {
3116 set_spdif_ctls(codec
, nid
, val
& 0xff, (val
>> 8) & 0xff);
3118 mutex_unlock(&codec
->spdif_mutex
);
3120 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign
);
3123 * SPDIF sharing with analog output
3125 static int spdif_share_sw_get(struct snd_kcontrol
*kcontrol
,
3126 struct snd_ctl_elem_value
*ucontrol
)
3128 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
3129 ucontrol
->value
.integer
.value
[0] = mout
->share_spdif
;
3133 static int spdif_share_sw_put(struct snd_kcontrol
*kcontrol
,
3134 struct snd_ctl_elem_value
*ucontrol
)
3136 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
3137 mout
->share_spdif
= !!ucontrol
->value
.integer
.value
[0];
3141 static struct snd_kcontrol_new spdif_share_sw
= {
3142 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3143 .name
= "IEC958 Default PCM Playback Switch",
3144 .info
= snd_ctl_boolean_mono_info
,
3145 .get
= spdif_share_sw_get
,
3146 .put
= spdif_share_sw_put
,
3150 * snd_hda_create_spdif_share_sw - create Default PCM switch
3151 * @codec: the HDA codec
3152 * @mout: multi-out instance
3154 int snd_hda_create_spdif_share_sw(struct hda_codec
*codec
,
3155 struct hda_multi_out
*mout
)
3157 struct snd_kcontrol
*kctl
;
3159 if (!mout
->dig_out_nid
)
3162 kctl
= snd_ctl_new1(&spdif_share_sw
, mout
);
3165 /* ATTENTION: here mout is passed as private_data, instead of codec */
3166 return snd_hda_ctl_add(codec
, mout
->dig_out_nid
, kctl
);
3168 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw
);
3174 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3176 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol
*kcontrol
,
3177 struct snd_ctl_elem_value
*ucontrol
)
3179 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3181 ucontrol
->value
.integer
.value
[0] = codec
->spdif_in_enable
;
3185 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol
*kcontrol
,
3186 struct snd_ctl_elem_value
*ucontrol
)
3188 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3189 hda_nid_t nid
= kcontrol
->private_value
;
3190 unsigned int val
= !!ucontrol
->value
.integer
.value
[0];
3193 mutex_lock(&codec
->spdif_mutex
);
3194 change
= codec
->spdif_in_enable
!= val
;
3196 codec
->spdif_in_enable
= val
;
3197 snd_hda_codec_write_cache(codec
, nid
, 0,
3198 AC_VERB_SET_DIGI_CONVERT_1
, val
);
3200 mutex_unlock(&codec
->spdif_mutex
);
3204 static int snd_hda_spdif_in_status_get(struct snd_kcontrol
*kcontrol
,
3205 struct snd_ctl_elem_value
*ucontrol
)
3207 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3208 hda_nid_t nid
= kcontrol
->private_value
;
3212 val
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_DIGI_CONVERT_1
, 0);
3213 sbits
= convert_to_spdif_status(val
);
3214 ucontrol
->value
.iec958
.status
[0] = sbits
;
3215 ucontrol
->value
.iec958
.status
[1] = sbits
>> 8;
3216 ucontrol
->value
.iec958
.status
[2] = sbits
>> 16;
3217 ucontrol
->value
.iec958
.status
[3] = sbits
>> 24;
3221 static struct snd_kcontrol_new dig_in_ctls
[] = {
3223 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3224 .name
= SNDRV_CTL_NAME_IEC958("", CAPTURE
, SWITCH
),
3225 .info
= snd_hda_spdif_in_switch_info
,
3226 .get
= snd_hda_spdif_in_switch_get
,
3227 .put
= snd_hda_spdif_in_switch_put
,
3230 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
3231 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3232 .name
= SNDRV_CTL_NAME_IEC958("", CAPTURE
, DEFAULT
),
3233 .info
= snd_hda_spdif_mask_info
,
3234 .get
= snd_hda_spdif_in_status_get
,
3240 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3241 * @codec: the HDA codec
3242 * @nid: audio in widget NID
3244 * Creates controls related with the SPDIF input.
3245 * Called from each patch supporting the SPDIF in.
3247 * Returns 0 if successful, or a negative error code.
3249 int snd_hda_create_spdif_in_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
3252 struct snd_kcontrol
*kctl
;
3253 struct snd_kcontrol_new
*dig_mix
;
3256 idx
= find_empty_mixer_ctl_idx(codec
, "IEC958 Capture Switch", 0);
3258 codec_err(codec
, "too many IEC958 inputs\n");
3261 for (dig_mix
= dig_in_ctls
; dig_mix
->name
; dig_mix
++) {
3262 kctl
= snd_ctl_new1(dig_mix
, codec
);
3265 kctl
->private_value
= nid
;
3266 err
= snd_hda_ctl_add(codec
, nid
, kctl
);
3270 codec
->spdif_in_enable
=
3271 snd_hda_codec_read(codec
, nid
, 0,
3272 AC_VERB_GET_DIGI_CONVERT_1
, 0) &
3276 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls
);
3282 /* build a 31bit cache key with the widget id and the command parameter */
3283 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3284 #define get_cmd_cache_nid(key) ((key) & 0xff)
3285 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3288 * snd_hda_codec_write_cache - send a single command with caching
3289 * @codec: the HDA codec
3290 * @nid: NID to send the command
3291 * @flags: optional bit flags
3292 * @verb: the verb to send
3293 * @parm: the parameter for the verb
3295 * Send a single command without waiting for response.
3297 * Returns 0 if successful, or a negative error code.
3299 int snd_hda_codec_write_cache(struct hda_codec
*codec
, hda_nid_t nid
,
3300 int flags
, unsigned int verb
, unsigned int parm
)
3303 struct hda_cache_head
*c
;
3305 unsigned int cache_only
;
3307 cache_only
= codec
->cached_write
;
3309 err
= snd_hda_codec_write(codec
, nid
, flags
, verb
, parm
);
3314 /* parm may contain the verb stuff for get/set amp */
3315 verb
= verb
| (parm
>> 8);
3317 key
= build_cmd_cache_key(nid
, verb
);
3318 mutex_lock(&codec
->bus
->core
.cmd_mutex
);
3319 c
= get_alloc_hash(&codec
->cmd_cache
, key
);
3322 c
->dirty
= cache_only
;
3324 mutex_unlock(&codec
->bus
->core
.cmd_mutex
);
3327 EXPORT_SYMBOL_GPL(snd_hda_codec_write_cache
);
3330 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3331 * @codec: the HDA codec
3332 * @nid: NID to send the command
3333 * @flags: optional bit flags
3334 * @verb: the verb to send
3335 * @parm: the parameter for the verb
3337 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3338 * command if the parameter is already identical with the cached value.
3339 * If not, it sends the command and refreshes the cache.
3341 * Returns 0 if successful, or a negative error code.
3343 int snd_hda_codec_update_cache(struct hda_codec
*codec
, hda_nid_t nid
,
3344 int flags
, unsigned int verb
, unsigned int parm
)
3346 struct hda_cache_head
*c
;
3349 /* parm may contain the verb stuff for get/set amp */
3350 verb
= verb
| (parm
>> 8);
3352 key
= build_cmd_cache_key(nid
, verb
);
3353 mutex_lock(&codec
->bus
->core
.cmd_mutex
);
3354 c
= get_hash(&codec
->cmd_cache
, key
);
3355 if (c
&& c
->val
== parm
) {
3356 mutex_unlock(&codec
->bus
->core
.cmd_mutex
);
3359 mutex_unlock(&codec
->bus
->core
.cmd_mutex
);
3360 return snd_hda_codec_write_cache(codec
, nid
, flags
, verb
, parm
);
3362 EXPORT_SYMBOL_GPL(snd_hda_codec_update_cache
);
3365 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3366 * @codec: HD-audio codec
3368 * Execute all verbs recorded in the command caches to resume.
3370 void snd_hda_codec_resume_cache(struct hda_codec
*codec
)
3374 mutex_lock(&codec
->hash_mutex
);
3375 codec
->cached_write
= 0;
3376 for (i
= 0; i
< codec
->cmd_cache
.buf
.used
; i
++) {
3377 struct hda_cache_head
*buffer
;
3380 buffer
= snd_array_elem(&codec
->cmd_cache
.buf
, i
);
3387 mutex_unlock(&codec
->hash_mutex
);
3388 snd_hda_codec_write(codec
, get_cmd_cache_nid(key
), 0,
3389 get_cmd_cache_cmd(key
), buffer
->val
);
3390 mutex_lock(&codec
->hash_mutex
);
3392 mutex_unlock(&codec
->hash_mutex
);
3394 EXPORT_SYMBOL_GPL(snd_hda_codec_resume_cache
);
3397 * snd_hda_sequence_write_cache - sequence writes with caching
3398 * @codec: the HDA codec
3399 * @seq: VERB array to send
3401 * Send the commands sequentially from the given array.
3402 * Thte commands are recorded on cache for power-save and resume.
3403 * The array must be terminated with NID=0.
3405 void snd_hda_sequence_write_cache(struct hda_codec
*codec
,
3406 const struct hda_verb
*seq
)
3408 for (; seq
->nid
; seq
++)
3409 snd_hda_codec_write_cache(codec
, seq
->nid
, 0, seq
->verb
,
3412 EXPORT_SYMBOL_GPL(snd_hda_sequence_write_cache
);
3415 * snd_hda_codec_flush_cache - Execute all pending (cached) amps / verbs
3416 * @codec: HD-audio codec
3418 void snd_hda_codec_flush_cache(struct hda_codec
*codec
)
3420 snd_hda_codec_resume_amp(codec
);
3421 snd_hda_codec_resume_cache(codec
);
3423 EXPORT_SYMBOL_GPL(snd_hda_codec_flush_cache
);
3426 * snd_hda_codec_set_power_to_all - Set the power state to all widgets
3427 * @codec: the HDA codec
3428 * @fg: function group (not used now)
3429 * @power_state: the power state to set (AC_PWRST_*)
3431 * Set the given power state to all widgets that have the power control.
3432 * If the codec has power_filter set, it evaluates the power state and
3433 * filter out if it's unchanged as D3.
3435 void snd_hda_codec_set_power_to_all(struct hda_codec
*codec
, hda_nid_t fg
,
3436 unsigned int power_state
)
3440 for_each_hda_codec_node(nid
, codec
) {
3441 unsigned int wcaps
= get_wcaps(codec
, nid
);
3442 unsigned int state
= power_state
;
3443 if (!(wcaps
& AC_WCAP_POWER
))
3445 if (codec
->power_filter
) {
3446 state
= codec
->power_filter(codec
, nid
, power_state
);
3447 if (state
!= power_state
&& power_state
== AC_PWRST_D3
)
3450 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_POWER_STATE
,
3454 EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all
);
3457 * wait until the state is reached, returns the current state
3459 static unsigned int hda_sync_power_state(struct hda_codec
*codec
,
3461 unsigned int power_state
)
3463 unsigned long end_time
= jiffies
+ msecs_to_jiffies(500);
3464 unsigned int state
, actual_state
;
3467 state
= snd_hda_codec_read(codec
, fg
, 0,
3468 AC_VERB_GET_POWER_STATE
, 0);
3469 if (state
& AC_PWRST_ERROR
)
3471 actual_state
= (state
>> 4) & 0x0f;
3472 if (actual_state
== power_state
)
3474 if (time_after_eq(jiffies
, end_time
))
3476 /* wait until the codec reachs to the target state */
3483 * snd_hda_codec_eapd_power_filter - A power filter callback for EAPD
3484 * @codec: the HDA codec
3486 * @power_state: power state to evalue
3488 * Don't power down the widget if it controls eapd and EAPD_BTLENABLE is set.
3489 * This can be used a codec power_filter callback.
3491 unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec
*codec
,
3493 unsigned int power_state
)
3495 if (nid
== codec
->core
.afg
|| nid
== codec
->core
.mfg
)
3497 if (power_state
== AC_PWRST_D3
&&
3498 get_wcaps_type(get_wcaps(codec
, nid
)) == AC_WID_PIN
&&
3499 (snd_hda_query_pin_caps(codec
, nid
) & AC_PINCAP_EAPD
)) {
3500 int eapd
= snd_hda_codec_read(codec
, nid
, 0,
3501 AC_VERB_GET_EAPD_BTLENABLE
, 0);
3507 EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter
);
3510 * set power state of the codec, and return the power state
3512 static unsigned int hda_set_power_state(struct hda_codec
*codec
,
3513 unsigned int power_state
)
3515 hda_nid_t fg
= codec
->core
.afg
? codec
->core
.afg
: codec
->core
.mfg
;
3520 /* this delay seems necessary to avoid click noise at power-down */
3521 if (power_state
== AC_PWRST_D3
) {
3522 if (codec
->depop_delay
< 0)
3523 msleep(codec_has_epss(codec
) ? 10 : 100);
3524 else if (codec
->depop_delay
> 0)
3525 msleep(codec
->depop_delay
);
3526 flags
= HDA_RW_NO_RESPONSE_FALLBACK
;
3529 /* repeat power states setting at most 10 times*/
3530 for (count
= 0; count
< 10; count
++) {
3531 if (codec
->patch_ops
.set_power_state
)
3532 codec
->patch_ops
.set_power_state(codec
, fg
,
3535 state
= power_state
;
3536 if (codec
->power_filter
)
3537 state
= codec
->power_filter(codec
, fg
, state
);
3538 if (state
== power_state
|| power_state
!= AC_PWRST_D3
)
3539 snd_hda_codec_read(codec
, fg
, flags
,
3540 AC_VERB_SET_POWER_STATE
,
3542 snd_hda_codec_set_power_to_all(codec
, fg
, power_state
);
3544 state
= hda_sync_power_state(codec
, fg
, power_state
);
3545 if (!(state
& AC_PWRST_ERROR
))
3552 /* sync power states of all widgets;
3553 * this is called at the end of codec parsing
3555 static void sync_power_up_states(struct hda_codec
*codec
)
3559 /* don't care if no filter is used */
3560 if (!codec
->power_filter
)
3563 for_each_hda_codec_node(nid
, codec
) {
3564 unsigned int wcaps
= get_wcaps(codec
, nid
);
3565 unsigned int target
;
3566 if (!(wcaps
& AC_WCAP_POWER
))
3568 target
= codec
->power_filter(codec
, nid
, AC_PWRST_D0
);
3569 if (target
== AC_PWRST_D0
)
3571 if (!snd_hda_check_power_state(codec
, nid
, target
))
3572 snd_hda_codec_write(codec
, nid
, 0,
3573 AC_VERB_SET_POWER_STATE
, target
);
3577 #ifdef CONFIG_SND_HDA_RECONFIG
3578 /* execute additional init verbs */
3579 static void hda_exec_init_verbs(struct hda_codec
*codec
)
3581 if (codec
->init_verbs
.list
)
3582 snd_hda_sequence_write(codec
, codec
->init_verbs
.list
);
3585 static inline void hda_exec_init_verbs(struct hda_codec
*codec
) {}
3589 /* update the power on/off account with the current jiffies */
3590 static void update_power_acct(struct hda_codec
*codec
, bool on
)
3592 unsigned long delta
= jiffies
- codec
->power_jiffies
;
3595 codec
->power_on_acct
+= delta
;
3597 codec
->power_off_acct
+= delta
;
3598 codec
->power_jiffies
+= delta
;
3601 void snd_hda_update_power_acct(struct hda_codec
*codec
)
3603 update_power_acct(codec
, hda_codec_is_power_on(codec
));
3607 * call suspend and power-down; used both from PM and power-save
3608 * this function returns the power state in the end
3610 static unsigned int hda_call_codec_suspend(struct hda_codec
*codec
)
3614 atomic_inc(&codec
->core
.in_pm
);
3616 if (codec
->patch_ops
.suspend
)
3617 codec
->patch_ops
.suspend(codec
);
3618 hda_cleanup_all_streams(codec
);
3619 state
= hda_set_power_state(codec
, AC_PWRST_D3
);
3620 update_power_acct(codec
, true);
3621 atomic_dec(&codec
->core
.in_pm
);
3625 /* mark all entries of cmd and amp caches dirty */
3626 static void hda_mark_cmd_cache_dirty(struct hda_codec
*codec
)
3629 for (i
= 0; i
< codec
->cmd_cache
.buf
.used
; i
++) {
3630 struct hda_cache_head
*cmd
;
3631 cmd
= snd_array_elem(&codec
->cmd_cache
.buf
, i
);
3634 for (i
= 0; i
< codec
->amp_cache
.buf
.used
; i
++) {
3635 struct hda_amp_info
*amp
;
3636 amp
= snd_array_elem(&codec
->amp_cache
.buf
, i
);
3637 amp
->head
.dirty
= 1;
3642 * kick up codec; used both from PM and power-save
3644 static void hda_call_codec_resume(struct hda_codec
*codec
)
3646 atomic_inc(&codec
->core
.in_pm
);
3648 hda_mark_cmd_cache_dirty(codec
);
3650 codec
->power_jiffies
= jiffies
;
3652 hda_set_power_state(codec
, AC_PWRST_D0
);
3653 restore_shutup_pins(codec
);
3654 hda_exec_init_verbs(codec
);
3655 snd_hda_jack_set_dirty_all(codec
);
3656 if (codec
->patch_ops
.resume
)
3657 codec
->patch_ops
.resume(codec
);
3659 if (codec
->patch_ops
.init
)
3660 codec
->patch_ops
.init(codec
);
3661 snd_hda_codec_resume_amp(codec
);
3662 snd_hda_codec_resume_cache(codec
);
3665 if (codec
->jackpoll_interval
)
3666 hda_jackpoll_work(&codec
->jackpoll_work
.work
);
3668 snd_hda_jack_report_sync(codec
);
3669 atomic_dec(&codec
->core
.in_pm
);
3672 static int hda_codec_runtime_suspend(struct device
*dev
)
3674 struct hda_codec
*codec
= dev_to_hda_codec(dev
);
3675 struct hda_pcm
*pcm
;
3678 cancel_delayed_work_sync(&codec
->jackpoll_work
);
3679 list_for_each_entry(pcm
, &codec
->pcm_list_head
, list
)
3680 snd_pcm_suspend_all(pcm
->pcm
);
3681 state
= hda_call_codec_suspend(codec
);
3682 if (codec_has_clkstop(codec
) && codec_has_epss(codec
) &&
3683 (state
& AC_PWRST_CLK_STOP_OK
))
3684 snd_hdac_codec_link_down(&codec
->core
);
3688 static int hda_codec_runtime_resume(struct device
*dev
)
3690 struct hda_codec
*codec
= dev_to_hda_codec(dev
);
3692 snd_hdac_codec_link_up(&codec
->core
);
3693 hda_call_codec_resume(codec
);
3694 pm_runtime_mark_last_busy(dev
);
3697 #endif /* CONFIG_PM */
3699 /* referred in hda_bind.c */
3700 const struct dev_pm_ops hda_codec_driver_pm
= {
3701 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend
,
3702 pm_runtime_force_resume
)
3703 SET_RUNTIME_PM_OPS(hda_codec_runtime_suspend
, hda_codec_runtime_resume
,
3708 * add standard channel maps if not specified
3710 static int add_std_chmaps(struct hda_codec
*codec
)
3712 struct hda_pcm
*pcm
;
3715 list_for_each_entry(pcm
, &codec
->pcm_list_head
, list
) {
3716 for (str
= 0; str
< 2; str
++) {
3717 struct hda_pcm_stream
*hinfo
= &pcm
->stream
[str
];
3718 struct snd_pcm_chmap
*chmap
;
3719 const struct snd_pcm_chmap_elem
*elem
;
3723 if (!pcm
|| !hinfo
->substreams
)
3725 elem
= hinfo
->chmap
? hinfo
->chmap
: snd_pcm_std_chmaps
;
3726 err
= snd_pcm_add_chmap_ctls(pcm
->pcm
, str
, elem
,
3727 hinfo
->channels_max
,
3731 chmap
->channel_mask
= SND_PCM_CHMAP_MASK_2468
;
3737 /* default channel maps for 2.1 speakers;
3738 * since HD-audio supports only stereo, odd number channels are omitted
3740 const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps
[] = {
3742 .map
= { SNDRV_CHMAP_FL
, SNDRV_CHMAP_FR
} },
3744 .map
= { SNDRV_CHMAP_FL
, SNDRV_CHMAP_FR
,
3745 SNDRV_CHMAP_LFE
, SNDRV_CHMAP_LFE
} },
3748 EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps
);
3750 int snd_hda_codec_build_controls(struct hda_codec
*codec
)
3753 hda_exec_init_verbs(codec
);
3754 /* continue to initialize... */
3755 if (codec
->patch_ops
.init
)
3756 err
= codec
->patch_ops
.init(codec
);
3757 if (!err
&& codec
->patch_ops
.build_controls
)
3758 err
= codec
->patch_ops
.build_controls(codec
);
3762 /* we create chmaps here instead of build_pcms */
3763 err
= add_std_chmaps(codec
);
3767 if (codec
->jackpoll_interval
)
3768 hda_jackpoll_work(&codec
->jackpoll_work
.work
);
3770 snd_hda_jack_report_sync(codec
); /* call at the last init point */
3771 sync_power_up_states(codec
);
3778 struct hda_rate_tbl
{
3780 unsigned int alsa_bits
;
3781 unsigned int hda_fmt
;
3784 /* rate = base * mult / div */
3785 #define HDA_RATE(base, mult, div) \
3786 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3787 (((div) - 1) << AC_FMT_DIV_SHIFT))
3789 static struct hda_rate_tbl rate_bits
[] = {
3790 /* rate in Hz, ALSA rate bitmask, HDA format value */
3792 /* autodetected value used in snd_hda_query_supported_pcm */
3793 { 8000, SNDRV_PCM_RATE_8000
, HDA_RATE(48, 1, 6) },
3794 { 11025, SNDRV_PCM_RATE_11025
, HDA_RATE(44, 1, 4) },
3795 { 16000, SNDRV_PCM_RATE_16000
, HDA_RATE(48, 1, 3) },
3796 { 22050, SNDRV_PCM_RATE_22050
, HDA_RATE(44, 1, 2) },
3797 { 32000, SNDRV_PCM_RATE_32000
, HDA_RATE(48, 2, 3) },
3798 { 44100, SNDRV_PCM_RATE_44100
, HDA_RATE(44, 1, 1) },
3799 { 48000, SNDRV_PCM_RATE_48000
, HDA_RATE(48, 1, 1) },
3800 { 88200, SNDRV_PCM_RATE_88200
, HDA_RATE(44, 2, 1) },
3801 { 96000, SNDRV_PCM_RATE_96000
, HDA_RATE(48, 2, 1) },
3802 { 176400, SNDRV_PCM_RATE_176400
, HDA_RATE(44, 4, 1) },
3803 { 192000, SNDRV_PCM_RATE_192000
, HDA_RATE(48, 4, 1) },
3804 #define AC_PAR_PCM_RATE_BITS 11
3805 /* up to bits 10, 384kHZ isn't supported properly */
3807 /* not autodetected value */
3808 { 9600, SNDRV_PCM_RATE_KNOT
, HDA_RATE(48, 1, 5) },
3810 { 0 } /* terminator */
3814 * snd_hda_calc_stream_format - calculate format bitset
3815 * @codec: HD-audio codec
3816 * @rate: the sample rate
3817 * @channels: the number of channels
3818 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3819 * @maxbps: the max. bps
3820 * @spdif_ctls: HD-audio SPDIF status bits (0 if irrelevant)
3822 * Calculate the format bitset from the given rate, channels and th PCM format.
3824 * Return zero if invalid.
3826 unsigned int snd_hda_calc_stream_format(struct hda_codec
*codec
,
3828 unsigned int channels
,
3829 unsigned int format
,
3830 unsigned int maxbps
,
3831 unsigned short spdif_ctls
)
3834 unsigned int val
= 0;
3836 for (i
= 0; rate_bits
[i
].hz
; i
++)
3837 if (rate_bits
[i
].hz
== rate
) {
3838 val
= rate_bits
[i
].hda_fmt
;
3841 if (!rate_bits
[i
].hz
) {
3842 codec_dbg(codec
, "invalid rate %d\n", rate
);
3846 if (channels
== 0 || channels
> 8) {
3847 codec_dbg(codec
, "invalid channels %d\n", channels
);
3850 val
|= channels
- 1;
3852 switch (snd_pcm_format_width(format
)) {
3854 val
|= AC_FMT_BITS_8
;
3857 val
|= AC_FMT_BITS_16
;
3862 if (maxbps
>= 32 || format
== SNDRV_PCM_FORMAT_FLOAT_LE
)
3863 val
|= AC_FMT_BITS_32
;
3864 else if (maxbps
>= 24)
3865 val
|= AC_FMT_BITS_24
;
3867 val
|= AC_FMT_BITS_20
;
3870 codec_dbg(codec
, "invalid format width %d\n",
3871 snd_pcm_format_width(format
));
3875 if (spdif_ctls
& AC_DIG1_NONAUDIO
)
3876 val
|= AC_FMT_TYPE_NON_PCM
;
3880 EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format
);
3882 static unsigned int get_pcm_param(struct hda_codec
*codec
, hda_nid_t nid
,
3885 unsigned int val
= 0;
3886 if (nid
!= codec
->core
.afg
&&
3887 (get_wcaps(codec
, nid
) & AC_WCAP_FORMAT_OVRD
))
3888 val
= snd_hda_param_read(codec
, nid
, AC_PAR_PCM
);
3889 if (!val
|| val
== -1)
3890 val
= snd_hda_param_read(codec
, codec
->core
.afg
, AC_PAR_PCM
);
3891 if (!val
|| val
== -1)
3896 static unsigned int query_pcm_param(struct hda_codec
*codec
, hda_nid_t nid
)
3898 return query_caps_hash(codec
, nid
, 0, HDA_HASH_PARPCM_KEY(nid
),
3902 static unsigned int get_stream_param(struct hda_codec
*codec
, hda_nid_t nid
,
3905 unsigned int streams
= snd_hda_param_read(codec
, nid
, AC_PAR_STREAM
);
3906 if (!streams
|| streams
== -1)
3907 streams
= snd_hda_param_read(codec
, codec
->core
.afg
, AC_PAR_STREAM
);
3908 if (!streams
|| streams
== -1)
3913 static unsigned int query_stream_param(struct hda_codec
*codec
, hda_nid_t nid
)
3915 return query_caps_hash(codec
, nid
, 0, HDA_HASH_PARSTR_KEY(nid
),
3920 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3921 * @codec: the HDA codec
3922 * @nid: NID to query
3923 * @ratesp: the pointer to store the detected rate bitflags
3924 * @formatsp: the pointer to store the detected formats
3925 * @bpsp: the pointer to store the detected format widths
3927 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3928 * or @bsps argument is ignored.
3930 * Returns 0 if successful, otherwise a negative error code.
3932 int snd_hda_query_supported_pcm(struct hda_codec
*codec
, hda_nid_t nid
,
3933 u32
*ratesp
, u64
*formatsp
, unsigned int *bpsp
)
3935 unsigned int i
, val
, wcaps
;
3937 wcaps
= get_wcaps(codec
, nid
);
3938 val
= query_pcm_param(codec
, nid
);
3942 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++) {
3944 rates
|= rate_bits
[i
].alsa_bits
;
3948 "rates == 0 (nid=0x%x, val=0x%x, ovrd=%i)\n",
3950 (wcaps
& AC_WCAP_FORMAT_OVRD
) ? 1 : 0);
3956 if (formatsp
|| bpsp
) {
3958 unsigned int streams
, bps
;
3960 streams
= query_stream_param(codec
, nid
);
3965 if (streams
& AC_SUPFMT_PCM
) {
3966 if (val
& AC_SUPPCM_BITS_8
) {
3967 formats
|= SNDRV_PCM_FMTBIT_U8
;
3970 if (val
& AC_SUPPCM_BITS_16
) {
3971 formats
|= SNDRV_PCM_FMTBIT_S16_LE
;
3974 if (wcaps
& AC_WCAP_DIGITAL
) {
3975 if (val
& AC_SUPPCM_BITS_32
)
3976 formats
|= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
;
3977 if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
))
3978 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
3979 if (val
& AC_SUPPCM_BITS_24
)
3981 else if (val
& AC_SUPPCM_BITS_20
)
3983 } else if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
|
3984 AC_SUPPCM_BITS_32
)) {
3985 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
3986 if (val
& AC_SUPPCM_BITS_32
)
3988 else if (val
& AC_SUPPCM_BITS_24
)
3990 else if (val
& AC_SUPPCM_BITS_20
)
3994 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
3995 if (streams
& AC_SUPFMT_FLOAT32
) {
3996 formats
|= SNDRV_PCM_FMTBIT_FLOAT_LE
;
4001 if (streams
== AC_SUPFMT_AC3
) {
4002 /* should be exclusive */
4003 /* temporary hack: we have still no proper support
4004 * for the direct AC3 stream...
4006 formats
|= SNDRV_PCM_FMTBIT_U8
;
4011 "formats == 0 (nid=0x%x, val=0x%x, ovrd=%i, streams=0x%x)\n",
4013 (wcaps
& AC_WCAP_FORMAT_OVRD
) ? 1 : 0,
4018 *formatsp
= formats
;
4025 EXPORT_SYMBOL_GPL(snd_hda_query_supported_pcm
);
4028 * snd_hda_is_supported_format - Check the validity of the format
4029 * @codec: HD-audio codec
4030 * @nid: NID to check
4031 * @format: the HD-audio format value to check
4033 * Check whether the given node supports the format value.
4035 * Returns 1 if supported, 0 if not.
4037 int snd_hda_is_supported_format(struct hda_codec
*codec
, hda_nid_t nid
,
4038 unsigned int format
)
4041 unsigned int val
= 0, rate
, stream
;
4043 val
= query_pcm_param(codec
, nid
);
4047 rate
= format
& 0xff00;
4048 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++)
4049 if (rate_bits
[i
].hda_fmt
== rate
) {
4054 if (i
>= AC_PAR_PCM_RATE_BITS
)
4057 stream
= query_stream_param(codec
, nid
);
4061 if (stream
& AC_SUPFMT_PCM
) {
4062 switch (format
& 0xf0) {
4064 if (!(val
& AC_SUPPCM_BITS_8
))
4068 if (!(val
& AC_SUPPCM_BITS_16
))
4072 if (!(val
& AC_SUPPCM_BITS_20
))
4076 if (!(val
& AC_SUPPCM_BITS_24
))
4080 if (!(val
& AC_SUPPCM_BITS_32
))
4087 /* FIXME: check for float32 and AC3? */
4092 EXPORT_SYMBOL_GPL(snd_hda_is_supported_format
);
4097 static int hda_pcm_default_open_close(struct hda_pcm_stream
*hinfo
,
4098 struct hda_codec
*codec
,
4099 struct snd_pcm_substream
*substream
)
4104 static int hda_pcm_default_prepare(struct hda_pcm_stream
*hinfo
,
4105 struct hda_codec
*codec
,
4106 unsigned int stream_tag
,
4107 unsigned int format
,
4108 struct snd_pcm_substream
*substream
)
4110 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, stream_tag
, 0, format
);
4114 static int hda_pcm_default_cleanup(struct hda_pcm_stream
*hinfo
,
4115 struct hda_codec
*codec
,
4116 struct snd_pcm_substream
*substream
)
4118 snd_hda_codec_cleanup_stream(codec
, hinfo
->nid
);
4122 static int set_pcm_default_values(struct hda_codec
*codec
,
4123 struct hda_pcm_stream
*info
)
4127 /* query support PCM information from the given NID */
4128 if (info
->nid
&& (!info
->rates
|| !info
->formats
)) {
4129 err
= snd_hda_query_supported_pcm(codec
, info
->nid
,
4130 info
->rates
? NULL
: &info
->rates
,
4131 info
->formats
? NULL
: &info
->formats
,
4132 info
->maxbps
? NULL
: &info
->maxbps
);
4136 if (info
->ops
.open
== NULL
)
4137 info
->ops
.open
= hda_pcm_default_open_close
;
4138 if (info
->ops
.close
== NULL
)
4139 info
->ops
.close
= hda_pcm_default_open_close
;
4140 if (info
->ops
.prepare
== NULL
) {
4141 if (snd_BUG_ON(!info
->nid
))
4143 info
->ops
.prepare
= hda_pcm_default_prepare
;
4145 if (info
->ops
.cleanup
== NULL
) {
4146 if (snd_BUG_ON(!info
->nid
))
4148 info
->ops
.cleanup
= hda_pcm_default_cleanup
;
4154 * codec prepare/cleanup entries
4157 * snd_hda_codec_prepare - Prepare a stream
4158 * @codec: the HDA codec
4159 * @hinfo: PCM information
4160 * @stream: stream tag to assign
4161 * @format: format id to assign
4162 * @substream: PCM substream to assign
4164 * Calls the prepare callback set by the codec with the given arguments.
4165 * Clean up the inactive streams when successful.
4167 int snd_hda_codec_prepare(struct hda_codec
*codec
,
4168 struct hda_pcm_stream
*hinfo
,
4169 unsigned int stream
,
4170 unsigned int format
,
4171 struct snd_pcm_substream
*substream
)
4174 mutex_lock(&codec
->bus
->prepare_mutex
);
4175 if (hinfo
->ops
.prepare
)
4176 ret
= hinfo
->ops
.prepare(hinfo
, codec
, stream
, format
,
4181 purify_inactive_streams(codec
);
4182 mutex_unlock(&codec
->bus
->prepare_mutex
);
4185 EXPORT_SYMBOL_GPL(snd_hda_codec_prepare
);
4188 * snd_hda_codec_cleanup - Prepare a stream
4189 * @codec: the HDA codec
4190 * @hinfo: PCM information
4191 * @substream: PCM substream
4193 * Calls the cleanup callback set by the codec with the given arguments.
4195 void snd_hda_codec_cleanup(struct hda_codec
*codec
,
4196 struct hda_pcm_stream
*hinfo
,
4197 struct snd_pcm_substream
*substream
)
4199 mutex_lock(&codec
->bus
->prepare_mutex
);
4200 if (hinfo
->ops
.cleanup
)
4201 hinfo
->ops
.cleanup(hinfo
, codec
, substream
);
4202 mutex_unlock(&codec
->bus
->prepare_mutex
);
4204 EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup
);
4207 const char *snd_hda_pcm_type_name
[HDA_PCM_NTYPES
] = {
4208 "Audio", "SPDIF", "HDMI", "Modem"
4212 * get the empty PCM device number to assign
4214 static int get_empty_pcm_device(struct hda_bus
*bus
, unsigned int type
)
4216 /* audio device indices; not linear to keep compatibility */
4217 /* assigned to static slots up to dev#10; if more needed, assign
4218 * the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y)
4220 static int audio_idx
[HDA_PCM_NTYPES
][5] = {
4221 [HDA_PCM_TYPE_AUDIO
] = { 0, 2, 4, 5, -1 },
4222 [HDA_PCM_TYPE_SPDIF
] = { 1, -1 },
4223 [HDA_PCM_TYPE_HDMI
] = { 3, 7, 8, 9, -1 },
4224 [HDA_PCM_TYPE_MODEM
] = { 6, -1 },
4228 if (type
>= HDA_PCM_NTYPES
) {
4229 dev_err(bus
->card
->dev
, "Invalid PCM type %d\n", type
);
4233 for (i
= 0; audio_idx
[type
][i
] >= 0; i
++) {
4234 #ifndef CONFIG_SND_DYNAMIC_MINORS
4235 if (audio_idx
[type
][i
] >= 8)
4238 if (!test_and_set_bit(audio_idx
[type
][i
], bus
->pcm_dev_bits
))
4239 return audio_idx
[type
][i
];
4242 #ifdef CONFIG_SND_DYNAMIC_MINORS
4243 /* non-fixed slots starting from 10 */
4244 for (i
= 10; i
< 32; i
++) {
4245 if (!test_and_set_bit(i
, bus
->pcm_dev_bits
))
4250 dev_warn(bus
->card
->dev
, "Too many %s devices\n",
4251 snd_hda_pcm_type_name
[type
]);
4252 #ifndef CONFIG_SND_DYNAMIC_MINORS
4253 dev_warn(bus
->card
->dev
,
4254 "Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n");
4259 /* call build_pcms ops of the given codec and set up the default parameters */
4260 int snd_hda_codec_parse_pcms(struct hda_codec
*codec
)
4262 struct hda_pcm
*cpcm
;
4265 if (!list_empty(&codec
->pcm_list_head
))
4266 return 0; /* already parsed */
4268 if (!codec
->patch_ops
.build_pcms
)
4271 err
= codec
->patch_ops
.build_pcms(codec
);
4273 codec_err(codec
, "cannot build PCMs for #%d (error %d)\n",
4274 codec
->core
.addr
, err
);
4278 list_for_each_entry(cpcm
, &codec
->pcm_list_head
, list
) {
4281 for (stream
= 0; stream
< 2; stream
++) {
4282 struct hda_pcm_stream
*info
= &cpcm
->stream
[stream
];
4284 if (!info
->substreams
)
4286 err
= set_pcm_default_values(codec
, info
);
4289 "fail to setup default for PCM %s\n",
4299 /* assign all PCMs of the given codec */
4300 int snd_hda_codec_build_pcms(struct hda_codec
*codec
)
4302 struct hda_bus
*bus
= codec
->bus
;
4303 struct hda_pcm
*cpcm
;
4306 if (snd_BUG_ON(!bus
->ops
.attach_pcm
))
4309 err
= snd_hda_codec_parse_pcms(codec
);
4311 snd_hda_codec_reset(codec
);
4315 /* attach a new PCM streams */
4316 list_for_each_entry(cpcm
, &codec
->pcm_list_head
, list
) {
4318 continue; /* already attached */
4319 if (!cpcm
->stream
[0].substreams
&& !cpcm
->stream
[1].substreams
)
4320 continue; /* no substreams assigned */
4322 dev
= get_empty_pcm_device(bus
, cpcm
->pcm_type
);
4324 continue; /* no fatal error */
4326 err
= bus
->ops
.attach_pcm(bus
, codec
, cpcm
);
4329 "cannot attach PCM stream %d for codec #%d\n",
4330 dev
, codec
->core
.addr
);
4331 continue; /* no fatal error */
4339 * snd_hda_add_new_ctls - create controls from the array
4340 * @codec: the HDA codec
4341 * @knew: the array of struct snd_kcontrol_new
4343 * This helper function creates and add new controls in the given array.
4344 * The array must be terminated with an empty entry as terminator.
4346 * Returns 0 if successful, or a negative error code.
4348 int snd_hda_add_new_ctls(struct hda_codec
*codec
,
4349 const struct snd_kcontrol_new
*knew
)
4353 for (; knew
->name
; knew
++) {
4354 struct snd_kcontrol
*kctl
;
4355 int addr
= 0, idx
= 0;
4356 if (knew
->iface
== -1) /* skip this codec private value */
4359 kctl
= snd_ctl_new1(knew
, codec
);
4363 kctl
->id
.device
= addr
;
4365 kctl
->id
.index
= idx
;
4366 err
= snd_hda_ctl_add(codec
, 0, kctl
);
4369 /* try first with another device index corresponding to
4370 * the codec addr; if it still fails (or it's the
4371 * primary codec), then try another control index
4373 if (!addr
&& codec
->core
.addr
)
4374 addr
= codec
->core
.addr
;
4375 else if (!idx
&& !knew
->index
) {
4376 idx
= find_empty_mixer_ctl_idx(codec
,
4386 EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls
);
4389 static void codec_set_power_save(struct hda_codec
*codec
, int delay
)
4391 struct device
*dev
= hda_codec_dev(codec
);
4394 pm_runtime_set_autosuspend_delay(dev
, delay
);
4395 pm_runtime_use_autosuspend(dev
);
4396 pm_runtime_allow(dev
);
4397 if (!pm_runtime_suspended(dev
))
4398 pm_runtime_mark_last_busy(dev
);
4400 pm_runtime_dont_use_autosuspend(dev
);
4401 pm_runtime_forbid(dev
);
4406 * snd_hda_set_power_save - reprogram autosuspend for the given delay
4407 * @bus: HD-audio bus
4408 * @delay: autosuspend delay in msec, 0 = off
4410 * Synchronize the runtime PM autosuspend state from the power_save option.
4412 void snd_hda_set_power_save(struct hda_bus
*bus
, int delay
)
4414 struct hda_codec
*c
;
4416 list_for_each_codec(c
, bus
)
4417 codec_set_power_save(c
, delay
);
4419 EXPORT_SYMBOL_GPL(snd_hda_set_power_save
);
4422 * snd_hda_check_amp_list_power - Check the amp list and update the power
4423 * @codec: HD-audio codec
4424 * @check: the object containing an AMP list and the status
4425 * @nid: NID to check / update
4427 * Check whether the given NID is in the amp list. If it's in the list,
4428 * check the current AMP status, and update the the power-status according
4429 * to the mute status.
4431 * This function is supposed to be set or called from the check_power_status
4434 int snd_hda_check_amp_list_power(struct hda_codec
*codec
,
4435 struct hda_loopback_check
*check
,
4438 const struct hda_amp_list
*p
;
4441 if (!check
->amplist
)
4443 for (p
= check
->amplist
; p
->nid
; p
++) {
4448 return 0; /* nothing changed */
4450 for (p
= check
->amplist
; p
->nid
; p
++) {
4451 for (ch
= 0; ch
< 2; ch
++) {
4452 v
= snd_hda_codec_amp_read(codec
, p
->nid
, ch
, p
->dir
,
4454 if (!(v
& HDA_AMP_MUTE
) && v
> 0) {
4455 if (!check
->power_on
) {
4456 check
->power_on
= 1;
4457 snd_hda_power_up(codec
);
4463 if (check
->power_on
) {
4464 check
->power_on
= 0;
4465 snd_hda_power_down(codec
);
4469 EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power
);
4477 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4478 * @imux: imux helper object
4479 * @uinfo: pointer to get/store the data
4481 int snd_hda_input_mux_info(const struct hda_input_mux
*imux
,
4482 struct snd_ctl_elem_info
*uinfo
)
4486 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
4488 uinfo
->value
.enumerated
.items
= imux
->num_items
;
4489 if (!imux
->num_items
)
4491 index
= uinfo
->value
.enumerated
.item
;
4492 if (index
>= imux
->num_items
)
4493 index
= imux
->num_items
- 1;
4494 strcpy(uinfo
->value
.enumerated
.name
, imux
->items
[index
].label
);
4497 EXPORT_SYMBOL_GPL(snd_hda_input_mux_info
);
4500 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4501 * @codec: the HDA codec
4502 * @imux: imux helper object
4503 * @ucontrol: pointer to get/store the data
4504 * @nid: input mux NID
4505 * @cur_val: pointer to get/store the current imux value
4507 int snd_hda_input_mux_put(struct hda_codec
*codec
,
4508 const struct hda_input_mux
*imux
,
4509 struct snd_ctl_elem_value
*ucontrol
,
4511 unsigned int *cur_val
)
4515 if (!imux
->num_items
)
4517 idx
= ucontrol
->value
.enumerated
.item
[0];
4518 if (idx
>= imux
->num_items
)
4519 idx
= imux
->num_items
- 1;
4520 if (*cur_val
== idx
)
4522 snd_hda_codec_write_cache(codec
, nid
, 0, AC_VERB_SET_CONNECT_SEL
,
4523 imux
->items
[idx
].index
);
4527 EXPORT_SYMBOL_GPL(snd_hda_input_mux_put
);
4531 * snd_hda_enum_helper_info - Helper for simple enum ctls
4532 * @kcontrol: ctl element
4533 * @uinfo: pointer to get/store the data
4534 * @num_items: number of enum items
4535 * @texts: enum item string array
4537 * process kcontrol info callback of a simple string enum array
4538 * when @num_items is 0 or @texts is NULL, assume a boolean enum array
4540 int snd_hda_enum_helper_info(struct snd_kcontrol
*kcontrol
,
4541 struct snd_ctl_elem_info
*uinfo
,
4542 int num_items
, const char * const *texts
)
4544 static const char * const texts_default
[] = {
4545 "Disabled", "Enabled"
4548 if (!texts
|| !num_items
) {
4550 texts
= texts_default
;
4553 return snd_ctl_enum_info(uinfo
, 1, num_items
, texts
);
4555 EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info
);
4558 * Multi-channel / digital-out PCM helper functions
4561 /* setup SPDIF output stream */
4562 static void setup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
,
4563 unsigned int stream_tag
, unsigned int format
)
4565 struct hda_spdif_out
*spdif
;
4566 unsigned int curr_fmt
;
4569 spdif
= snd_hda_spdif_out_of_nid(codec
, nid
);
4570 curr_fmt
= snd_hda_codec_read(codec
, nid
, 0,
4571 AC_VERB_GET_STREAM_FORMAT
, 0);
4572 reset
= codec
->spdif_status_reset
&&
4573 (spdif
->ctls
& AC_DIG1_ENABLE
) &&
4576 /* turn off SPDIF if needed; otherwise the IEC958 bits won't be
4579 set_dig_out_convert(codec
, nid
,
4580 spdif
->ctls
& ~AC_DIG1_ENABLE
& 0xff,
4582 snd_hda_codec_setup_stream(codec
, nid
, stream_tag
, 0, format
);
4583 if (codec
->slave_dig_outs
) {
4585 for (d
= codec
->slave_dig_outs
; *d
; d
++)
4586 snd_hda_codec_setup_stream(codec
, *d
, stream_tag
, 0,
4589 /* turn on again (if needed) */
4591 set_dig_out_convert(codec
, nid
,
4592 spdif
->ctls
& 0xff, -1);
4595 static void cleanup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
)
4597 snd_hda_codec_cleanup_stream(codec
, nid
);
4598 if (codec
->slave_dig_outs
) {
4600 for (d
= codec
->slave_dig_outs
; *d
; d
++)
4601 snd_hda_codec_cleanup_stream(codec
, *d
);
4606 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4607 * @codec: the HDA codec
4608 * @mout: hda_multi_out object
4610 int snd_hda_multi_out_dig_open(struct hda_codec
*codec
,
4611 struct hda_multi_out
*mout
)
4613 mutex_lock(&codec
->spdif_mutex
);
4614 if (mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
)
4615 /* already opened as analog dup; reset it once */
4616 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4617 mout
->dig_out_used
= HDA_DIG_EXCLUSIVE
;
4618 mutex_unlock(&codec
->spdif_mutex
);
4621 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open
);
4624 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4625 * @codec: the HDA codec
4626 * @mout: hda_multi_out object
4627 * @stream_tag: stream tag to assign
4628 * @format: format id to assign
4629 * @substream: PCM substream to assign
4631 int snd_hda_multi_out_dig_prepare(struct hda_codec
*codec
,
4632 struct hda_multi_out
*mout
,
4633 unsigned int stream_tag
,
4634 unsigned int format
,
4635 struct snd_pcm_substream
*substream
)
4637 mutex_lock(&codec
->spdif_mutex
);
4638 setup_dig_out_stream(codec
, mout
->dig_out_nid
, stream_tag
, format
);
4639 mutex_unlock(&codec
->spdif_mutex
);
4642 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare
);
4645 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4646 * @codec: the HDA codec
4647 * @mout: hda_multi_out object
4649 int snd_hda_multi_out_dig_cleanup(struct hda_codec
*codec
,
4650 struct hda_multi_out
*mout
)
4652 mutex_lock(&codec
->spdif_mutex
);
4653 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4654 mutex_unlock(&codec
->spdif_mutex
);
4657 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup
);
4660 * snd_hda_multi_out_dig_close - release the digital out stream
4661 * @codec: the HDA codec
4662 * @mout: hda_multi_out object
4664 int snd_hda_multi_out_dig_close(struct hda_codec
*codec
,
4665 struct hda_multi_out
*mout
)
4667 mutex_lock(&codec
->spdif_mutex
);
4668 mout
->dig_out_used
= 0;
4669 mutex_unlock(&codec
->spdif_mutex
);
4672 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close
);
4675 * snd_hda_multi_out_analog_open - open analog outputs
4676 * @codec: the HDA codec
4677 * @mout: hda_multi_out object
4678 * @substream: PCM substream to assign
4679 * @hinfo: PCM information to assign
4681 * Open analog outputs and set up the hw-constraints.
4682 * If the digital outputs can be opened as slave, open the digital
4685 int snd_hda_multi_out_analog_open(struct hda_codec
*codec
,
4686 struct hda_multi_out
*mout
,
4687 struct snd_pcm_substream
*substream
,
4688 struct hda_pcm_stream
*hinfo
)
4690 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
4691 runtime
->hw
.channels_max
= mout
->max_channels
;
4692 if (mout
->dig_out_nid
) {
4693 if (!mout
->analog_rates
) {
4694 mout
->analog_rates
= hinfo
->rates
;
4695 mout
->analog_formats
= hinfo
->formats
;
4696 mout
->analog_maxbps
= hinfo
->maxbps
;
4698 runtime
->hw
.rates
= mout
->analog_rates
;
4699 runtime
->hw
.formats
= mout
->analog_formats
;
4700 hinfo
->maxbps
= mout
->analog_maxbps
;
4702 if (!mout
->spdif_rates
) {
4703 snd_hda_query_supported_pcm(codec
, mout
->dig_out_nid
,
4705 &mout
->spdif_formats
,
4706 &mout
->spdif_maxbps
);
4708 mutex_lock(&codec
->spdif_mutex
);
4709 if (mout
->share_spdif
) {
4710 if ((runtime
->hw
.rates
& mout
->spdif_rates
) &&
4711 (runtime
->hw
.formats
& mout
->spdif_formats
)) {
4712 runtime
->hw
.rates
&= mout
->spdif_rates
;
4713 runtime
->hw
.formats
&= mout
->spdif_formats
;
4714 if (mout
->spdif_maxbps
< hinfo
->maxbps
)
4715 hinfo
->maxbps
= mout
->spdif_maxbps
;
4717 mout
->share_spdif
= 0;
4718 /* FIXME: need notify? */
4721 mutex_unlock(&codec
->spdif_mutex
);
4723 return snd_pcm_hw_constraint_step(substream
->runtime
, 0,
4724 SNDRV_PCM_HW_PARAM_CHANNELS
, 2);
4726 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open
);
4729 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4730 * @codec: the HDA codec
4731 * @mout: hda_multi_out object
4732 * @stream_tag: stream tag to assign
4733 * @format: format id to assign
4734 * @substream: PCM substream to assign
4736 * Set up the i/o for analog out.
4737 * When the digital out is available, copy the front out to digital out, too.
4739 int snd_hda_multi_out_analog_prepare(struct hda_codec
*codec
,
4740 struct hda_multi_out
*mout
,
4741 unsigned int stream_tag
,
4742 unsigned int format
,
4743 struct snd_pcm_substream
*substream
)
4745 const hda_nid_t
*nids
= mout
->dac_nids
;
4746 int chs
= substream
->runtime
->channels
;
4747 struct hda_spdif_out
*spdif
;
4750 mutex_lock(&codec
->spdif_mutex
);
4751 spdif
= snd_hda_spdif_out_of_nid(codec
, mout
->dig_out_nid
);
4752 if (mout
->dig_out_nid
&& mout
->share_spdif
&&
4753 mout
->dig_out_used
!= HDA_DIG_EXCLUSIVE
) {
4755 snd_hda_is_supported_format(codec
, mout
->dig_out_nid
,
4757 !(spdif
->status
& IEC958_AES0_NONAUDIO
)) {
4758 mout
->dig_out_used
= HDA_DIG_ANALOG_DUP
;
4759 setup_dig_out_stream(codec
, mout
->dig_out_nid
,
4760 stream_tag
, format
);
4762 mout
->dig_out_used
= 0;
4763 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4766 mutex_unlock(&codec
->spdif_mutex
);
4769 snd_hda_codec_setup_stream(codec
, nids
[HDA_FRONT
], stream_tag
,
4771 if (!mout
->no_share_stream
&&
4772 mout
->hp_nid
&& mout
->hp_nid
!= nids
[HDA_FRONT
])
4773 /* headphone out will just decode front left/right (stereo) */
4774 snd_hda_codec_setup_stream(codec
, mout
->hp_nid
, stream_tag
,
4776 /* extra outputs copied from front */
4777 for (i
= 0; i
< ARRAY_SIZE(mout
->hp_out_nid
); i
++)
4778 if (!mout
->no_share_stream
&& mout
->hp_out_nid
[i
])
4779 snd_hda_codec_setup_stream(codec
,
4780 mout
->hp_out_nid
[i
],
4781 stream_tag
, 0, format
);
4784 for (i
= 1; i
< mout
->num_dacs
; i
++) {
4785 if (chs
>= (i
+ 1) * 2) /* independent out */
4786 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
4788 else if (!mout
->no_share_stream
) /* copy front */
4789 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
4793 /* extra surrounds */
4794 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++) {
4796 if (!mout
->extra_out_nid
[i
])
4798 if (chs
>= (i
+ 1) * 2)
4800 else if (!mout
->no_share_stream
)
4802 snd_hda_codec_setup_stream(codec
, mout
->extra_out_nid
[i
],
4803 stream_tag
, ch
, format
);
4808 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare
);
4811 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4812 * @codec: the HDA codec
4813 * @mout: hda_multi_out object
4815 int snd_hda_multi_out_analog_cleanup(struct hda_codec
*codec
,
4816 struct hda_multi_out
*mout
)
4818 const hda_nid_t
*nids
= mout
->dac_nids
;
4821 for (i
= 0; i
< mout
->num_dacs
; i
++)
4822 snd_hda_codec_cleanup_stream(codec
, nids
[i
]);
4824 snd_hda_codec_cleanup_stream(codec
, mout
->hp_nid
);
4825 for (i
= 0; i
< ARRAY_SIZE(mout
->hp_out_nid
); i
++)
4826 if (mout
->hp_out_nid
[i
])
4827 snd_hda_codec_cleanup_stream(codec
,
4828 mout
->hp_out_nid
[i
]);
4829 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
4830 if (mout
->extra_out_nid
[i
])
4831 snd_hda_codec_cleanup_stream(codec
,
4832 mout
->extra_out_nid
[i
]);
4833 mutex_lock(&codec
->spdif_mutex
);
4834 if (mout
->dig_out_nid
&& mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
) {
4835 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4836 mout
->dig_out_used
= 0;
4838 mutex_unlock(&codec
->spdif_mutex
);
4841 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup
);
4844 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
4845 * @codec: the HDA codec
4846 * @pin: referred pin NID
4848 * Guess the suitable VREF pin bits to be set as the pin-control value.
4849 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
4851 unsigned int snd_hda_get_default_vref(struct hda_codec
*codec
, hda_nid_t pin
)
4853 unsigned int pincap
;
4854 unsigned int oldval
;
4855 oldval
= snd_hda_codec_read(codec
, pin
, 0,
4856 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
4857 pincap
= snd_hda_query_pin_caps(codec
, pin
);
4858 pincap
= (pincap
& AC_PINCAP_VREF
) >> AC_PINCAP_VREF_SHIFT
;
4859 /* Exception: if the default pin setup is vref50, we give it priority */
4860 if ((pincap
& AC_PINCAP_VREF_80
) && oldval
!= PIN_VREF50
)
4861 return AC_PINCTL_VREF_80
;
4862 else if (pincap
& AC_PINCAP_VREF_50
)
4863 return AC_PINCTL_VREF_50
;
4864 else if (pincap
& AC_PINCAP_VREF_100
)
4865 return AC_PINCTL_VREF_100
;
4866 else if (pincap
& AC_PINCAP_VREF_GRD
)
4867 return AC_PINCTL_VREF_GRD
;
4868 return AC_PINCTL_VREF_HIZ
;
4870 EXPORT_SYMBOL_GPL(snd_hda_get_default_vref
);
4873 * snd_hda_correct_pin_ctl - correct the pin ctl value for matching with the pin cap
4874 * @codec: the HDA codec
4875 * @pin: referred pin NID
4876 * @val: pin ctl value to audit
4878 unsigned int snd_hda_correct_pin_ctl(struct hda_codec
*codec
,
4879 hda_nid_t pin
, unsigned int val
)
4881 static unsigned int cap_lists
[][2] = {
4882 { AC_PINCTL_VREF_100
, AC_PINCAP_VREF_100
},
4883 { AC_PINCTL_VREF_80
, AC_PINCAP_VREF_80
},
4884 { AC_PINCTL_VREF_50
, AC_PINCAP_VREF_50
},
4885 { AC_PINCTL_VREF_GRD
, AC_PINCAP_VREF_GRD
},
4891 cap
= snd_hda_query_pin_caps(codec
, pin
);
4893 return val
; /* don't know what to do... */
4895 if (val
& AC_PINCTL_OUT_EN
) {
4896 if (!(cap
& AC_PINCAP_OUT
))
4897 val
&= ~(AC_PINCTL_OUT_EN
| AC_PINCTL_HP_EN
);
4898 else if ((val
& AC_PINCTL_HP_EN
) && !(cap
& AC_PINCAP_HP_DRV
))
4899 val
&= ~AC_PINCTL_HP_EN
;
4902 if (val
& AC_PINCTL_IN_EN
) {
4903 if (!(cap
& AC_PINCAP_IN
))
4904 val
&= ~(AC_PINCTL_IN_EN
| AC_PINCTL_VREFEN
);
4906 unsigned int vcap
, vref
;
4908 vcap
= (cap
& AC_PINCAP_VREF
) >> AC_PINCAP_VREF_SHIFT
;
4909 vref
= val
& AC_PINCTL_VREFEN
;
4910 for (i
= 0; i
< ARRAY_SIZE(cap_lists
); i
++) {
4911 if (vref
== cap_lists
[i
][0] &&
4912 !(vcap
& cap_lists
[i
][1])) {
4913 if (i
== ARRAY_SIZE(cap_lists
) - 1)
4914 vref
= AC_PINCTL_VREF_HIZ
;
4916 vref
= cap_lists
[i
+ 1][0];
4919 val
&= ~AC_PINCTL_VREFEN
;
4926 EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl
);
4929 * _snd_hda_pin_ctl - Helper to set pin ctl value
4930 * @codec: the HDA codec
4931 * @pin: referred pin NID
4932 * @val: pin control value to set
4933 * @cached: access over codec pinctl cache or direct write
4935 * This function is a helper to set a pin ctl value more safely.
4936 * It corrects the pin ctl value via snd_hda_correct_pin_ctl(), stores the
4937 * value in pin target array via snd_hda_codec_set_pin_target(), then
4938 * actually writes the value via either snd_hda_codec_update_cache() or
4939 * snd_hda_codec_write() depending on @cached flag.
4941 int _snd_hda_set_pin_ctl(struct hda_codec
*codec
, hda_nid_t pin
,
4942 unsigned int val
, bool cached
)
4944 val
= snd_hda_correct_pin_ctl(codec
, pin
, val
);
4945 snd_hda_codec_set_pin_target(codec
, pin
, val
);
4947 return snd_hda_codec_update_cache(codec
, pin
, 0,
4948 AC_VERB_SET_PIN_WIDGET_CONTROL
, val
);
4950 return snd_hda_codec_write(codec
, pin
, 0,
4951 AC_VERB_SET_PIN_WIDGET_CONTROL
, val
);
4953 EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl
);
4956 * snd_hda_add_imux_item - Add an item to input_mux
4957 * @codec: the HDA codec
4958 * @imux: imux helper object
4959 * @label: the name of imux item to assign
4960 * @index: index number of imux item to assign
4961 * @type_idx: pointer to store the resultant label index
4963 * When the same label is used already in the existing items, the number
4964 * suffix is appended to the label. This label index number is stored
4965 * to type_idx when non-NULL pointer is given.
4967 int snd_hda_add_imux_item(struct hda_codec
*codec
,
4968 struct hda_input_mux
*imux
, const char *label
,
4969 int index
, int *type_idx
)
4971 int i
, label_idx
= 0;
4972 if (imux
->num_items
>= HDA_MAX_NUM_INPUTS
) {
4973 codec_err(codec
, "hda_codec: Too many imux items!\n");
4976 for (i
= 0; i
< imux
->num_items
; i
++) {
4977 if (!strncmp(label
, imux
->items
[i
].label
, strlen(label
)))
4981 *type_idx
= label_idx
;
4983 snprintf(imux
->items
[imux
->num_items
].label
,
4984 sizeof(imux
->items
[imux
->num_items
].label
),
4985 "%s %d", label
, label_idx
);
4987 strlcpy(imux
->items
[imux
->num_items
].label
, label
,
4988 sizeof(imux
->items
[imux
->num_items
].label
));
4989 imux
->items
[imux
->num_items
].index
= index
;
4993 EXPORT_SYMBOL_GPL(snd_hda_add_imux_item
);
4996 * snd_hda_bus_reset - Reset the bus
4997 * @bus: HD-audio bus
4999 void snd_hda_bus_reset(struct hda_bus
*bus
)
5001 struct hda_codec
*codec
;
5003 list_for_each_codec(codec
, bus
) {
5004 /* FIXME: maybe a better way needed for forced reset */
5005 cancel_delayed_work_sync(&codec
->jackpoll_work
);
5007 if (hda_codec_is_power_on(codec
)) {
5008 hda_call_codec_suspend(codec
);
5009 hda_call_codec_resume(codec
);
5014 EXPORT_SYMBOL_GPL(snd_hda_bus_reset
);
5017 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5018 * @pcm: PCM caps bits
5019 * @buf: the string buffer to write
5020 * @buflen: the max buffer length
5022 * used by hda_proc.c and hda_eld.c
5024 void snd_print_pcm_bits(int pcm
, char *buf
, int buflen
)
5026 static unsigned int bits
[] = { 8, 16, 20, 24, 32 };
5029 for (i
= 0, j
= 0; i
< ARRAY_SIZE(bits
); i
++)
5030 if (pcm
& (AC_SUPPCM_BITS_8
<< i
))
5031 j
+= snprintf(buf
+ j
, buflen
- j
, " %d", bits
[i
]);
5033 buf
[j
] = '\0'; /* necessary when j == 0 */
5035 EXPORT_SYMBOL_GPL(snd_print_pcm_bits
);
5037 MODULE_DESCRIPTION("HDA codec core");
5038 MODULE_LICENSE("GPL");