2019-05-27 14:55:05 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifndef __SOUND_CORE_H
|
|
|
|
|
#define __SOUND_CORE_H
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Main header file for the ALSA driver
|
2007-10-15 15:50:19 +08:00
|
|
|
* Copyright (c) 1994-2001 by Jaroslav Kysela <perex@perex.cz>
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
|
2014-01-29 18:46:11 +08:00
|
|
|
#include <linux/device.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/sched.h> /* wake_up() */
|
2006-01-16 23:29:08 +08:00
|
|
|
#include <linux/mutex.h> /* struct mutex */
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/rwsem.h> /* struct rw_semaphore */
|
|
|
|
|
#include <linux/pm.h> /* pm_message_t */
|
2008-08-08 23:06:01 +08:00
|
|
|
#include <linux/stringify.h>
|
2013-08-17 01:18:59 +08:00
|
|
|
#include <linux/printk.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-01-09 01:13:27 +08:00
|
|
|
/* number of supported soundcards */
|
|
|
|
|
#ifdef CONFIG_SND_DYNAMIC_MINORS
|
ALSA: Add kconfig to specify the max card numbers
Currently ALSA supports up to 32 card instances when the dynamic minor
is used. While 32 cards are usually big enough for normal use cases,
there are sometimes weird requirements with more card support.
Actually, this limitation, 32, comes from the index option, where you
can pass the bit mask to assign the card. Other than that, we can
actually give more cards up to the minor number limits (currently 256,
which can be extended more, too).
This patch adds a new Kconfig to specify the max card numbers, and
changes a few places to accept more than 32 cards.
The only incompatibility with high card numbers would be the handling
of index option. The index option can be still used to pass the
bitmask for card assignments, but this works only up to 32 slots.
More than 32, no bitmask style option is available but only a single
slot can be specified via index option.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-05-15 14:46:39 +08:00
|
|
|
#define SNDRV_CARDS CONFIG_SND_MAX_CARDS
|
2008-01-09 01:13:27 +08:00
|
|
|
#else
|
|
|
|
|
#define SNDRV_CARDS 8 /* don't change - minor numbers */
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define CONFIG_SND_MAJOR 116 /* standard configuration */
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* forward declarations */
|
|
|
|
|
struct pci_dev;
|
2011-05-27 01:46:22 +08:00
|
|
|
struct module;
|
2014-01-29 19:13:43 +08:00
|
|
|
struct completion;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* device allocation stuff */
|
|
|
|
|
|
ALSA: Use priority list for managing device list
Basically, the device type specifies the priority of the device to be
registered / freed, too. However, the priority value isn't well
utilized but only it's checked as a group. This results in
inconsistent register and free order (where each of them should be in
reversed direction).
This patch simplifies the device list management code by simply
inserting a list entry at creation time in an incremental order for
the priority value. Since we can just follow the link for register,
disconnect and free calls, we don't have to specify the group; so the
whole enum definitions are also simplified as well.
The visible change to outside is that the priorities of some object
types are revisited. For example, now the SNDRV_DEV_LOWLEVEL object
is registered before others (control, PCM, etc) and, in return,
released after others. Similarly, SNDRV_DEV_CODEC is in a lower
priority than SNDRV_DEV_BUS for ensuring the dependency.
Also, the unused SNDRV_DEV_TOPLEVEL, SNDRV_DEV_LOWLEVEL_PRE and
SNDRV_DEV_LOWLEVEL_NORMAL are removed as a cleanup.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2014-01-29 22:53:35 +08:00
|
|
|
/* type of the object used in snd_device_*()
|
|
|
|
|
* this also defines the calling order
|
|
|
|
|
*/
|
2014-01-29 22:13:33 +08:00
|
|
|
enum snd_device_type {
|
ALSA: Use priority list for managing device list
Basically, the device type specifies the priority of the device to be
registered / freed, too. However, the priority value isn't well
utilized but only it's checked as a group. This results in
inconsistent register and free order (where each of them should be in
reversed direction).
This patch simplifies the device list management code by simply
inserting a list entry at creation time in an incremental order for
the priority value. Since we can just follow the link for register,
disconnect and free calls, we don't have to specify the group; so the
whole enum definitions are also simplified as well.
The visible change to outside is that the priorities of some object
types are revisited. For example, now the SNDRV_DEV_LOWLEVEL object
is registered before others (control, PCM, etc) and, in return,
released after others. Similarly, SNDRV_DEV_CODEC is in a lower
priority than SNDRV_DEV_BUS for ensuring the dependency.
Also, the unused SNDRV_DEV_TOPLEVEL, SNDRV_DEV_LOWLEVEL_PRE and
SNDRV_DEV_LOWLEVEL_NORMAL are removed as a cleanup.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2014-01-29 22:53:35 +08:00
|
|
|
SNDRV_DEV_LOWLEVEL,
|
|
|
|
|
SNDRV_DEV_INFO,
|
|
|
|
|
SNDRV_DEV_BUS,
|
|
|
|
|
SNDRV_DEV_CODEC,
|
2014-01-29 22:13:33 +08:00
|
|
|
SNDRV_DEV_PCM,
|
ALSA: Use priority list for managing device list
Basically, the device type specifies the priority of the device to be
registered / freed, too. However, the priority value isn't well
utilized but only it's checked as a group. This results in
inconsistent register and free order (where each of them should be in
reversed direction).
This patch simplifies the device list management code by simply
inserting a list entry at creation time in an incremental order for
the priority value. Since we can just follow the link for register,
disconnect and free calls, we don't have to specify the group; so the
whole enum definitions are also simplified as well.
The visible change to outside is that the priorities of some object
types are revisited. For example, now the SNDRV_DEV_LOWLEVEL object
is registered before others (control, PCM, etc) and, in return,
released after others. Similarly, SNDRV_DEV_CODEC is in a lower
priority than SNDRV_DEV_BUS for ensuring the dependency.
Also, the unused SNDRV_DEV_TOPLEVEL, SNDRV_DEV_LOWLEVEL_PRE and
SNDRV_DEV_LOWLEVEL_NORMAL are removed as a cleanup.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2014-01-29 22:53:35 +08:00
|
|
|
SNDRV_DEV_COMPRESS,
|
2014-01-29 22:13:33 +08:00
|
|
|
SNDRV_DEV_RAWMIDI,
|
|
|
|
|
SNDRV_DEV_TIMER,
|
|
|
|
|
SNDRV_DEV_SEQUENCER,
|
|
|
|
|
SNDRV_DEV_HWDEP,
|
|
|
|
|
SNDRV_DEV_JACK,
|
ALSA: core: Assure control device to be registered at last
The commit 289ca025ee1d ("ALSA: Use priority list for managing device
list") changed the way to register/disconnect/free devices via a
single priority list. This helped to make behavior consistent, but it
also changed a slight behavior change: namely, the control device is
registered earlier than others, while it was supposed to be the very
last one.
I've put SNDRV_DEV_CONTROL in the current position as the release of
ctl elements often conflict with the private ctl elements some PCM or
other components may create, which often leads to a double-free.
But, the order of register and disconnect should be indeed fixed as
expected in the early days: the control device gets registered at
last, and disconnected at first.
This patch changes the priority list order to move SNDRV_DEV_CONTROL
as the last guy to assure the register / disconnect order. Meanwhile,
for keeping the messy resource release order, manually treat the
control and lowlevel devices as last freed one.
Additional note:
The lowlevel device is the device where a card driver creates at
probe. And, we still keep the release order control -> lowlevel, as
there might be link from a control element back to a lowlevel object.
Fixes: 289ca025ee1d ("ALSA: Use priority list for managing device list")
Reported-by: Tzung-Bi Shih <tzungbi@google.com>
Tested-by: Tzung-Bi Shih <tzungbi@google.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2018-05-16 02:25:29 +08:00
|
|
|
SNDRV_DEV_CONTROL, /* NOTE: this must be the last one */
|
2014-01-29 22:13:33 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum snd_device_state {
|
|
|
|
|
SNDRV_DEV_BUILD,
|
|
|
|
|
SNDRV_DEV_REGISTERED,
|
|
|
|
|
SNDRV_DEV_DISCONNECTED,
|
|
|
|
|
};
|
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
struct snd_device;
|
|
|
|
|
|
|
|
|
|
struct snd_device_ops {
|
|
|
|
|
int (*dev_free)(struct snd_device *dev);
|
|
|
|
|
int (*dev_register)(struct snd_device *dev);
|
|
|
|
|
int (*dev_disconnect)(struct snd_device *dev);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct snd_device {
|
2005-04-17 06:20:36 +08:00
|
|
|
struct list_head list; /* list of registered devices */
|
2005-11-17 20:51:18 +08:00
|
|
|
struct snd_card *card; /* card which holds this device */
|
2014-01-29 22:13:33 +08:00
|
|
|
enum snd_device_state state; /* state of the device */
|
|
|
|
|
enum snd_device_type type; /* device type */
|
2005-04-17 06:20:36 +08:00
|
|
|
void *device_data; /* device structure */
|
2020-01-03 16:16:19 +08:00
|
|
|
const struct snd_device_ops *ops; /* operations */
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
#define snd_device(n) list_entry(n, struct snd_device, list)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* main structure for soundcard */
|
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
struct snd_card {
|
2005-06-30 01:31:06 +08:00
|
|
|
int number; /* number of soundcard (index to
|
|
|
|
|
snd_cards) */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
char id[16]; /* id string of this card */
|
|
|
|
|
char driver[16]; /* driver name */
|
|
|
|
|
char shortname[32]; /* short name of this soundcard */
|
|
|
|
|
char longname[80]; /* name of this soundcard */
|
2015-12-23 02:09:05 +08:00
|
|
|
char irq_descr[32]; /* Interrupt description */
|
2005-04-17 06:20:36 +08:00
|
|
|
char mixername[80]; /* mixer name */
|
2008-10-07 17:38:09 +08:00
|
|
|
char components[128]; /* card components delimited with
|
2005-06-30 01:31:06 +08:00
|
|
|
space */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct module *module; /* top-level module */
|
|
|
|
|
|
|
|
|
|
void *private_data; /* private data for soundcard */
|
2005-11-17 20:51:18 +08:00
|
|
|
void (*private_free) (struct snd_card *card); /* callback for freeing of
|
2005-06-30 01:31:06 +08:00
|
|
|
private data */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct list_head devices; /* devices */
|
|
|
|
|
|
2015-01-29 23:41:27 +08:00
|
|
|
struct device ctl_dev; /* control device */
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int last_numid; /* last used numeric ID */
|
|
|
|
|
struct rw_semaphore controls_rwsem; /* controls list lock */
|
|
|
|
|
rwlock_t ctl_files_rwlock; /* ctl_files list lock */
|
|
|
|
|
int controls_count; /* count of all controls */
|
ALSA: control: Add memory consumption limit to user controls
ALSA control interface allows users to add arbitrary control elements
(called "user controls" or "user elements"), and its resource usage is
limited just by the max number of control sets (currently 32). This
limit, however, is quite loose: each allocation of control set may
have 1028 elements, and each element may have up to 512 bytes (ILP32) or
1024 bytes (LP64) of value data. Moreover, each control set may contain
the enum strings and TLV data, which can be up to 64kB and 128kB,
respectively. Totally, the whole memory consumption may go over 38MB --
it's quite large, and we'd rather like to reduce the size.
OTOH, there have been other requests even to increase the max number
of user elements; e.g. ALSA firewire stack require the more user
controls, hence we want to raise the bar, too.
For satisfying both requirements, this patch changes the management of
user controls: instead of setting the upper limit of the number of
user controls, we check the actual memory allocation size and set the
upper limit of the total allocation in bytes. As long as the memory
consumption stays below the limit, more user controls are allowed than
the current limit 32. At the same time, we set the lower limit (8MB)
as default than the current theoretical limit, in order to lower the
risk of DoS.
As a compromise for lowering the default limit, now the actual memory
limit is defined as a module option, 'max_user_ctl_alloc_size', so that
user can increase/decrease the limit if really needed, too.
Link: https://lore.kernel.org/r/s5htur3zl5e.wl-tiwai@suse.de
Co-developed-by: Takashi Iwai <tiwai@suse.de>
Reviewed-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Tested-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Link: https://lore.kernel.org/r/20210408103149.40357-1-o-takashi@sakamocchi.jp
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2021-04-08 18:31:49 +08:00
|
|
|
size_t user_ctl_alloc_size; // current memory allocation by user controls.
|
2005-04-17 06:20:36 +08:00
|
|
|
struct list_head controls; /* all controls for this card */
|
|
|
|
|
struct list_head ctl_files; /* active control files */
|
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
struct snd_info_entry *proc_root; /* root for soundcard specific files */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct proc_dir_entry *proc_root_link; /* number link to real id */
|
|
|
|
|
|
2009-02-23 23:35:21 +08:00
|
|
|
struct list_head files_list; /* all files associated to this card */
|
2005-06-30 01:31:06 +08:00
|
|
|
struct snd_shutdown_f_ops *s_f_ops; /* file operations in the shutdown
|
|
|
|
|
state */
|
2005-04-17 06:20:36 +08:00
|
|
|
spinlock_t files_lock; /* lock the files for this card */
|
|
|
|
|
int shutdown; /* this card is going down */
|
2014-01-29 19:13:43 +08:00
|
|
|
struct completion *release_completion;
|
2007-01-26 19:40:31 +08:00
|
|
|
struct device *dev; /* device assigned to this card */
|
2014-01-29 18:46:11 +08:00
|
|
|
struct device card_dev; /* cardX object for sysfs */
|
2015-01-30 19:27:43 +08:00
|
|
|
const struct attribute_group *dev_groups[4]; /* assigned sysfs attr */
|
2014-01-29 18:46:11 +08:00
|
|
|
bool registered; /* card_dev is registered? */
|
ALSA: core: Add managed card creation
As a second step for preliminary to widen the devres usages among
sound drivers, this patch adds a new ALSA core API function,
snd_devm_card_new(), to create a snd_card object via devres.
When a card object is created by this new function, snd_card_free() is
called automatically and the card object resource gets released at the
device unbinding time.
However, the story isn't that simple. A caveat is that we have to
call snd_card_free() at the very first of the whole resource release
procedure, in order to assure that the all exposed devices on
user-space are deleted and sync with processes accessing those devices
before releasing resources.
For achieving it, snd_card_register() adds a new devres action to
trigger snd_card_free() automatically when the given card object is a
"managed" one. Since usually snd_card_register() is the last step of
the initialization, this should work in most cases.
With all these tricks, some drivers can get rid of the whole driver
remove callback code.
About a bit of implementation details: the patch adds two new flags to
snd_card object: managed and releasing. The former indicates that the
object was created via snd_devm_card_new(), and the latter is used for
avoiding the double-free of snd_card_free() calls. Both flags are
fairly internal and likely uninteresting to normal users.
Link: https://lore.kernel.org/r/20210715075941.23332-3-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2021-07-15 15:58:24 +08:00
|
|
|
bool managed; /* managed via devres */
|
|
|
|
|
bool releasing; /* during card free process */
|
2019-11-17 16:53:07 +08:00
|
|
|
int sync_irq; /* assigned irq, used for PCM sync */
|
ALSA: add snd_card_disconnect_sync()
In case of user unbind ALSA driver during playing back / capturing,
each driver needs to stop and remove it correctly. One note here is
that we can't cancel from remove function in such case, because
unbind operation doesn't check return value from remove function.
So, we *must* stop and remove in this case.
For this purpose, we need to sync (= wait) until the all top-level
operations are canceled at remove function.
For example, snd_card_free() processes the disconnection procedure at
first, then waits for the completion. That's how the hot-unplug works
safely. It's implemented, at least, in the top-level driver removal.
Now for the lower level driver, we need a similar strategy. Notify to
the toplevel for hot-unplug (disconnect in ALSA), and sync with the
stop operation, then continue the rest of its own remove procedure.
This patch adds snd_card_disconnect_sync(), and driver can use it from
remove function.
Note: the "lower level" driver here refers to a middle layer driver
(e.g. ASoC components) that can be unbound freely during operation.
Most of legacy ALSA helper drivers don't have such a problem because
they can't be unbound.
Note#2: snd_card_disconnect_sync() merely calls snd_card_disconnect()
and syncs with closing all pending files. It takes only the files
opened by user-space into account, and doesn't care about object
refcounts. (The latter is handled by snd_card_free() completion call,
BTW.) Also, the function doesn't free resources by itself.
Tested-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2017-10-11 14:36:13 +08:00
|
|
|
wait_queue_head_t remove_sleep;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
ALSA: pcm: Set per-card upper limit of PCM buffer allocations
Currently, the available buffer allocation size for a PCM stream
depends on the preallocated size; when a buffer has been preallocated,
the max buffer size is set to that size, so that application won't
re-allocate too much memory. OTOH, when no preallocation is done,
each substream may allocate arbitrary size of buffers as long as
snd_pcm_hardware.buffer_bytes_max allows -- which can be quite high,
HD-audio sets 1GB there.
It means that the system may consume a high amount of pages for PCM
buffers, and they are pinned and never swapped out. This can lead to
OOM easily.
For avoiding such a situation, this patch adds the upper limit per
card. Each snd_pcm_lib_malloc_pages() and _free_pages() calls are
tracked and it will return an error if the total amount of buffers
goes over the defined upper limit. The default value is set to 32MB,
which should be really large enough for usual operations.
If larger buffers are needed for any specific usage, it can be
adjusted (also dynamically) via snd_pcm.max_alloc_per_card option.
Setting zero there means no chceck is performed, and again, unlimited
amount of buffers are allowed.
Link: https://lore.kernel.org/r/20200120124423.11862-1-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2020-01-20 20:44:22 +08:00
|
|
|
size_t total_pcm_alloc_bytes; /* total amount of allocated buffers */
|
|
|
|
|
struct mutex memory_mutex; /* protection for the above */
|
ALSA: jack: implement software jack injection via debugfs
This change adds audio jack injection feature through debugfs, with
this feature, we could validate alsa userspace changes by injecting
plugin or plugout events to the non-phantom audio jacks.
With this change, the sound core will build the folders
$debugfs_mount_dir/sound/cardN if SND_DEBUG and DEBUG_FS are enabled.
And if users also enable the SND_JACK_INJECTION_DEBUG, the jack
injection nodes will be built in the folder cardN like below:
$tree $debugfs_mount_dir/sound
$debugfs_mount_dir/sound
├── card0
│ ├── HDMI_DP_pcm_10_Jack
│ │ ├── jackin_inject
│ │ ├── kctl_id
│ │ ├── mask_bits
│ │ ├── status
│ │ ├── sw_inject_enable
│ │ └── type
...
│ └── HDMI_DP_pcm_9_Jack
│ ├── jackin_inject
│ ├── kctl_id
│ ├── mask_bits
│ ├── status
│ ├── sw_inject_enable
│ └── type
└── card1
├── HDMI_DP_pcm_5_Jack
│ ├── jackin_inject
│ ├── kctl_id
│ ├── mask_bits
│ ├── status
│ ├── sw_inject_enable
│ └── type
...
├── Headphone_Jack
│ ├── jackin_inject
│ ├── kctl_id
│ ├── mask_bits
│ ├── status
│ ├── sw_inject_enable
│ └── type
└── Headset_Mic_Jack
├── jackin_inject
├── kctl_id
├── mask_bits
├── status
├── sw_inject_enable
└── type
The nodes kctl_id, mask_bits, status and type are read-only, users
could check jack or jack_kctl's information through them.
The nodes sw_inject_enable and jackin_inject are directly used for
injection. The sw_inject_enable is read-write, users could check if
software injection is enabled or not on this jack, and users could
echo 1 or 0 to enable or disable software injection on this jack. Once
the injection is enabled, the jack will not change by hardware events
anymore, once the injection is disabled, the jack will restore the
last reported hardware events to the jack. The jackin_inject is
write-only, if the injection is enabled, users could echo 1 or 0 to
this node to inject plugin or plugout events to this jack.
For the detailed usage information on these nodes, please refer to
Documentation/sound/designs/jack-injection.rst.
Reviewed-by: Takashi Iwai <tiwai@suse.de>
Reviewed-by: Jaroslav Kysela <perex@perex.cz>
Reviewed-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>
Signed-off-by: Hui Wang <hui.wang@canonical.com>
Link: https://lore.kernel.org/r/20210127085639.74954-2-hui.wang@canonical.com
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2021-01-27 16:56:39 +08:00
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
|
struct dentry *debugfs_root; /* debugfs root for card */
|
|
|
|
|
#endif
|
ALSA: pcm: Set per-card upper limit of PCM buffer allocations
Currently, the available buffer allocation size for a PCM stream
depends on the preallocated size; when a buffer has been preallocated,
the max buffer size is set to that size, so that application won't
re-allocate too much memory. OTOH, when no preallocation is done,
each substream may allocate arbitrary size of buffers as long as
snd_pcm_hardware.buffer_bytes_max allows -- which can be quite high,
HD-audio sets 1GB there.
It means that the system may consume a high amount of pages for PCM
buffers, and they are pinned and never swapped out. This can lead to
OOM easily.
For avoiding such a situation, this patch adds the upper limit per
card. Each snd_pcm_lib_malloc_pages() and _free_pages() calls are
tracked and it will return an error if the total amount of buffers
goes over the defined upper limit. The default value is set to 32MB,
which should be really large enough for usual operations.
If larger buffers are needed for any specific usage, it can be
adjusted (also dynamically) via snd_pcm.max_alloc_per_card option.
Setting zero there means no chceck is performed, and again, unlimited
amount of buffers are allowed.
Link: https://lore.kernel.org/r/20200120124423.11862-1-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2020-01-20 20:44:22 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
|
unsigned int power_state; /* power state */
|
ALSA: control: Track in-flight control read/write/tlv accesses
Although the power state check is performed in various places (e.g. at
the entrance of quite a few ioctls), there can be still some pending
tasks that already went into the ioctl handler or other ops, and those
may access the hardware even after the power state check. For
example, kcontrol access ioctl paths that call info/get/put callbacks
may update the hardware registers. If a system wants to assure the
free from such hw access (like the case of PCI rescan feature we're
going to implement in future), this situation must be avoided, and we
have to sync such in-flight tasks finishing beforehand.
For that purpose, this patch introduces a few new things in core code:
- A refcount, power_ref, and a wait queue, power_ref_sleep, to the
card object
- A few new helpers, snd_power_ref(), snd_power_unref(),
snd_power_ref_and_wait(), and snd_power_sync_ref()
In the code paths that call kctl info/read/write/tlv ops, we check the
power state with the newly introduced snd_power_ref_and_wait(). This
function also takes the card.power_ref refcount for tracking this
in-flight task. Once after the access finishes, snd_power_unref() is
called to released the refcount in return. So the driver can sync via
snd_power_sync_ref() assuring that all in-flight tasks have been
finished.
As of this patch, snd_power_sync_ref() is called only at
snd_card_disconnect(), but it'll be used in other places in future.
Note that atomic_t is used for power_ref intentionally instead of
refcount_t. It's because of the design of refcount_t type; refcount_t
cannot be zero-based, and it cannot do dec_and_test() call for
multiple times, hence it's not suitable for our purpose.
Also, this patch changes snd_power_wait() to accept only
SNDRV_CTL_POWER_D0, which is the only value that makes sense.
In later patch, the snd_power_wait() calls will be cleaned up.
Reviewed-by: Jaroslav Kysela <perex@perex.cz>
Link: https://lore.kernel.org/r/20210523090920.15345-3-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2021-05-23 17:09:16 +08:00
|
|
|
atomic_t power_ref;
|
2005-04-17 06:20:36 +08:00
|
|
|
wait_queue_head_t power_sleep;
|
ALSA: control: Track in-flight control read/write/tlv accesses
Although the power state check is performed in various places (e.g. at
the entrance of quite a few ioctls), there can be still some pending
tasks that already went into the ioctl handler or other ops, and those
may access the hardware even after the power state check. For
example, kcontrol access ioctl paths that call info/get/put callbacks
may update the hardware registers. If a system wants to assure the
free from such hw access (like the case of PCI rescan feature we're
going to implement in future), this situation must be avoided, and we
have to sync such in-flight tasks finishing beforehand.
For that purpose, this patch introduces a few new things in core code:
- A refcount, power_ref, and a wait queue, power_ref_sleep, to the
card object
- A few new helpers, snd_power_ref(), snd_power_unref(),
snd_power_ref_and_wait(), and snd_power_sync_ref()
In the code paths that call kctl info/read/write/tlv ops, we check the
power state with the newly introduced snd_power_ref_and_wait(). This
function also takes the card.power_ref refcount for tracking this
in-flight task. Once after the access finishes, snd_power_unref() is
called to released the refcount in return. So the driver can sync via
snd_power_sync_ref() assuring that all in-flight tasks have been
finished.
As of this patch, snd_power_sync_ref() is called only at
snd_card_disconnect(), but it'll be used in other places in future.
Note that atomic_t is used for power_ref intentionally instead of
refcount_t. It's because of the design of refcount_t type; refcount_t
cannot be zero-based, and it cannot do dec_and_test() call for
multiple times, hence it's not suitable for our purpose.
Also, this patch changes snd_power_wait() to accept only
SNDRV_CTL_POWER_D0, which is the only value that makes sense.
In later patch, the snd_power_wait() calls will be cleaned up.
Reviewed-by: Jaroslav Kysela <perex@perex.cz>
Link: https://lore.kernel.org/r/20210523090920.15345-3-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2021-05-23 17:09:16 +08:00
|
|
|
wait_queue_head_t power_ref_sleep;
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
2017-05-12 17:44:03 +08:00
|
|
|
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
2005-11-17 20:51:18 +08:00
|
|
|
struct snd_mixer_oss *mixer_oss;
|
2005-04-17 06:20:36 +08:00
|
|
|
int mixer_oss_change_count;
|
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
2014-01-29 18:46:11 +08:00
|
|
|
#define dev_to_snd_card(p) container_of(p, struct snd_card, card_dev)
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_PM
|
2005-11-17 20:51:18 +08:00
|
|
|
static inline unsigned int snd_power_get_state(struct snd_card *card)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2021-05-23 17:09:15 +08:00
|
|
|
return READ_ONCE(card->power_state);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
static inline void snd_power_change_state(struct snd_card *card, unsigned int state)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2021-05-23 17:09:15 +08:00
|
|
|
WRITE_ONCE(card->power_state, state);
|
2005-04-17 06:20:36 +08:00
|
|
|
wake_up(&card->power_sleep);
|
|
|
|
|
}
|
2005-06-30 01:31:06 +08:00
|
|
|
|
ALSA: control: Track in-flight control read/write/tlv accesses
Although the power state check is performed in various places (e.g. at
the entrance of quite a few ioctls), there can be still some pending
tasks that already went into the ioctl handler or other ops, and those
may access the hardware even after the power state check. For
example, kcontrol access ioctl paths that call info/get/put callbacks
may update the hardware registers. If a system wants to assure the
free from such hw access (like the case of PCI rescan feature we're
going to implement in future), this situation must be avoided, and we
have to sync such in-flight tasks finishing beforehand.
For that purpose, this patch introduces a few new things in core code:
- A refcount, power_ref, and a wait queue, power_ref_sleep, to the
card object
- A few new helpers, snd_power_ref(), snd_power_unref(),
snd_power_ref_and_wait(), and snd_power_sync_ref()
In the code paths that call kctl info/read/write/tlv ops, we check the
power state with the newly introduced snd_power_ref_and_wait(). This
function also takes the card.power_ref refcount for tracking this
in-flight task. Once after the access finishes, snd_power_unref() is
called to released the refcount in return. So the driver can sync via
snd_power_sync_ref() assuring that all in-flight tasks have been
finished.
As of this patch, snd_power_sync_ref() is called only at
snd_card_disconnect(), but it'll be used in other places in future.
Note that atomic_t is used for power_ref intentionally instead of
refcount_t. It's because of the design of refcount_t type; refcount_t
cannot be zero-based, and it cannot do dec_and_test() call for
multiple times, hence it's not suitable for our purpose.
Also, this patch changes snd_power_wait() to accept only
SNDRV_CTL_POWER_D0, which is the only value that makes sense.
In later patch, the snd_power_wait() calls will be cleaned up.
Reviewed-by: Jaroslav Kysela <perex@perex.cz>
Link: https://lore.kernel.org/r/20210523090920.15345-3-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2021-05-23 17:09:16 +08:00
|
|
|
/**
|
|
|
|
|
* snd_power_ref - Take the reference count for power control
|
|
|
|
|
* @card: sound card object
|
|
|
|
|
*
|
|
|
|
|
* The power_ref reference of the card is used for managing to block
|
|
|
|
|
* the snd_power_sync_ref() operation. This function increments the reference.
|
|
|
|
|
* The counterpart snd_power_unref() has to be called appropriately later.
|
|
|
|
|
*/
|
|
|
|
|
static inline void snd_power_ref(struct snd_card *card)
|
|
|
|
|
{
|
|
|
|
|
atomic_inc(&card->power_ref);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* snd_power_unref - Release the reference count for power control
|
|
|
|
|
* @card: sound card object
|
|
|
|
|
*/
|
|
|
|
|
static inline void snd_power_unref(struct snd_card *card)
|
|
|
|
|
{
|
|
|
|
|
if (atomic_dec_and_test(&card->power_ref))
|
|
|
|
|
wake_up(&card->power_ref_sleep);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* snd_power_sync_ref - wait until the card power_ref is freed
|
|
|
|
|
* @card: sound card object
|
|
|
|
|
*
|
|
|
|
|
* This function is used to synchronize with the pending power_ref being
|
|
|
|
|
* released.
|
|
|
|
|
*/
|
|
|
|
|
static inline void snd_power_sync_ref(struct snd_card *card)
|
|
|
|
|
{
|
|
|
|
|
wait_event(card->power_ref_sleep, !atomic_read(&card->power_ref));
|
|
|
|
|
}
|
|
|
|
|
|
2005-06-30 01:31:06 +08:00
|
|
|
/* init.c */
|
2021-05-23 17:09:19 +08:00
|
|
|
int snd_power_wait(struct snd_card *card);
|
ALSA: control: Track in-flight control read/write/tlv accesses
Although the power state check is performed in various places (e.g. at
the entrance of quite a few ioctls), there can be still some pending
tasks that already went into the ioctl handler or other ops, and those
may access the hardware even after the power state check. For
example, kcontrol access ioctl paths that call info/get/put callbacks
may update the hardware registers. If a system wants to assure the
free from such hw access (like the case of PCI rescan feature we're
going to implement in future), this situation must be avoided, and we
have to sync such in-flight tasks finishing beforehand.
For that purpose, this patch introduces a few new things in core code:
- A refcount, power_ref, and a wait queue, power_ref_sleep, to the
card object
- A few new helpers, snd_power_ref(), snd_power_unref(),
snd_power_ref_and_wait(), and snd_power_sync_ref()
In the code paths that call kctl info/read/write/tlv ops, we check the
power state with the newly introduced snd_power_ref_and_wait(). This
function also takes the card.power_ref refcount for tracking this
in-flight task. Once after the access finishes, snd_power_unref() is
called to released the refcount in return. So the driver can sync via
snd_power_sync_ref() assuring that all in-flight tasks have been
finished.
As of this patch, snd_power_sync_ref() is called only at
snd_card_disconnect(), but it'll be used in other places in future.
Note that atomic_t is used for power_ref intentionally instead of
refcount_t. It's because of the design of refcount_t type; refcount_t
cannot be zero-based, and it cannot do dec_and_test() call for
multiple times, hence it's not suitable for our purpose.
Also, this patch changes snd_power_wait() to accept only
SNDRV_CTL_POWER_D0, which is the only value that makes sense.
In later patch, the snd_power_wait() calls will be cleaned up.
Reviewed-by: Jaroslav Kysela <perex@perex.cz>
Link: https://lore.kernel.org/r/20210523090920.15345-3-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2021-05-23 17:09:16 +08:00
|
|
|
int snd_power_ref_and_wait(struct snd_card *card);
|
2005-06-30 01:31:06 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#else /* ! CONFIG_PM */
|
|
|
|
|
|
2021-05-23 17:09:19 +08:00
|
|
|
static inline int snd_power_wait(struct snd_card *card) { return 0; }
|
ALSA: control: Track in-flight control read/write/tlv accesses
Although the power state check is performed in various places (e.g. at
the entrance of quite a few ioctls), there can be still some pending
tasks that already went into the ioctl handler or other ops, and those
may access the hardware even after the power state check. For
example, kcontrol access ioctl paths that call info/get/put callbacks
may update the hardware registers. If a system wants to assure the
free from such hw access (like the case of PCI rescan feature we're
going to implement in future), this situation must be avoided, and we
have to sync such in-flight tasks finishing beforehand.
For that purpose, this patch introduces a few new things in core code:
- A refcount, power_ref, and a wait queue, power_ref_sleep, to the
card object
- A few new helpers, snd_power_ref(), snd_power_unref(),
snd_power_ref_and_wait(), and snd_power_sync_ref()
In the code paths that call kctl info/read/write/tlv ops, we check the
power state with the newly introduced snd_power_ref_and_wait(). This
function also takes the card.power_ref refcount for tracking this
in-flight task. Once after the access finishes, snd_power_unref() is
called to released the refcount in return. So the driver can sync via
snd_power_sync_ref() assuring that all in-flight tasks have been
finished.
As of this patch, snd_power_sync_ref() is called only at
snd_card_disconnect(), but it'll be used in other places in future.
Note that atomic_t is used for power_ref intentionally instead of
refcount_t. It's because of the design of refcount_t type; refcount_t
cannot be zero-based, and it cannot do dec_and_test() call for
multiple times, hence it's not suitable for our purpose.
Also, this patch changes snd_power_wait() to accept only
SNDRV_CTL_POWER_D0, which is the only value that makes sense.
In later patch, the snd_power_wait() calls will be cleaned up.
Reviewed-by: Jaroslav Kysela <perex@perex.cz>
Link: https://lore.kernel.org/r/20210523090920.15345-3-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2021-05-23 17:09:16 +08:00
|
|
|
static inline void snd_power_ref(struct snd_card *card) {}
|
|
|
|
|
static inline void snd_power_unref(struct snd_card *card) {}
|
|
|
|
|
static inline int snd_power_ref_and_wait(struct snd_card *card) { return 0; }
|
|
|
|
|
static inline void snd_power_sync_ref(struct snd_card *card) {}
|
2010-10-17 01:24:52 +08:00
|
|
|
#define snd_power_get_state(card) ({ (void)(card); SNDRV_CTL_POWER_D0; })
|
2005-04-17 06:20:36 +08:00
|
|
|
#define snd_power_change_state(card, state) do { (void)(card); } while (0)
|
|
|
|
|
|
|
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
struct snd_minor {
|
2005-11-20 21:03:48 +08:00
|
|
|
int type; /* SNDRV_DEVICE_TYPE_XXX */
|
2005-11-20 21:05:49 +08:00
|
|
|
int card; /* card number */
|
2005-04-17 06:20:36 +08:00
|
|
|
int device; /* device number */
|
2006-03-28 17:56:41 +08:00
|
|
|
const struct file_operations *f_ops; /* file operations */
|
2005-11-20 21:06:59 +08:00
|
|
|
void *private_data; /* private data for f_ops->open */
|
2006-08-08 13:19:37 +08:00
|
|
|
struct device *dev; /* device for sysfs */
|
2012-10-16 19:05:59 +08:00
|
|
|
struct snd_card *card_ptr; /* assigned card instance */
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
2007-01-26 19:40:31 +08:00
|
|
|
/* return a device pointer linked to each sound device as a parent */
|
|
|
|
|
static inline struct device *snd_card_get_device_link(struct snd_card *card)
|
|
|
|
|
{
|
2014-01-29 18:46:11 +08:00
|
|
|
return card ? &card->card_dev : NULL;
|
2007-01-26 19:40:31 +08:00
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* sound.c */
|
|
|
|
|
|
2005-10-24 23:05:03 +08:00
|
|
|
extern int snd_major;
|
2005-04-17 06:20:36 +08:00
|
|
|
extern int snd_ecards_limit;
|
2006-08-08 13:19:37 +08:00
|
|
|
extern struct class *sound_class;
|
ALSA: jack: implement software jack injection via debugfs
This change adds audio jack injection feature through debugfs, with
this feature, we could validate alsa userspace changes by injecting
plugin or plugout events to the non-phantom audio jacks.
With this change, the sound core will build the folders
$debugfs_mount_dir/sound/cardN if SND_DEBUG and DEBUG_FS are enabled.
And if users also enable the SND_JACK_INJECTION_DEBUG, the jack
injection nodes will be built in the folder cardN like below:
$tree $debugfs_mount_dir/sound
$debugfs_mount_dir/sound
├── card0
│ ├── HDMI_DP_pcm_10_Jack
│ │ ├── jackin_inject
│ │ ├── kctl_id
│ │ ├── mask_bits
│ │ ├── status
│ │ ├── sw_inject_enable
│ │ └── type
...
│ └── HDMI_DP_pcm_9_Jack
│ ├── jackin_inject
│ ├── kctl_id
│ ├── mask_bits
│ ├── status
│ ├── sw_inject_enable
│ └── type
└── card1
├── HDMI_DP_pcm_5_Jack
│ ├── jackin_inject
│ ├── kctl_id
│ ├── mask_bits
│ ├── status
│ ├── sw_inject_enable
│ └── type
...
├── Headphone_Jack
│ ├── jackin_inject
│ ├── kctl_id
│ ├── mask_bits
│ ├── status
│ ├── sw_inject_enable
│ └── type
└── Headset_Mic_Jack
├── jackin_inject
├── kctl_id
├── mask_bits
├── status
├── sw_inject_enable
└── type
The nodes kctl_id, mask_bits, status and type are read-only, users
could check jack or jack_kctl's information through them.
The nodes sw_inject_enable and jackin_inject are directly used for
injection. The sw_inject_enable is read-write, users could check if
software injection is enabled or not on this jack, and users could
echo 1 or 0 to enable or disable software injection on this jack. Once
the injection is enabled, the jack will not change by hardware events
anymore, once the injection is disabled, the jack will restore the
last reported hardware events to the jack. The jackin_inject is
write-only, if the injection is enabled, users could echo 1 or 0 to
this node to inject plugin or plugout events to this jack.
For the detailed usage information on these nodes, please refer to
Documentation/sound/designs/jack-injection.rst.
Reviewed-by: Takashi Iwai <tiwai@suse.de>
Reviewed-by: Jaroslav Kysela <perex@perex.cz>
Reviewed-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>
Signed-off-by: Hui Wang <hui.wang@canonical.com>
Link: https://lore.kernel.org/r/20210127085639.74954-2-hui.wang@canonical.com
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2021-01-27 16:56:39 +08:00
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
|
extern struct dentry *sound_debugfs_root;
|
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
void snd_request_card(int card);
|
|
|
|
|
|
2015-01-30 04:32:47 +08:00
|
|
|
void snd_device_initialize(struct device *dev, struct snd_card *card);
|
|
|
|
|
|
2015-01-30 15:34:58 +08:00
|
|
|
int snd_register_device(int type, struct snd_card *card, int dev,
|
|
|
|
|
const struct file_operations *f_ops,
|
|
|
|
|
void *private_data, struct device *device);
|
|
|
|
|
int snd_unregister_device(struct device *dev);
|
2005-11-20 21:06:59 +08:00
|
|
|
void *snd_lookup_minor_data(unsigned int minor, int type);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_SND_OSSEMUL
|
2005-11-20 21:03:48 +08:00
|
|
|
int snd_register_oss_device(int type, struct snd_card *card, int dev,
|
2014-02-04 20:51:45 +08:00
|
|
|
const struct file_operations *f_ops, void *private_data);
|
2005-11-17 20:51:18 +08:00
|
|
|
int snd_unregister_oss_device(int type, struct snd_card *card, int dev);
|
2005-11-20 21:06:59 +08:00
|
|
|
void *snd_lookup_oss_minor_data(unsigned int minor, int type);
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
int snd_minor_info_init(void);
|
|
|
|
|
|
|
|
|
|
/* sound_oss.c */
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SND_OSSEMUL
|
|
|
|
|
int snd_minor_info_oss_init(void);
|
|
|
|
|
#else
|
2008-04-15 00:31:35 +08:00
|
|
|
static inline int snd_minor_info_oss_init(void) { return 0; }
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* memory.c */
|
|
|
|
|
|
|
|
|
|
int copy_to_user_fromio(void __user *dst, const volatile void __iomem *src, size_t count);
|
|
|
|
|
int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size_t count);
|
|
|
|
|
|
|
|
|
|
/* init.c */
|
|
|
|
|
|
2006-05-16 01:49:05 +08:00
|
|
|
int snd_card_locked(int card);
|
2017-05-12 17:44:03 +08:00
|
|
|
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
2005-04-17 06:20:36 +08:00
|
|
|
#define SND_MIXER_OSS_NOTIFY_REGISTER 0
|
|
|
|
|
#define SND_MIXER_OSS_NOTIFY_DISCONNECT 1
|
|
|
|
|
#define SND_MIXER_OSS_NOTIFY_FREE 2
|
2005-11-17 20:51:18 +08:00
|
|
|
extern int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int cmd);
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
2014-01-29 19:51:12 +08:00
|
|
|
int snd_card_new(struct device *parent, int idx, const char *xid,
|
|
|
|
|
struct module *module, int extra_size,
|
|
|
|
|
struct snd_card **card_ret);
|
ALSA: core: Add managed card creation
As a second step for preliminary to widen the devres usages among
sound drivers, this patch adds a new ALSA core API function,
snd_devm_card_new(), to create a snd_card object via devres.
When a card object is created by this new function, snd_card_free() is
called automatically and the card object resource gets released at the
device unbinding time.
However, the story isn't that simple. A caveat is that we have to
call snd_card_free() at the very first of the whole resource release
procedure, in order to assure that the all exposed devices on
user-space are deleted and sync with processes accessing those devices
before releasing resources.
For achieving it, snd_card_register() adds a new devres action to
trigger snd_card_free() automatically when the given card object is a
"managed" one. Since usually snd_card_register() is the last step of
the initialization, this should work in most cases.
With all these tricks, some drivers can get rid of the whole driver
remove callback code.
About a bit of implementation details: the patch adds two new flags to
snd_card object: managed and releasing. The former indicates that the
object was created via snd_devm_card_new(), and the latter is used for
avoiding the double-free of snd_card_free() calls. Both flags are
fairly internal and likely uninteresting to normal users.
Link: https://lore.kernel.org/r/20210715075941.23332-3-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2021-07-15 15:58:24 +08:00
|
|
|
int snd_devm_card_new(struct device *parent, int idx, const char *xid,
|
|
|
|
|
struct module *module, size_t extra_size,
|
|
|
|
|
struct snd_card **card_ret);
|
2014-01-29 19:51:12 +08:00
|
|
|
|
2005-11-17 20:51:18 +08:00
|
|
|
int snd_card_disconnect(struct snd_card *card);
|
ALSA: add snd_card_disconnect_sync()
In case of user unbind ALSA driver during playing back / capturing,
each driver needs to stop and remove it correctly. One note here is
that we can't cancel from remove function in such case, because
unbind operation doesn't check return value from remove function.
So, we *must* stop and remove in this case.
For this purpose, we need to sync (= wait) until the all top-level
operations are canceled at remove function.
For example, snd_card_free() processes the disconnection procedure at
first, then waits for the completion. That's how the hot-unplug works
safely. It's implemented, at least, in the top-level driver removal.
Now for the lower level driver, we need a similar strategy. Notify to
the toplevel for hot-unplug (disconnect in ALSA), and sync with the
stop operation, then continue the rest of its own remove procedure.
This patch adds snd_card_disconnect_sync(), and driver can use it from
remove function.
Note: the "lower level" driver here refers to a middle layer driver
(e.g. ASoC components) that can be unbound freely during operation.
Most of legacy ALSA helper drivers don't have such a problem because
they can't be unbound.
Note#2: snd_card_disconnect_sync() merely calls snd_card_disconnect()
and syncs with closing all pending files. It takes only the files
opened by user-space into account, and doesn't care about object
refcounts. (The latter is handled by snd_card_free() completion call,
BTW.) Also, the function doesn't free resources by itself.
Tested-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2017-10-11 14:36:13 +08:00
|
|
|
void snd_card_disconnect_sync(struct snd_card *card);
|
2005-11-17 20:51:18 +08:00
|
|
|
int snd_card_free(struct snd_card *card);
|
2006-06-23 20:38:23 +08:00
|
|
|
int snd_card_free_when_closed(struct snd_card *card);
|
2009-06-02 18:02:38 +08:00
|
|
|
void snd_card_set_id(struct snd_card *card, const char *id);
|
2005-11-17 20:51:18 +08:00
|
|
|
int snd_card_register(struct snd_card *card);
|
2005-04-17 06:20:36 +08:00
|
|
|
int snd_card_info_init(void);
|
2015-01-30 19:27:43 +08:00
|
|
|
int snd_card_add_dev_attr(struct snd_card *card,
|
|
|
|
|
const struct attribute_group *group);
|
2005-11-17 20:51:18 +08:00
|
|
|
int snd_component_add(struct snd_card *card, const char *component);
|
|
|
|
|
int snd_card_file_add(struct snd_card *card, struct file *file);
|
|
|
|
|
int snd_card_file_remove(struct snd_card *card, struct file *file);
|
2019-04-17 00:18:47 +08:00
|
|
|
|
|
|
|
|
struct snd_card *snd_card_ref(int card);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* snd_card_unref - Unreference the card object
|
|
|
|
|
* @card: the card object to unreference
|
|
|
|
|
*
|
|
|
|
|
* Call this function for the card object that was obtained via snd_card_ref()
|
|
|
|
|
* or snd_lookup_minor_data().
|
|
|
|
|
*/
|
|
|
|
|
static inline void snd_card_unref(struct snd_card *card)
|
|
|
|
|
{
|
|
|
|
|
put_device(&card->card_dev);
|
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-04-01 21:33:22 +08:00
|
|
|
#define snd_card_set_dev(card, devptr) ((card)->dev = (devptr))
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* device.c */
|
|
|
|
|
|
2014-01-29 22:13:33 +08:00
|
|
|
int snd_device_new(struct snd_card *card, enum snd_device_type type,
|
2020-01-03 16:16:19 +08:00
|
|
|
void *device_data, const struct snd_device_ops *ops);
|
2005-11-17 20:51:18 +08:00
|
|
|
int snd_device_register(struct snd_card *card, void *device_data);
|
|
|
|
|
int snd_device_register_all(struct snd_card *card);
|
2015-02-28 01:01:22 +08:00
|
|
|
void snd_device_disconnect(struct snd_card *card, void *device_data);
|
|
|
|
|
void snd_device_disconnect_all(struct snd_card *card);
|
2014-02-04 18:36:11 +08:00
|
|
|
void snd_device_free(struct snd_card *card, void *device_data);
|
|
|
|
|
void snd_device_free_all(struct snd_card *card);
|
2020-03-24 01:06:42 +08:00
|
|
|
int snd_device_get_state(struct snd_card *card, void *device_data);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* isadma.c */
|
|
|
|
|
|
2005-08-24 05:45:06 +08:00
|
|
|
#ifdef CONFIG_ISA_DMA_API
|
2005-04-17 06:20:36 +08:00
|
|
|
#define DMA_MODE_NO_ENABLE 0x0100
|
|
|
|
|
|
|
|
|
|
void snd_dma_program(unsigned long dma, unsigned long addr, unsigned int size, unsigned short mode);
|
|
|
|
|
void snd_dma_disable(unsigned long dma);
|
|
|
|
|
unsigned int snd_dma_pointer(unsigned long dma, unsigned int size);
|
2021-07-15 15:58:25 +08:00
|
|
|
int snd_devm_request_dma(struct device *dev, int dma, const char *name);
|
2005-08-24 05:45:06 +08:00
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* misc.c */
|
2005-10-11 23:28:58 +08:00
|
|
|
struct resource;
|
2005-10-10 17:56:31 +08:00
|
|
|
void release_and_free_resource(struct resource *res);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* --- */
|
|
|
|
|
|
2012-04-10 17:00:35 +08:00
|
|
|
/* sound printk debug levels */
|
|
|
|
|
enum {
|
|
|
|
|
SND_PR_ALWAYS,
|
|
|
|
|
SND_PR_DEBUG,
|
|
|
|
|
SND_PR_VERBOSE,
|
|
|
|
|
};
|
|
|
|
|
|
2009-08-27 22:45:07 +08:00
|
|
|
#if defined(CONFIG_SND_DEBUG) || defined(CONFIG_SND_VERBOSE_PRINTK)
|
2011-11-01 08:11:33 +08:00
|
|
|
__printf(4, 5)
|
2009-08-27 22:45:07 +08:00
|
|
|
void __snd_printk(unsigned int level, const char *file, int line,
|
2011-11-01 08:11:33 +08:00
|
|
|
const char *format, ...);
|
2009-08-27 22:45:07 +08:00
|
|
|
#else
|
2016-11-15 05:25:33 +08:00
|
|
|
#define __snd_printk(level, file, line, format, ...) \
|
|
|
|
|
printk(format, ##__VA_ARGS__)
|
2009-08-27 22:45:07 +08:00
|
|
|
#endif
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
|
* snd_printk - printk wrapper
|
|
|
|
|
* @fmt: format string
|
|
|
|
|
*
|
2008-11-07 16:37:22 +08:00
|
|
|
* Works like printk() but prints the file and the line of the caller
|
2005-04-17 06:20:36 +08:00
|
|
|
* when configured with CONFIG_SND_VERBOSE_PRINTK.
|
|
|
|
|
*/
|
2016-11-15 05:25:33 +08:00
|
|
|
#define snd_printk(fmt, ...) \
|
|
|
|
|
__snd_printk(0, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
|
/**
|
|
|
|
|
* snd_printd - debug printk
|
2006-01-10 12:53:55 +08:00
|
|
|
* @fmt: format string
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2008-04-01 21:33:22 +08:00
|
|
|
* Works like snd_printk() for debugging purposes.
|
2005-04-17 06:20:36 +08:00
|
|
|
* Ignored when CONFIG_SND_DEBUG is not set.
|
|
|
|
|
*/
|
2016-11-15 05:25:33 +08:00
|
|
|
#define snd_printd(fmt, ...) \
|
|
|
|
|
__snd_printk(1, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
|
|
|
|
|
#define _snd_printd(level, fmt, ...) \
|
|
|
|
|
__snd_printk(level, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
|
2005-10-10 17:46:31 +08:00
|
|
|
|
2008-11-07 16:37:22 +08:00
|
|
|
/**
|
|
|
|
|
* snd_BUG - give a BUG warning message and stack trace
|
|
|
|
|
*
|
|
|
|
|
* Calls WARN() if CONFIG_SND_DEBUG is set.
|
|
|
|
|
* Ignored when CONFIG_SND_DEBUG is not set.
|
|
|
|
|
*/
|
2008-08-08 23:18:08 +08:00
|
|
|
#define snd_BUG() WARN(1, "BUG?\n")
|
2008-11-07 16:37:22 +08:00
|
|
|
|
2013-08-17 01:18:59 +08:00
|
|
|
/**
|
2020-10-24 00:33:35 +08:00
|
|
|
* snd_printd_ratelimit - Suppress high rates of output when
|
|
|
|
|
* CONFIG_SND_DEBUG is enabled.
|
2013-08-17 01:18:59 +08:00
|
|
|
*/
|
|
|
|
|
#define snd_printd_ratelimit() printk_ratelimit()
|
|
|
|
|
|
2008-11-07 16:37:22 +08:00
|
|
|
/**
|
|
|
|
|
* snd_BUG_ON - debugging check macro
|
|
|
|
|
* @cond: condition to evaluate
|
|
|
|
|
*
|
2013-03-05 06:02:59 +08:00
|
|
|
* Has the same behavior as WARN_ON when CONFIG_SND_DEBUG is set,
|
|
|
|
|
* otherwise just evaluates the conditional and returns the value.
|
2008-11-07 16:37:22 +08:00
|
|
|
*/
|
2013-03-05 06:02:59 +08:00
|
|
|
#define snd_BUG_ON(cond) WARN_ON((cond))
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
#else /* !CONFIG_SND_DEBUG */
|
|
|
|
|
|
2013-01-25 17:54:07 +08:00
|
|
|
__printf(1, 2)
|
|
|
|
|
static inline void snd_printd(const char *format, ...) {}
|
|
|
|
|
__printf(2, 3)
|
|
|
|
|
static inline void _snd_printd(int level, const char *format, ...) {}
|
|
|
|
|
|
2008-11-07 04:05:21 +08:00
|
|
|
#define snd_BUG() do { } while (0)
|
2013-03-05 06:02:59 +08:00
|
|
|
|
|
|
|
|
#define snd_BUG_ON(condition) ({ \
|
|
|
|
|
int __ret_warn_on = !!(condition); \
|
|
|
|
|
unlikely(__ret_warn_on); \
|
|
|
|
|
})
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-17 01:18:59 +08:00
|
|
|
static inline bool snd_printd_ratelimit(void) { return false; }
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif /* CONFIG_SND_DEBUG */
|
|
|
|
|
|
2008-05-20 18:15:15 +08:00
|
|
|
#ifdef CONFIG_SND_DEBUG_VERBOSE
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
|
* snd_printdd - debug printk
|
|
|
|
|
* @format: format string
|
|
|
|
|
*
|
2008-04-01 21:33:22 +08:00
|
|
|
* Works like snd_printk() for debugging purposes.
|
2008-05-20 18:15:15 +08:00
|
|
|
* Ignored when CONFIG_SND_DEBUG_VERBOSE is not set.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2016-11-15 05:25:33 +08:00
|
|
|
#define snd_printdd(format, ...) \
|
|
|
|
|
__snd_printk(2, __FILE__, __LINE__, format, ##__VA_ARGS__)
|
2005-04-17 06:20:36 +08:00
|
|
|
#else
|
2013-01-25 17:54:07 +08:00
|
|
|
__printf(1, 2)
|
|
|
|
|
static inline void snd_printdd(const char *format, ...) {}
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define SNDRV_OSS_VERSION ((3<<16)|(8<<8)|(1<<4)|(0)) /* 3.8.1a */
|
|
|
|
|
|
|
|
|
|
/* for easier backward-porting */
|
2017-05-12 17:44:03 +08:00
|
|
|
#if IS_ENABLED(CONFIG_GAMEPORT)
|
2005-04-17 06:20:36 +08:00
|
|
|
#define gameport_set_dev_parent(gp,xdev) ((gp)->dev.parent = (xdev))
|
|
|
|
|
#define gameport_set_port_data(gp,r) ((gp)->port_data = (r))
|
|
|
|
|
#define gameport_get_port_data(gp) (gp)->port_data
|
|
|
|
|
#endif
|
|
|
|
|
|
2006-11-24 22:34:06 +08:00
|
|
|
/* PCI quirk list helper */
|
|
|
|
|
struct snd_pci_quirk {
|
|
|
|
|
unsigned short subvendor; /* PCI subvendor ID */
|
|
|
|
|
unsigned short subdevice; /* PCI subdevice ID */
|
2009-01-31 00:27:45 +08:00
|
|
|
unsigned short subdevice_mask; /* bitmask to match */
|
2006-11-24 22:34:06 +08:00
|
|
|
int value; /* value */
|
2008-05-20 18:15:15 +08:00
|
|
|
#ifdef CONFIG_SND_DEBUG_VERBOSE
|
2006-11-24 22:34:06 +08:00
|
|
|
const char *name; /* name of the device (optional) */
|
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
2009-01-31 00:27:45 +08:00
|
|
|
#define _SND_PCI_QUIRK_ID_MASK(vend, mask, dev) \
|
|
|
|
|
.subvendor = (vend), .subdevice = (dev), .subdevice_mask = (mask)
|
|
|
|
|
#define _SND_PCI_QUIRK_ID(vend, dev) \
|
|
|
|
|
_SND_PCI_QUIRK_ID_MASK(vend, 0xffff, dev)
|
2006-11-24 22:34:06 +08:00
|
|
|
#define SND_PCI_QUIRK_ID(vend,dev) {_SND_PCI_QUIRK_ID(vend, dev)}
|
2008-05-20 18:15:15 +08:00
|
|
|
#ifdef CONFIG_SND_DEBUG_VERBOSE
|
2006-11-24 22:34:06 +08:00
|
|
|
#define SND_PCI_QUIRK(vend,dev,xname,val) \
|
|
|
|
|
{_SND_PCI_QUIRK_ID(vend, dev), .value = (val), .name = (xname)}
|
2009-01-31 00:27:45 +08:00
|
|
|
#define SND_PCI_QUIRK_VENDOR(vend, xname, val) \
|
|
|
|
|
{_SND_PCI_QUIRK_ID_MASK(vend, 0, 0), .value = (val), .name = (xname)}
|
|
|
|
|
#define SND_PCI_QUIRK_MASK(vend, mask, dev, xname, val) \
|
|
|
|
|
{_SND_PCI_QUIRK_ID_MASK(vend, mask, dev), \
|
|
|
|
|
.value = (val), .name = (xname)}
|
2013-01-25 17:54:07 +08:00
|
|
|
#define snd_pci_quirk_name(q) ((q)->name)
|
2006-11-24 22:34:06 +08:00
|
|
|
#else
|
|
|
|
|
#define SND_PCI_QUIRK(vend,dev,xname,val) \
|
|
|
|
|
{_SND_PCI_QUIRK_ID(vend, dev), .value = (val)}
|
2009-01-31 00:27:45 +08:00
|
|
|
#define SND_PCI_QUIRK_MASK(vend, mask, dev, xname, val) \
|
|
|
|
|
{_SND_PCI_QUIRK_ID_MASK(vend, mask, dev), .value = (val)}
|
|
|
|
|
#define SND_PCI_QUIRK_VENDOR(vend, xname, val) \
|
|
|
|
|
{_SND_PCI_QUIRK_ID_MASK(vend, 0, 0), .value = (val)}
|
2013-01-25 17:54:07 +08:00
|
|
|
#define snd_pci_quirk_name(q) ""
|
2006-11-24 22:34:06 +08:00
|
|
|
#endif
|
|
|
|
|
|
2014-03-01 07:41:31 +08:00
|
|
|
#ifdef CONFIG_PCI
|
2006-11-24 22:34:06 +08:00
|
|
|
const struct snd_pci_quirk *
|
|
|
|
|
snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list);
|
|
|
|
|
|
2010-01-14 16:16:52 +08:00
|
|
|
const struct snd_pci_quirk *
|
|
|
|
|
snd_pci_quirk_lookup_id(u16 vendor, u16 device,
|
|
|
|
|
const struct snd_pci_quirk *list);
|
2014-03-01 07:41:31 +08:00
|
|
|
#else
|
|
|
|
|
static inline const struct snd_pci_quirk *
|
|
|
|
|
snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list)
|
|
|
|
|
{
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline const struct snd_pci_quirk *
|
|
|
|
|
snd_pci_quirk_lookup_id(u16 vendor, u16 device,
|
|
|
|
|
const struct snd_pci_quirk *list)
|
|
|
|
|
{
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2012-01-30 17:10:58 +08:00
|
|
|
#endif
|
2006-11-24 22:34:06 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif /* __SOUND_CORE_H */
|