2019-05-27 06:55:05 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Initialization routines
|
2007-10-15 07:50:19 +00:00
|
|
|
* Copyright (c) by Jaroslav Kysela <perex@perex.cz>
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/sched.h>
|
2011-07-15 16:38:28 +00:00
|
|
|
#include <linux/module.h>
|
2012-01-22 16:23:42 +00:00
|
|
|
#include <linux/device.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/file.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/ctype.h>
|
|
|
|
#include <linux/pm.h>
|
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 08:56:39 +00:00
|
|
|
#include <linux/debugfs.h>
|
2014-01-29 11:13:43 +00:00
|
|
|
#include <linux/completion.h>
|
2021-02-06 20:36:53 +00:00
|
|
|
#include <linux/interrupt.h>
|
2005-10-29 18:07:23 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <sound/core.h>
|
|
|
|
#include <sound/control.h>
|
|
|
|
#include <sound/info.h>
|
|
|
|
|
2009-09-07 13:50:18 +00:00
|
|
|
/* monitor files for graceful shutdown (hotplug) */
|
|
|
|
struct snd_monitor_file {
|
|
|
|
struct file *file;
|
|
|
|
const struct file_operations *disconnected_f_op;
|
|
|
|
struct list_head shutdown_list; /* still need to shutdown */
|
|
|
|
struct list_head list; /* link of monitor files */
|
|
|
|
};
|
|
|
|
|
2006-10-06 14:08:27 +00:00
|
|
|
static DEFINE_SPINLOCK(shutdown_lock);
|
|
|
|
static LIST_HEAD(shutdown_files);
|
|
|
|
|
2007-02-12 08:55:37 +00:00
|
|
|
static const struct file_operations snd_shutdown_f_ops;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
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 06:46:39 +00:00
|
|
|
/* locked for registering/using */
|
|
|
|
static DECLARE_BITMAP(snd_cards_lock, SNDRV_CARDS);
|
2019-04-16 16:18:47 +00:00
|
|
|
static struct snd_card *snd_cards[SNDRV_CARDS];
|
2006-04-28 13:13:39 +00:00
|
|
|
|
2006-05-15 17:49:05 +00:00
|
|
|
static DEFINE_MUTEX(snd_card_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-10-26 13:10:15 +00:00
|
|
|
static char *slots[SNDRV_CARDS];
|
|
|
|
module_param_array(slots, charp, NULL, 0444);
|
|
|
|
MODULE_PARM_DESC(slots, "Module names assigned to the slots.");
|
|
|
|
|
2008-05-27 15:59:24 +00:00
|
|
|
/* return non-zero if the given index is reserved for the given
|
2007-10-26 13:10:15 +00:00
|
|
|
* module via slots option
|
|
|
|
*/
|
2008-05-27 15:59:24 +00:00
|
|
|
static int module_slot_match(struct module *module, int idx)
|
2007-10-26 13:10:15 +00:00
|
|
|
{
|
2008-05-27 15:59:24 +00:00
|
|
|
int match = 1;
|
2007-10-26 13:10:15 +00:00
|
|
|
#ifdef MODULE
|
2008-05-27 15:59:24 +00:00
|
|
|
const char *s1, *s2;
|
|
|
|
|
2013-10-28 11:54:52 +00:00
|
|
|
if (!module || !*module->name || !slots[idx])
|
2007-10-26 13:10:15 +00:00
|
|
|
return 0;
|
2008-05-27 15:59:24 +00:00
|
|
|
|
|
|
|
s1 = module->name;
|
|
|
|
s2 = slots[idx];
|
|
|
|
if (*s2 == '!') {
|
|
|
|
match = 0; /* negative match */
|
|
|
|
s2++;
|
|
|
|
}
|
2007-10-26 13:10:15 +00:00
|
|
|
/* compare module name strings
|
|
|
|
* hyphens are handled as equivalent with underscore
|
|
|
|
*/
|
|
|
|
for (;;) {
|
|
|
|
char c1 = *s1++;
|
|
|
|
char c2 = *s2++;
|
|
|
|
if (c1 == '-')
|
|
|
|
c1 = '_';
|
|
|
|
if (c2 == '-')
|
|
|
|
c2 = '_';
|
|
|
|
if (c1 != c2)
|
2008-05-27 15:59:24 +00:00
|
|
|
return !match;
|
2007-10-26 13:10:15 +00:00
|
|
|
if (!c1)
|
|
|
|
break;
|
|
|
|
}
|
2008-05-27 15:59:24 +00:00
|
|
|
#endif /* MODULE */
|
|
|
|
return match;
|
2007-10-26 13:10:15 +00:00
|
|
|
}
|
|
|
|
|
2014-02-10 08:48:47 +00:00
|
|
|
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
2005-11-17 12:51:18 +00:00
|
|
|
int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag);
|
2006-04-28 13:13:39 +00:00
|
|
|
EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
2014-01-23 10:02:15 +00:00
|
|
|
static int check_empty_slot(struct module *module, int slot)
|
|
|
|
{
|
|
|
|
return !slots[slot] || !*slots[slot];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* return an empty slot number (>= 0) found in the given bitmask @mask.
|
|
|
|
* @mask == -1 == 0xffffffff means: take any free slot up to 32
|
|
|
|
* when no slot is available, return the original @mask as is.
|
|
|
|
*/
|
|
|
|
static int get_slot_from_bitmask(int mask, int (*check)(struct module *, int),
|
|
|
|
struct module *module)
|
|
|
|
{
|
|
|
|
int slot;
|
|
|
|
|
|
|
|
for (slot = 0; slot < SNDRV_CARDS; slot++) {
|
|
|
|
if (slot < 32 && !(mask & (1U << slot)))
|
|
|
|
continue;
|
|
|
|
if (!test_bit(slot, snd_cards_lock)) {
|
|
|
|
if (check(module, slot))
|
|
|
|
return slot; /* found */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return mask; /* unchanged */
|
|
|
|
}
|
|
|
|
|
2023-08-16 16:02:44 +00:00
|
|
|
/* the default release callback set in snd_device_alloc() */
|
|
|
|
static void default_release_alloc(struct device *dev)
|
|
|
|
{
|
|
|
|
kfree(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_device_alloc - Allocate and initialize struct device for sound devices
|
|
|
|
* @dev_p: pointer to store the allocated device
|
|
|
|
* @card: card to assign, optional
|
|
|
|
*
|
|
|
|
* For releasing the allocated device, call put_device().
|
|
|
|
*/
|
|
|
|
int snd_device_alloc(struct device **dev_p, struct snd_card *card)
|
|
|
|
{
|
|
|
|
struct device *dev;
|
|
|
|
|
|
|
|
*dev_p = NULL;
|
|
|
|
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
|
|
|
|
if (!dev)
|
|
|
|
return -ENOMEM;
|
|
|
|
device_initialize(dev);
|
|
|
|
if (card)
|
|
|
|
dev->parent = &card->card_dev;
|
|
|
|
dev->class = &sound_class;
|
|
|
|
dev->release = default_release_alloc;
|
|
|
|
*dev_p = dev;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_device_alloc);
|
|
|
|
|
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 07:58:24 +00:00
|
|
|
static int snd_card_init(struct snd_card *card, struct device *parent,
|
|
|
|
int idx, const char *xid, struct module *module,
|
|
|
|
size_t extra_size);
|
2014-01-29 10:46:11 +00:00
|
|
|
static int snd_card_do_free(struct snd_card *card);
|
2015-01-30 11:27:43 +00:00
|
|
|
static const struct attribute_group card_dev_attr_group;
|
2014-01-29 10:46:11 +00:00
|
|
|
|
|
|
|
static void release_card_device(struct device *dev)
|
|
|
|
{
|
|
|
|
snd_card_do_free(dev_to_snd_card(dev));
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2014-01-29 11:51:12 +00:00
|
|
|
* snd_card_new - create and initialize a soundcard structure
|
|
|
|
* @parent: the parent device object
|
2005-04-16 22:20:36 +00:00
|
|
|
* @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
|
|
|
|
* @xid: card identification (ASCII string)
|
|
|
|
* @module: top level module for locking
|
|
|
|
* @extra_size: allocate this extra size after the main soundcard structure
|
2008-12-28 15:32:08 +00:00
|
|
|
* @card_ret: the pointer to store the created card instance
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-12-28 15:32:08 +00:00
|
|
|
* The function allocates snd_card instance via kzalloc with the given
|
|
|
|
* space for the driver to use freely. The allocated struct is stored
|
|
|
|
* in the given card_ret pointer.
|
|
|
|
*
|
2013-03-11 21:05:14 +00:00
|
|
|
* Return: Zero if successful or a negative error code.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2014-01-29 11:51:12 +00:00
|
|
|
int snd_card_new(struct device *parent, int idx, const char *xid,
|
2008-12-28 15:32:08 +00:00
|
|
|
struct module *module, int extra_size,
|
|
|
|
struct snd_card **card_ret)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-11-17 12:51:18 +00:00
|
|
|
struct snd_card *card;
|
2014-01-23 10:02:15 +00:00
|
|
|
int err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-28 15:32:08 +00:00
|
|
|
if (snd_BUG_ON(!card_ret))
|
|
|
|
return -EINVAL;
|
|
|
|
*card_ret = NULL;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (extra_size < 0)
|
|
|
|
extra_size = 0;
|
2005-09-09 12:20:23 +00:00
|
|
|
card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
|
2008-12-28 15:32:08 +00:00
|
|
|
if (!card)
|
|
|
|
return -ENOMEM;
|
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 07:58:24 +00:00
|
|
|
|
|
|
|
err = snd_card_init(card, parent, idx, xid, module, extra_size);
|
2022-09-19 12:35:16 +00:00
|
|
|
if (err < 0)
|
|
|
|
return err; /* card is freed by error handler */
|
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 07:58:24 +00:00
|
|
|
|
|
|
|
*card_ret = card;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(snd_card_new);
|
|
|
|
|
|
|
|
static void __snd_card_release(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
snd_card_free(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_devm_card_new - managed snd_card object creation
|
|
|
|
* @parent: the parent device object
|
|
|
|
* @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
|
|
|
|
* @xid: card identification (ASCII string)
|
|
|
|
* @module: top level module for locking
|
|
|
|
* @extra_size: allocate this extra size after the main soundcard structure
|
|
|
|
* @card_ret: the pointer to store the created card instance
|
|
|
|
*
|
|
|
|
* This function works like snd_card_new() but manages the allocated resource
|
|
|
|
* via devres, i.e. you don't need to free explicitly.
|
|
|
|
*
|
|
|
|
* When a snd_card object is created with this function and registered via
|
|
|
|
* snd_card_register(), the very first devres action to call snd_card_free()
|
|
|
|
* is added automatically. In that way, the resource disconnection is assured
|
|
|
|
* at first, then released in the expected order.
|
2022-04-12 09:31:40 +00:00
|
|
|
*
|
|
|
|
* If an error happens at the probe before snd_card_register() is called and
|
|
|
|
* there have been other devres resources, you'd need to free the card manually
|
|
|
|
* via snd_card_free() call in the error; otherwise it may lead to UAF due to
|
|
|
|
* devres call orders. You can use snd_card_free_on_error() helper for
|
|
|
|
* handling it more easily.
|
2022-07-13 10:47:59 +00:00
|
|
|
*
|
|
|
|
* Return: zero if successful, or a negative error code
|
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 07:58:24 +00: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)
|
|
|
|
{
|
|
|
|
struct snd_card *card;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
*card_ret = NULL;
|
|
|
|
card = devres_alloc(__snd_card_release, sizeof(*card) + extra_size,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!card)
|
|
|
|
return -ENOMEM;
|
|
|
|
card->managed = true;
|
|
|
|
err = snd_card_init(card, parent, idx, xid, module, extra_size);
|
|
|
|
if (err < 0) {
|
2022-09-19 12:35:16 +00:00
|
|
|
devres_free(card); /* in managed mode, we need to free manually */
|
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 07:58:24 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
devres_add(parent, card);
|
|
|
|
*card_ret = card;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_devm_card_new);
|
|
|
|
|
2022-04-12 09:31:40 +00:00
|
|
|
/**
|
|
|
|
* snd_card_free_on_error - a small helper for handling devm probe errors
|
|
|
|
* @dev: the managed device object
|
|
|
|
* @ret: the return code from the probe callback
|
|
|
|
*
|
|
|
|
* This function handles the explicit snd_card_free() call at the error from
|
|
|
|
* the probe callback. It's just a small helper for simplifying the error
|
|
|
|
* handling with the managed devices.
|
2022-07-13 10:47:59 +00:00
|
|
|
*
|
|
|
|
* Return: zero if successful, or a negative error code
|
2022-04-12 09:31:40 +00:00
|
|
|
*/
|
|
|
|
int snd_card_free_on_error(struct device *dev, int ret)
|
|
|
|
{
|
|
|
|
struct snd_card *card;
|
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
return 0;
|
|
|
|
card = devres_find(dev, __snd_card_release, NULL, NULL);
|
|
|
|
if (card)
|
|
|
|
snd_card_free(card);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_card_free_on_error);
|
|
|
|
|
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 07:58:24 +00:00
|
|
|
static int snd_card_init(struct snd_card *card, struct device *parent,
|
|
|
|
int idx, const char *xid, struct module *module,
|
|
|
|
size_t extra_size)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2014-01-29 10:46:11 +00:00
|
|
|
if (extra_size > 0)
|
|
|
|
card->private_data = (char *)card + sizeof(struct snd_card);
|
2009-06-02 10:02:38 +00:00
|
|
|
if (xid)
|
ALSA: Convert strlcpy to strscpy when return value is unused
strlcpy is deprecated. see: Documentation/process/deprecated.rst
Change the calls that do not use the strlcpy return value to the
preferred strscpy.
Done with cocci script:
@@
expression e1, e2, e3;
@@
- strlcpy(
+ strscpy(
e1, e2, e3);
This cocci script leaves the instances where the return value is
used unchanged.
After this patch, sound/ has 3 uses of strlcpy() that need to be
manually inspected for conversion and changed one day.
$ git grep -w strlcpy sound/
sound/usb/card.c: len = strlcpy(card->longname, s, sizeof(card->longname));
sound/usb/mixer.c: return strlcpy(buf, p->name, buflen);
sound/usb/mixer.c: return strlcpy(buf, p->names[index], buflen);
Miscellenea:
o Remove trailing whitespace in conversion of sound/core/hwdep.c
Link: https://lore.kernel.org/lkml/CAHk-=wgfRnXz0W3D37d01q3JFkr_i_uTL=V6A6G1oUZcprmknw@mail.gmail.com/
Signed-off-by: Joe Perches <joe@perches.com>
Acked-by: Mark Brown <broonie@kernel.org>
Link: https://lore.kernel.org/r/22b393d1790bb268769d0bab7bacf0866dcb0c14.camel@perches.com
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2021-01-04 17:17:34 +00:00
|
|
|
strscpy(card->id, xid, sizeof(card->id));
|
2005-04-16 22:20:36 +00:00
|
|
|
err = 0;
|
2006-05-15 17:49:05 +00:00
|
|
|
mutex_lock(&snd_card_mutex);
|
2014-01-23 10:02:15 +00:00
|
|
|
if (idx < 0) /* first check the matching module-name slot */
|
|
|
|
idx = get_slot_from_bitmask(idx, module_slot_match, module);
|
|
|
|
if (idx < 0) /* if not matched, assign an empty slot */
|
|
|
|
idx = get_slot_from_bitmask(idx, check_empty_slot, module);
|
2008-05-27 15:59:24 +00:00
|
|
|
if (idx < 0)
|
|
|
|
err = -ENODEV;
|
|
|
|
else if (idx < snd_ecards_limit) {
|
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 06:46:39 +00:00
|
|
|
if (test_bit(idx, snd_cards_lock))
|
2008-05-27 15:59:24 +00:00
|
|
|
err = -EBUSY; /* invalid */
|
|
|
|
} else if (idx >= SNDRV_CARDS)
|
|
|
|
err = -ENODEV;
|
|
|
|
if (err < 0) {
|
2006-05-15 17:49:05 +00:00
|
|
|
mutex_unlock(&snd_card_mutex);
|
2014-02-04 17:21:03 +00:00
|
|
|
dev_err(parent, "cannot find the slot for index %d (range 0-%i), error: %d\n",
|
2007-01-16 16:49:21 +00:00
|
|
|
idx, snd_ecards_limit - 1, err);
|
2022-09-19 12:35:16 +00:00
|
|
|
if (!card->managed)
|
|
|
|
kfree(card); /* manually free here, as no destructor called */
|
2014-01-29 10:46:11 +00:00
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
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 06:46:39 +00:00
|
|
|
set_bit(idx, snd_cards_lock); /* lock it */
|
2008-05-27 15:59:24 +00:00
|
|
|
if (idx >= snd_ecards_limit)
|
|
|
|
snd_ecards_limit = idx + 1; /* increase the limit */
|
2006-05-15 17:49:05 +00:00
|
|
|
mutex_unlock(&snd_card_mutex);
|
2014-01-29 11:51:12 +00:00
|
|
|
card->dev = parent;
|
2005-04-16 22:20:36 +00:00
|
|
|
card->number = idx;
|
2020-06-24 16:03:00 +00:00
|
|
|
#ifdef MODULE
|
|
|
|
WARN_ON(!module);
|
2005-04-16 22:20:36 +00:00
|
|
|
card->module = module;
|
2020-06-24 16:03:00 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
INIT_LIST_HEAD(&card->devices);
|
|
|
|
init_rwsem(&card->controls_rwsem);
|
|
|
|
rwlock_init(&card->ctl_files_rwlock);
|
|
|
|
INIT_LIST_HEAD(&card->controls);
|
|
|
|
INIT_LIST_HEAD(&card->ctl_files);
|
ALSA: control: Use xarray for faster lookups
The control elements are managed in a single linked list and we
traverse the whole list for matching each numid or ctl id per every
inquiry of a control element. This is OK-ish for a small number of
elements but obviously it doesn't scale. Especially the matching with
the ctl id takes time because it checks each field of the snd_ctl_id
element, e.g. the name string is matched with strcmp().
This patch adds the hash tables with Xarray for improving the lookup
speed of a control element. There are two xarray tables added to the
card; one for numid and another for ctl id. For the numid, we use the
numid as the index, while for the ctl id, we calculate a hash key.
The lookup is done via a single xa_load() execution. As long as the
given control element is found on the Xarray table, that's fine, we
can give back a quick lookup result. The problem is when no entry
hits on the table, and for this case, we have a slight optimization.
Namely, the driver checks whether we had a collision on Xarray table,
and do a fallback search (linear lookup of the full entries) only if a
hash key collision happened beforehand.
So, in theory, the inquiry for a non-existing element might take still
time even with this patch in a worst case, but this must be pretty
rare.
The feature is enabled via CONFIG_SND_CTL_FAST_LOOKUP, which is turned
on as default. For simplicity, the option can be turned off only when
CONFIG_EXPERT is set ("You are expert? Then you manage 1000 knobs").
Link: https://lore.kernel.org/r/20211028130027.18764-1-tiwai@suse.de
Link: https://lore.kernel.org/r/20220609180504.775-1-tiwai@suse.de
Link: https://lore.kernel.org/all/cover.1653813866.git.quic_rbankapu@quicinc.com/
Link: https://lore.kernel.org/r/20220610064537.18660-1-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2022-06-10 06:45:37 +00:00
|
|
|
#ifdef CONFIG_SND_CTL_FAST_LOOKUP
|
|
|
|
xa_init(&card->ctl_numids);
|
|
|
|
xa_init(&card->ctl_hash);
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_init(&card->files_lock);
|
2009-02-23 15:35:21 +00:00
|
|
|
INIT_LIST_HEAD(&card->files_list);
|
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 12:44:22 +00:00
|
|
|
mutex_init(&card->memory_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
init_waitqueue_head(&card->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 09:09:16 +00:00
|
|
|
init_waitqueue_head(&card->power_ref_sleep);
|
|
|
|
atomic_set(&card->power_ref, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
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 06:36:13 +00:00
|
|
|
init_waitqueue_head(&card->remove_sleep);
|
2019-11-17 08:53:07 +00:00
|
|
|
card->sync_irq = -1;
|
2014-01-29 10:46:11 +00:00
|
|
|
|
|
|
|
device_initialize(&card->card_dev);
|
|
|
|
card->card_dev.parent = parent;
|
2023-06-20 17:56:34 +00:00
|
|
|
card->card_dev.class = &sound_class;
|
2014-01-29 10:46:11 +00:00
|
|
|
card->card_dev.release = release_card_device;
|
2015-01-30 11:27:43 +00:00
|
|
|
card->card_dev.groups = card->dev_groups;
|
|
|
|
card->dev_groups[0] = &card_dev_attr_group;
|
2014-01-29 10:46:11 +00:00
|
|
|
err = kobject_set_name(&card->card_dev.kobj, "card%d", idx);
|
|
|
|
if (err < 0)
|
|
|
|
goto __error;
|
|
|
|
|
2015-12-22 18:09:05 +00:00
|
|
|
snprintf(card->irq_descr, sizeof(card->irq_descr), "%s:%s",
|
|
|
|
dev_driver_string(card->dev), dev_name(&card->card_dev));
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* the control interface cannot be accessed from the user space until */
|
|
|
|
/* snd_cards_bitmask and snd_cards are set with snd_card_register */
|
2008-12-28 15:32:08 +00:00
|
|
|
err = snd_ctl_create(card);
|
|
|
|
if (err < 0) {
|
2014-02-04 17:21:03 +00:00
|
|
|
dev_err(parent, "unable to register control minors\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
goto __error;
|
|
|
|
}
|
2008-12-28 15:32:08 +00:00
|
|
|
err = snd_info_card_create(card);
|
|
|
|
if (err < 0) {
|
2014-02-04 17:21:03 +00:00
|
|
|
dev_err(parent, "unable to create card info\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
goto __error_ctl;
|
|
|
|
}
|
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 08:56:39 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_SND_DEBUG
|
2023-09-12 11:01:13 +00:00
|
|
|
card->debugfs_root = debugfs_create_dir(dev_name(&card->card_dev),
|
|
|
|
sound_debugfs_root);
|
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 08:56:39 +00:00
|
|
|
#endif
|
2008-12-28 15:32:08 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
__error_ctl:
|
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 14:53:35 +00:00
|
|
|
snd_device_free_all(card);
|
2005-04-16 22:20:36 +00:00
|
|
|
__error:
|
2014-01-29 10:46:11 +00:00
|
|
|
put_device(&card->card_dev);
|
2008-12-28 15:32:08 +00:00
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-04-28 13:13:39 +00:00
|
|
|
|
2019-04-16 16:18:47 +00:00
|
|
|
/**
|
|
|
|
* snd_card_ref - Get the card object from the index
|
|
|
|
* @idx: the card index
|
|
|
|
*
|
|
|
|
* Returns a card object corresponding to the given index or NULL if not found.
|
|
|
|
* Release the object via snd_card_unref().
|
2022-07-13 10:47:59 +00:00
|
|
|
*
|
|
|
|
* Return: a card object or NULL
|
2019-04-16 16:18:47 +00:00
|
|
|
*/
|
|
|
|
struct snd_card *snd_card_ref(int idx)
|
|
|
|
{
|
|
|
|
struct snd_card *card;
|
|
|
|
|
|
|
|
mutex_lock(&snd_card_mutex);
|
|
|
|
card = snd_cards[idx];
|
|
|
|
if (card)
|
|
|
|
get_device(&card->card_dev);
|
|
|
|
mutex_unlock(&snd_card_mutex);
|
|
|
|
return card;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_card_ref);
|
|
|
|
|
2006-05-15 17:49:05 +00:00
|
|
|
/* return non-zero if a card is already locked */
|
|
|
|
int snd_card_locked(int card)
|
|
|
|
{
|
|
|
|
int locked;
|
|
|
|
|
|
|
|
mutex_lock(&snd_card_mutex);
|
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 06:46:39 +00:00
|
|
|
locked = test_bit(card, snd_cards_lock);
|
2006-05-15 17:49:05 +00:00
|
|
|
mutex_unlock(&snd_card_mutex);
|
|
|
|
return locked;
|
|
|
|
}
|
|
|
|
|
2006-03-03 13:08:43 +00:00
|
|
|
static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig)
|
|
|
|
{
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t snd_disconnect_read(struct file *file, char __user *buf,
|
|
|
|
size_t count, loff_t *offset)
|
|
|
|
{
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t snd_disconnect_write(struct file *file, const char __user *buf,
|
|
|
|
size_t count, loff_t *offset)
|
|
|
|
{
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2006-10-06 14:08:27 +00:00
|
|
|
static int snd_disconnect_release(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct snd_monitor_file *df = NULL, *_df;
|
|
|
|
|
|
|
|
spin_lock(&shutdown_lock);
|
|
|
|
list_for_each_entry(_df, &shutdown_files, shutdown_list) {
|
|
|
|
if (_df->file == file) {
|
|
|
|
df = _df;
|
2009-02-23 15:35:21 +00:00
|
|
|
list_del_init(&df->shutdown_list);
|
2006-10-06 14:08:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&shutdown_lock);
|
|
|
|
|
2008-10-31 23:28:30 +00:00
|
|
|
if (likely(df)) {
|
|
|
|
if ((file->f_flags & FASYNC) && df->disconnected_f_op->fasync)
|
|
|
|
df->disconnected_f_op->fasync(-1, file, 0);
|
2006-10-06 14:08:27 +00:00
|
|
|
return df->disconnected_f_op->release(inode, file);
|
2008-10-31 23:28:30 +00:00
|
|
|
}
|
2006-10-06 14:08:27 +00:00
|
|
|
|
2008-03-03 23:32:18 +00:00
|
|
|
panic("%s(%p, %p) failed!", __func__, inode, file);
|
2006-10-06 14:08:27 +00:00
|
|
|
}
|
|
|
|
|
2017-07-03 03:27:36 +00:00
|
|
|
static __poll_t snd_disconnect_poll(struct file * file, poll_table * wait)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2018-02-11 22:34:03 +00:00
|
|
|
return EPOLLERR | EPOLLNVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-03-03 13:08:43 +00:00
|
|
|
static long snd_disconnect_ioctl(struct file *file,
|
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int snd_disconnect_fasync(int fd, struct file *file, int on)
|
|
|
|
{
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2007-02-12 08:55:37 +00:00
|
|
|
static const struct file_operations snd_shutdown_f_ops =
|
2006-10-06 14:08:27 +00:00
|
|
|
{
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.llseek = snd_disconnect_llseek,
|
|
|
|
.read = snd_disconnect_read,
|
|
|
|
.write = snd_disconnect_write,
|
|
|
|
.release = snd_disconnect_release,
|
|
|
|
.poll = snd_disconnect_poll,
|
|
|
|
.unlocked_ioctl = snd_disconnect_ioctl,
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
.compat_ioctl = snd_disconnect_ioctl,
|
|
|
|
#endif
|
|
|
|
.mmap = snd_disconnect_mmap,
|
|
|
|
.fasync = snd_disconnect_fasync
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* snd_card_disconnect - disconnect all APIs from the file-operations (user space)
|
|
|
|
* @card: soundcard structure
|
|
|
|
*
|
|
|
|
* Disconnects all APIs from the file-operations (user space).
|
|
|
|
*
|
2013-03-11 21:05:14 +00:00
|
|
|
* Return: Zero, otherwise a negative error code.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Note: The current implementation replaces all active file->f_op with special
|
|
|
|
* dummy file operations (they do nothing except release).
|
|
|
|
*/
|
2023-02-07 19:19:05 +00:00
|
|
|
void snd_card_disconnect(struct snd_card *card)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct snd_monitor_file *mfile;
|
|
|
|
|
2008-04-17 10:52:02 +00:00
|
|
|
if (!card)
|
2023-02-07 19:19:05 +00:00
|
|
|
return;
|
2008-04-17 10:52:02 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock(&card->files_lock);
|
|
|
|
if (card->shutdown) {
|
|
|
|
spin_unlock(&card->files_lock);
|
2023-02-07 19:19:05 +00:00
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
card->shutdown = 1;
|
|
|
|
|
2019-04-16 15:06:33 +00:00
|
|
|
/* replace file->f_op with special dummy operations */
|
2009-02-23 15:35:21 +00:00
|
|
|
list_for_each_entry(mfile, &card->files_list, list) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* it's critical part, use endless loop */
|
|
|
|
/* we have no room to fail */
|
2006-10-06 14:08:27 +00:00
|
|
|
mfile->disconnected_f_op = mfile->file->f_op;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-06 14:08:27 +00:00
|
|
|
spin_lock(&shutdown_lock);
|
|
|
|
list_add(&mfile->shutdown_list, &shutdown_files);
|
|
|
|
spin_unlock(&shutdown_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-06 14:08:27 +00:00
|
|
|
mfile->file->f_op = &snd_shutdown_f_ops;
|
2008-01-13 11:03:53 +00:00
|
|
|
fops_get(mfile->file->f_op);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
spin_unlock(&card->files_lock);
|
|
|
|
|
2019-04-16 15:06:33 +00:00
|
|
|
/* notify all connected devices about disconnection */
|
2005-04-16 22:20:36 +00:00
|
|
|
/* at this point, they cannot respond to any calls except release() */
|
|
|
|
|
2014-02-10 08:48:47 +00:00
|
|
|
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
2005-04-16 22:20:36 +00:00
|
|
|
if (snd_mixer_oss_notify_callback)
|
|
|
|
snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_DISCONNECT);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* notify all devices that we are disconnected */
|
2015-02-27 17:01:22 +00:00
|
|
|
snd_device_disconnect_all(card);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-02-06 20:36:53 +00:00
|
|
|
if (card->sync_irq > 0)
|
|
|
|
synchronize_irq(card->sync_irq);
|
|
|
|
|
2006-06-23 12:37:59 +00:00
|
|
|
snd_info_card_disconnect(card);
|
2014-01-29 10:46:11 +00:00
|
|
|
if (card->registered) {
|
|
|
|
device_del(&card->card_dev);
|
|
|
|
card->registered = false;
|
2008-04-17 10:50:47 +00:00
|
|
|
}
|
2019-04-16 15:06:33 +00:00
|
|
|
|
|
|
|
/* disable fops (user space) operations for ALSA API */
|
|
|
|
mutex_lock(&snd_card_mutex);
|
|
|
|
snd_cards[card->number] = NULL;
|
|
|
|
clear_bit(card->number, snd_cards_lock);
|
|
|
|
mutex_unlock(&snd_card_mutex);
|
|
|
|
|
2008-04-17 10:52:02 +00:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
wake_up(&card->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 09:09:16 +00:00
|
|
|
snd_power_sync_ref(card);
|
2008-04-17 10:50:47 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-04-28 13:13:39 +00:00
|
|
|
EXPORT_SYMBOL(snd_card_disconnect);
|
|
|
|
|
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 06:36:13 +00:00
|
|
|
/**
|
|
|
|
* snd_card_disconnect_sync - disconnect card and wait until files get closed
|
|
|
|
* @card: card object to disconnect
|
|
|
|
*
|
|
|
|
* This calls snd_card_disconnect() for disconnecting all belonging components
|
|
|
|
* and waits until all pending files get closed.
|
|
|
|
* It assures that all accesses from user-space finished so that the driver
|
|
|
|
* can release its resources gracefully.
|
|
|
|
*/
|
|
|
|
void snd_card_disconnect_sync(struct snd_card *card)
|
|
|
|
{
|
2023-02-07 19:19:05 +00:00
|
|
|
snd_card_disconnect(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 06:36:13 +00:00
|
|
|
|
|
|
|
spin_lock_irq(&card->files_lock);
|
|
|
|
wait_event_lock_irq(card->remove_sleep,
|
|
|
|
list_empty(&card->files_list),
|
|
|
|
card->files_lock);
|
|
|
|
spin_unlock_irq(&card->files_lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_card_disconnect_sync);
|
|
|
|
|
2006-06-23 12:38:23 +00:00
|
|
|
static int snd_card_do_free(struct snd_card *card)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
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 07:58:24 +00:00
|
|
|
card->releasing = true;
|
2014-02-10 08:48:47 +00:00
|
|
|
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
2005-04-16 22:20:36 +00:00
|
|
|
if (snd_mixer_oss_notify_callback)
|
|
|
|
snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
|
|
|
|
#endif
|
2014-02-04 10:36:11 +00:00
|
|
|
snd_device_free_all(card);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (card->private_free)
|
|
|
|
card->private_free(card);
|
|
|
|
if (snd_info_card_free(card) < 0) {
|
2014-02-04 17:21:03 +00:00
|
|
|
dev_warn(card->dev, "unable to free card info\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Not fatal error */
|
|
|
|
}
|
2021-02-02 22:56:29 +00:00
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
debugfs_remove(card->debugfs_root);
|
|
|
|
card->debugfs_root = NULL;
|
|
|
|
#endif
|
2014-01-29 11:13:43 +00:00
|
|
|
if (card->release_completion)
|
|
|
|
complete(card->release_completion);
|
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 07:58:24 +00:00
|
|
|
if (!card->managed)
|
|
|
|
kfree(card);
|
2006-06-23 12:38:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-10-30 14:19:43 +00:00
|
|
|
/**
|
|
|
|
* snd_card_free_when_closed - Disconnect the card, free it later eventually
|
|
|
|
* @card: soundcard structure
|
|
|
|
*
|
|
|
|
* Unlike snd_card_free(), this function doesn't try to release the card
|
|
|
|
* resource immediately, but tries to disconnect at first. When the card
|
|
|
|
* is still in use, the function returns before freeing the resources.
|
|
|
|
* The card resources will be freed when the refcount gets to zero.
|
2022-07-13 10:47:59 +00:00
|
|
|
*
|
|
|
|
* Return: zero if successful, or a negative error code
|
2014-10-30 14:19:43 +00:00
|
|
|
*/
|
2023-02-07 19:19:06 +00:00
|
|
|
void snd_card_free_when_closed(struct snd_card *card)
|
2006-06-23 12:38:23 +00:00
|
|
|
{
|
2023-02-07 19:19:05 +00:00
|
|
|
if (!card)
|
2023-02-07 19:19:06 +00:00
|
|
|
return;
|
2023-02-07 19:19:05 +00:00
|
|
|
|
|
|
|
snd_card_disconnect(card);
|
2014-01-29 11:13:43 +00:00
|
|
|
put_device(&card->card_dev);
|
2023-02-07 19:19:06 +00:00
|
|
|
return;
|
2006-06-23 12:38:23 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(snd_card_free_when_closed);
|
|
|
|
|
2014-10-30 14:19:43 +00:00
|
|
|
/**
|
|
|
|
* snd_card_free - frees given soundcard structure
|
|
|
|
* @card: soundcard structure
|
|
|
|
*
|
|
|
|
* This function releases the soundcard structure and the all assigned
|
|
|
|
* devices automatically. That is, you don't have to release the devices
|
|
|
|
* by yourself.
|
|
|
|
*
|
|
|
|
* This function waits until the all resources are properly released.
|
|
|
|
*
|
|
|
|
* Return: Zero. Frees all associated devices and frees the control
|
|
|
|
* interface associated to given soundcard.
|
|
|
|
*/
|
2023-02-07 19:19:07 +00:00
|
|
|
void snd_card_free(struct snd_card *card)
|
2006-06-23 12:38:23 +00:00
|
|
|
{
|
2020-09-02 21:21:23 +00:00
|
|
|
DECLARE_COMPLETION_ONSTACK(released);
|
2014-01-29 11:13:43 +00:00
|
|
|
|
2021-07-31 08:34:46 +00:00
|
|
|
/* The call of snd_card_free() is allowed from various code paths;
|
|
|
|
* a manual call from the driver and the call via devres_free, and
|
|
|
|
* we need to avoid double-free. Moreover, the release via devres
|
|
|
|
* may call snd_card_free() twice due to its nature, we need to have
|
|
|
|
* the check here at the beginning.
|
|
|
|
*/
|
|
|
|
if (card->releasing)
|
2023-02-07 19:19:07 +00:00
|
|
|
return;
|
2021-07-31 08:34:46 +00:00
|
|
|
|
2014-01-29 11:13:43 +00:00
|
|
|
card->release_completion = &released;
|
2023-02-07 19:19:06 +00:00
|
|
|
snd_card_free_when_closed(card);
|
|
|
|
|
2006-06-23 12:38:23 +00:00
|
|
|
/* wait, until all devices are ready for the free operation */
|
2014-01-29 11:13:43 +00:00
|
|
|
wait_for_completion(&released);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-04-28 13:13:39 +00:00
|
|
|
EXPORT_SYMBOL(snd_card_free);
|
|
|
|
|
2012-03-09 16:41:53 +00:00
|
|
|
/* retrieve the last word of shortname or longname */
|
|
|
|
static const char *retrieve_id_from_card_name(const char *name)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-03-09 16:41:53 +00:00
|
|
|
const char *spos = name;
|
|
|
|
|
|
|
|
while (*name) {
|
|
|
|
if (isspace(*name) && isalnum(name[1]))
|
|
|
|
spos = name + 1;
|
|
|
|
name++;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2012-03-09 16:41:53 +00:00
|
|
|
return spos;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* return true if the given id string doesn't conflict any other card ids */
|
|
|
|
static bool card_id_ok(struct snd_card *card, const char *id)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
if (!snd_info_check_reserved_words(id))
|
|
|
|
return false;
|
|
|
|
for (i = 0; i < snd_ecards_limit; i++) {
|
|
|
|
if (snd_cards[i] && snd_cards[i] != card &&
|
|
|
|
!strcmp(snd_cards[i]->id, id))
|
|
|
|
return false;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2012-03-09 16:41:53 +00:00
|
|
|
return true;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-03-09 16:41:53 +00:00
|
|
|
/* copy to card->id only with valid letters from nid */
|
|
|
|
static void copy_valid_id_string(struct snd_card *card, const char *src,
|
|
|
|
const char *nid)
|
|
|
|
{
|
|
|
|
char *id = card->id;
|
|
|
|
|
|
|
|
while (*nid && !isalnum(*nid))
|
|
|
|
nid++;
|
|
|
|
if (isdigit(*nid))
|
|
|
|
*id++ = isalpha(*src) ? *src : 'D';
|
|
|
|
while (*nid && (size_t)(id - card->id) < sizeof(card->id) - 1) {
|
|
|
|
if (isalnum(*nid))
|
|
|
|
*id++ = *nid;
|
|
|
|
nid++;
|
|
|
|
}
|
|
|
|
*id = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set card->id from the given string
|
|
|
|
* If the string conflicts with other ids, add a suffix to make it unique.
|
|
|
|
*/
|
|
|
|
static void snd_card_set_id_no_lock(struct snd_card *card, const char *src,
|
|
|
|
const char *nid)
|
|
|
|
{
|
|
|
|
int len, loops;
|
|
|
|
bool is_default = false;
|
|
|
|
char *id;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-03-09 16:41:53 +00:00
|
|
|
copy_valid_id_string(card, src, nid);
|
|
|
|
id = card->id;
|
|
|
|
|
|
|
|
again:
|
|
|
|
/* use "Default" for obviously invalid strings
|
|
|
|
* ("card" conflicts with proc directories)
|
|
|
|
*/
|
|
|
|
if (!*id || !strncmp(id, "card", 4)) {
|
2011-04-04 10:43:23 +00:00
|
|
|
strcpy(id, "Default");
|
2012-03-09 16:41:53 +00:00
|
|
|
is_default = true;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-05-24 14:30:39 +00:00
|
|
|
len = strlen(id);
|
2012-03-09 16:41:53 +00:00
|
|
|
for (loops = 0; loops < SNDRV_CARDS; loops++) {
|
2013-05-24 14:30:39 +00:00
|
|
|
char *spos;
|
|
|
|
char sfxstr[5]; /* "_012" */
|
|
|
|
int sfxlen;
|
|
|
|
|
2012-03-09 16:41:53 +00:00
|
|
|
if (card_id_ok(card, id))
|
|
|
|
return; /* OK */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-05-24 14:30:39 +00:00
|
|
|
/* Add _XYZ suffix */
|
|
|
|
sprintf(sfxstr, "_%X", loops + 1);
|
|
|
|
sfxlen = strlen(sfxstr);
|
|
|
|
if (len + sfxlen >= sizeof(card->id))
|
|
|
|
spos = id + sizeof(card->id) - sfxlen - 1;
|
|
|
|
else
|
|
|
|
spos = id + len;
|
|
|
|
strcpy(spos, sfxstr);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2012-03-09 16:41:53 +00:00
|
|
|
/* fallback to the default id */
|
|
|
|
if (!is_default) {
|
|
|
|
*id = 0;
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
/* last resort... */
|
2014-02-04 17:21:03 +00:00
|
|
|
dev_err(card->dev, "unable to set card id (%s)\n", id);
|
2012-03-09 16:41:53 +00:00
|
|
|
if (card->proc_root->name)
|
ALSA: Convert strlcpy to strscpy when return value is unused
strlcpy is deprecated. see: Documentation/process/deprecated.rst
Change the calls that do not use the strlcpy return value to the
preferred strscpy.
Done with cocci script:
@@
expression e1, e2, e3;
@@
- strlcpy(
+ strscpy(
e1, e2, e3);
This cocci script leaves the instances where the return value is
used unchanged.
After this patch, sound/ has 3 uses of strlcpy() that need to be
manually inspected for conversion and changed one day.
$ git grep -w strlcpy sound/
sound/usb/card.c: len = strlcpy(card->longname, s, sizeof(card->longname));
sound/usb/mixer.c: return strlcpy(buf, p->name, buflen);
sound/usb/mixer.c: return strlcpy(buf, p->names[index], buflen);
Miscellenea:
o Remove trailing whitespace in conversion of sound/core/hwdep.c
Link: https://lore.kernel.org/lkml/CAHk-=wgfRnXz0W3D37d01q3JFkr_i_uTL=V6A6G1oUZcprmknw@mail.gmail.com/
Signed-off-by: Joe Perches <joe@perches.com>
Acked-by: Mark Brown <broonie@kernel.org>
Link: https://lore.kernel.org/r/22b393d1790bb268769d0bab7bacf0866dcb0c14.camel@perches.com
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2021-01-04 17:17:34 +00:00
|
|
|
strscpy(card->id, card->proc_root->name, sizeof(card->id));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-06-03 19:43:29 +00:00
|
|
|
/**
|
|
|
|
* snd_card_set_id - set card identification name
|
|
|
|
* @card: soundcard structure
|
|
|
|
* @nid: new identification string
|
|
|
|
*
|
|
|
|
* This function sets the card identification and checks for name
|
|
|
|
* collisions.
|
|
|
|
*/
|
|
|
|
void snd_card_set_id(struct snd_card *card, const char *nid)
|
|
|
|
{
|
2009-06-03 22:12:18 +00:00
|
|
|
/* check if user specified own card->id */
|
|
|
|
if (card->id[0] != '\0')
|
|
|
|
return;
|
|
|
|
mutex_lock(&snd_card_mutex);
|
2012-03-09 16:41:53 +00:00
|
|
|
snd_card_set_id_no_lock(card, nid, nid);
|
2009-06-03 22:12:18 +00:00
|
|
|
mutex_unlock(&snd_card_mutex);
|
2009-06-03 19:43:29 +00:00
|
|
|
}
|
2009-06-02 10:02:38 +00:00
|
|
|
EXPORT_SYMBOL(snd_card_set_id);
|
|
|
|
|
2021-05-26 12:18:28 +00:00
|
|
|
static ssize_t id_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2008-11-11 15:51:02 +00:00
|
|
|
{
|
2014-02-19 10:18:10 +00:00
|
|
|
struct snd_card *card = container_of(dev, struct snd_card, card_dev);
|
2022-08-01 16:56:36 +00:00
|
|
|
return sysfs_emit(buf, "%s\n", card->id);
|
2008-11-11 15:51:02 +00:00
|
|
|
}
|
|
|
|
|
2021-05-26 12:18:28 +00:00
|
|
|
static ssize_t id_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2008-11-11 15:51:02 +00:00
|
|
|
{
|
2014-02-19 10:18:10 +00:00
|
|
|
struct snd_card *card = container_of(dev, struct snd_card, card_dev);
|
2008-11-11 15:51:02 +00:00
|
|
|
char buf1[sizeof(card->id)];
|
|
|
|
size_t copy = count > sizeof(card->id) - 1 ?
|
|
|
|
sizeof(card->id) - 1 : count;
|
|
|
|
size_t idx;
|
|
|
|
int c;
|
|
|
|
|
|
|
|
for (idx = 0; idx < copy; idx++) {
|
|
|
|
c = buf[idx];
|
|
|
|
if (!isalnum(c) && c != '_' && c != '-')
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
memcpy(buf1, buf, copy);
|
|
|
|
buf1[copy] = '\0';
|
|
|
|
mutex_lock(&snd_card_mutex);
|
2012-03-09 16:41:53 +00:00
|
|
|
if (!card_id_ok(NULL, buf1)) {
|
2008-11-11 15:51:02 +00:00
|
|
|
mutex_unlock(&snd_card_mutex);
|
|
|
|
return -EEXIST;
|
|
|
|
}
|
|
|
|
strcpy(card->id, buf1);
|
2008-11-12 15:31:37 +00:00
|
|
|
snd_info_card_id_change(card);
|
2008-11-11 15:51:02 +00:00
|
|
|
mutex_unlock(&snd_card_mutex);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2021-05-26 12:18:28 +00:00
|
|
|
static DEVICE_ATTR_RW(id);
|
2008-11-11 15:51:02 +00:00
|
|
|
|
2021-05-26 12:18:28 +00:00
|
|
|
static ssize_t number_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2008-11-11 15:51:02 +00:00
|
|
|
{
|
2014-02-19 10:18:10 +00:00
|
|
|
struct snd_card *card = container_of(dev, struct snd_card, card_dev);
|
2022-08-01 16:56:36 +00:00
|
|
|
return sysfs_emit(buf, "%i\n", card->number);
|
2008-11-11 15:51:02 +00:00
|
|
|
}
|
|
|
|
|
2021-05-26 12:18:28 +00:00
|
|
|
static DEVICE_ATTR_RO(number);
|
2014-01-29 10:54:10 +00:00
|
|
|
|
|
|
|
static struct attribute *card_dev_attrs[] = {
|
|
|
|
&dev_attr_id.attr,
|
|
|
|
&dev_attr_number.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2015-01-30 11:27:43 +00:00
|
|
|
static const struct attribute_group card_dev_attr_group = {
|
2014-01-29 10:54:10 +00:00
|
|
|
.attrs = card_dev_attrs,
|
|
|
|
};
|
|
|
|
|
2015-01-30 11:27:43 +00:00
|
|
|
/**
|
|
|
|
* snd_card_add_dev_attr - Append a new sysfs attribute group to card
|
|
|
|
* @card: card instance
|
|
|
|
* @group: attribute group to append
|
2022-07-13 10:47:59 +00:00
|
|
|
*
|
|
|
|
* Return: zero if successful, or a negative error code
|
2015-01-30 11:27:43 +00:00
|
|
|
*/
|
|
|
|
int snd_card_add_dev_attr(struct snd_card *card,
|
|
|
|
const struct attribute_group *group)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* loop for (arraysize-1) here to keep NULL at the last entry */
|
|
|
|
for (i = 0; i < ARRAY_SIZE(card->dev_groups) - 1; i++) {
|
|
|
|
if (!card->dev_groups[i]) {
|
|
|
|
card->dev_groups[i] = group;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_err(card->dev, "Too many groups assigned\n");
|
|
|
|
return -ENOSPC;
|
2017-06-16 14:16:33 +00:00
|
|
|
}
|
2015-01-30 11:27:43 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_card_add_dev_attr);
|
2008-11-11 15:51:02 +00:00
|
|
|
|
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 07:58:24 +00:00
|
|
|
static void trigger_card_free(void *data)
|
|
|
|
{
|
2021-07-31 08:34:46 +00:00
|
|
|
snd_card_free(data);
|
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 07:58:24 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* snd_card_register - register the soundcard
|
|
|
|
* @card: soundcard structure
|
|
|
|
*
|
|
|
|
* This function registers all the devices assigned to the soundcard.
|
|
|
|
* Until calling this, the ALSA control interface is blocked from the
|
|
|
|
* external accesses. Thus, you should call this function at the end
|
|
|
|
* of the initialization of the card.
|
|
|
|
*
|
2013-03-11 21:05:14 +00:00
|
|
|
* Return: Zero otherwise a negative error code if the registration failed.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2005-11-17 12:51:18 +00:00
|
|
|
int snd_card_register(struct snd_card *card)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2008-08-08 15:09:09 +00:00
|
|
|
if (snd_BUG_ON(!card))
|
|
|
|
return -EINVAL;
|
2010-09-05 05:33:14 +00:00
|
|
|
|
2014-01-29 10:46:11 +00:00
|
|
|
if (!card->registered) {
|
|
|
|
err = device_add(&card->card_dev);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
card->registered = true;
|
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 07:58:24 +00:00
|
|
|
} else {
|
|
|
|
if (card->managed)
|
|
|
|
devm_remove_action(card->dev, trigger_card_free, card);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (card->managed) {
|
|
|
|
err = devm_add_action(card->dev, trigger_card_free, card);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2006-08-08 05:19:37 +00:00
|
|
|
}
|
2010-09-05 05:33:14 +00:00
|
|
|
|
2021-06-08 14:05:27 +00:00
|
|
|
err = snd_device_register_all(card);
|
|
|
|
if (err < 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
2006-05-15 17:49:05 +00:00
|
|
|
mutex_lock(&snd_card_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (snd_cards[card->number]) {
|
|
|
|
/* already registered */
|
2006-05-15 17:49:05 +00:00
|
|
|
mutex_unlock(&snd_card_mutex);
|
2015-05-18 07:20:24 +00:00
|
|
|
return snd_info_card_register(card); /* register pending info */
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2012-03-09 16:41:53 +00:00
|
|
|
if (*card->id) {
|
|
|
|
/* make a unique id name from the given string */
|
|
|
|
char tmpid[sizeof(card->id)];
|
|
|
|
memcpy(tmpid, card->id, sizeof(card->id));
|
|
|
|
snd_card_set_id_no_lock(card, tmpid, tmpid);
|
|
|
|
} else {
|
|
|
|
/* create an id from either shortname or longname */
|
|
|
|
const char *src;
|
|
|
|
src = *card->shortname ? card->shortname : card->longname;
|
|
|
|
snd_card_set_id_no_lock(card, src,
|
|
|
|
retrieve_id_from_card_name(src));
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
snd_cards[card->number] = card;
|
2006-05-15 17:49:05 +00:00
|
|
|
mutex_unlock(&snd_card_mutex);
|
2019-02-05 15:26:06 +00:00
|
|
|
err = snd_info_card_register(card);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2014-02-10 08:48:47 +00:00
|
|
|
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
2005-04-16 22:20:36 +00:00
|
|
|
if (snd_mixer_oss_notify_callback)
|
|
|
|
snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
|
2008-11-11 15:51:02 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2006-04-28 13:13:39 +00:00
|
|
|
EXPORT_SYMBOL(snd_card_register);
|
|
|
|
|
2015-05-27 11:45:45 +00:00
|
|
|
#ifdef CONFIG_SND_PROC_FS
|
2005-11-17 14:55:49 +00:00
|
|
|
static void snd_card_info_read(struct snd_info_entry *entry,
|
|
|
|
struct snd_info_buffer *buffer)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int idx, count;
|
2005-11-17 12:51:18 +00:00
|
|
|
struct snd_card *card;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
|
2006-05-15 17:49:05 +00:00
|
|
|
mutex_lock(&snd_card_mutex);
|
2021-06-08 14:05:27 +00:00
|
|
|
card = snd_cards[idx];
|
|
|
|
if (card) {
|
2005-04-16 22:20:36 +00:00
|
|
|
count++;
|
2005-11-20 13:09:05 +00:00
|
|
|
snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
idx,
|
|
|
|
card->id,
|
|
|
|
card->driver,
|
|
|
|
card->shortname);
|
2005-11-20 13:09:05 +00:00
|
|
|
snd_iprintf(buffer, " %s\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
card->longname);
|
|
|
|
}
|
2006-05-15 17:49:05 +00:00
|
|
|
mutex_unlock(&snd_card_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (!count)
|
|
|
|
snd_iprintf(buffer, "--- no soundcards ---\n");
|
|
|
|
}
|
|
|
|
|
2005-12-01 09:42:42 +00:00
|
|
|
#ifdef CONFIG_SND_OSSEMUL
|
2005-11-17 12:51:18 +00:00
|
|
|
void snd_card_info_read_oss(struct snd_info_buffer *buffer)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int idx, count;
|
2005-11-17 12:51:18 +00:00
|
|
|
struct snd_card *card;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
|
2006-05-15 17:49:05 +00:00
|
|
|
mutex_lock(&snd_card_mutex);
|
2021-06-08 14:05:27 +00:00
|
|
|
card = snd_cards[idx];
|
|
|
|
if (card) {
|
2005-04-16 22:20:36 +00:00
|
|
|
count++;
|
|
|
|
snd_iprintf(buffer, "%s\n", card->longname);
|
|
|
|
}
|
2006-05-15 17:49:05 +00:00
|
|
|
mutex_unlock(&snd_card_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (!count) {
|
|
|
|
snd_iprintf(buffer, "--- no soundcards ---\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef MODULE
|
2005-11-17 12:51:18 +00:00
|
|
|
static void snd_card_module_info_read(struct snd_info_entry *entry,
|
|
|
|
struct snd_info_buffer *buffer)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int idx;
|
2005-11-17 12:51:18 +00:00
|
|
|
struct snd_card *card;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
for (idx = 0; idx < SNDRV_CARDS; idx++) {
|
2006-05-15 17:49:05 +00:00
|
|
|
mutex_lock(&snd_card_mutex);
|
2021-06-08 14:05:27 +00:00
|
|
|
card = snd_cards[idx];
|
|
|
|
if (card)
|
2005-11-20 13:09:05 +00:00
|
|
|
snd_iprintf(buffer, "%2i %s\n",
|
|
|
|
idx, card->module->name);
|
2006-05-15 17:49:05 +00:00
|
|
|
mutex_unlock(&snd_card_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
int __init snd_card_info_init(void)
|
|
|
|
{
|
2005-11-17 12:51:18 +00:00
|
|
|
struct snd_info_entry *entry;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
|
2005-10-10 09:46:31 +00:00
|
|
|
if (! entry)
|
|
|
|
return -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
entry->c.text.read = snd_card_info_read;
|
2015-04-22 20:29:10 +00:00
|
|
|
if (snd_info_register(entry) < 0)
|
|
|
|
return -ENOMEM; /* freed in error path */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#ifdef MODULE
|
|
|
|
entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL);
|
2015-04-22 20:29:10 +00:00
|
|
|
if (!entry)
|
|
|
|
return -ENOMEM;
|
|
|
|
entry->c.text.read = snd_card_module_info_read;
|
|
|
|
if (snd_info_register(entry) < 0)
|
|
|
|
return -ENOMEM; /* freed in error path */
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2015-05-27 11:45:45 +00:00
|
|
|
#endif /* CONFIG_SND_PROC_FS */
|
2005-12-01 09:42:42 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* snd_component_add - add a component string
|
|
|
|
* @card: soundcard structure
|
|
|
|
* @component: the component id string
|
|
|
|
*
|
|
|
|
* This function adds the component id string to the supported list.
|
|
|
|
* The component can be referred from the alsa-lib.
|
|
|
|
*
|
2013-03-11 21:05:14 +00:00
|
|
|
* Return: Zero otherwise a negative error code.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
2005-11-17 12:51:18 +00:00
|
|
|
int snd_component_add(struct snd_card *card, const char *component)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
char *ptr;
|
|
|
|
int len = strlen(component);
|
|
|
|
|
|
|
|
ptr = strstr(card->components, component);
|
|
|
|
if (ptr != NULL) {
|
|
|
|
if (ptr[len] == '\0' || ptr[len] == ' ') /* already there */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (strlen(card->components) + 1 + len + 1 > sizeof(card->components)) {
|
|
|
|
snd_BUG();
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
if (card->components[0] != '\0')
|
|
|
|
strcat(card->components, " ");
|
|
|
|
strcat(card->components, component);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-04-28 13:13:39 +00:00
|
|
|
EXPORT_SYMBOL(snd_component_add);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* snd_card_file_add - add the file to the file list of the card
|
|
|
|
* @card: soundcard structure
|
|
|
|
* @file: file pointer
|
|
|
|
*
|
|
|
|
* This function adds the file to the file linked-list of the card.
|
|
|
|
* This linked-list is used to keep tracking the connection state,
|
|
|
|
* and to avoid the release of busy resources by hotplug.
|
|
|
|
*
|
2013-03-11 21:05:14 +00:00
|
|
|
* Return: zero or a negative error code.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2005-11-17 12:51:18 +00:00
|
|
|
int snd_card_file_add(struct snd_card *card, struct file *file)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct snd_monitor_file *mfile;
|
|
|
|
|
|
|
|
mfile = kmalloc(sizeof(*mfile), GFP_KERNEL);
|
|
|
|
if (mfile == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
mfile->file = file;
|
2006-10-06 14:08:27 +00:00
|
|
|
mfile->disconnected_f_op = NULL;
|
2011-03-24 08:50:15 +00:00
|
|
|
INIT_LIST_HEAD(&mfile->shutdown_list);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock(&card->files_lock);
|
|
|
|
if (card->shutdown) {
|
|
|
|
spin_unlock(&card->files_lock);
|
|
|
|
kfree(mfile);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
2009-02-23 15:35:21 +00:00
|
|
|
list_add(&mfile->list, &card->files_list);
|
2014-01-29 11:13:43 +00:00
|
|
|
get_device(&card->card_dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock(&card->files_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-04-28 13:13:39 +00:00
|
|
|
EXPORT_SYMBOL(snd_card_file_add);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* snd_card_file_remove - remove the file from the file list
|
|
|
|
* @card: soundcard structure
|
|
|
|
* @file: file pointer
|
|
|
|
*
|
|
|
|
* This function removes the file formerly added to the card via
|
|
|
|
* snd_card_file_add() function.
|
2006-06-23 12:38:26 +00:00
|
|
|
* If all files are removed and snd_card_free_when_closed() was
|
|
|
|
* called beforehand, it processes the pending release of
|
|
|
|
* resources.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2013-03-11 21:05:14 +00:00
|
|
|
* Return: Zero or a negative error code.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2005-11-17 12:51:18 +00:00
|
|
|
int snd_card_file_remove(struct snd_card *card, struct file *file)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-02-23 15:35:21 +00:00
|
|
|
struct snd_monitor_file *mfile, *found = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_lock(&card->files_lock);
|
2009-02-23 15:35:21 +00:00
|
|
|
list_for_each_entry(mfile, &card->files_list, list) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (mfile->file == file) {
|
2009-02-23 15:35:21 +00:00
|
|
|
list_del(&mfile->list);
|
2011-03-24 08:50:15 +00:00
|
|
|
spin_lock(&shutdown_lock);
|
|
|
|
list_del(&mfile->shutdown_list);
|
|
|
|
spin_unlock(&shutdown_lock);
|
2009-02-23 15:35:21 +00:00
|
|
|
if (mfile->disconnected_f_op)
|
|
|
|
fops_put(mfile->disconnected_f_op);
|
|
|
|
found = mfile;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
2006-10-06 14:08:27 +00:00
|
|
|
}
|
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 06:36:13 +00:00
|
|
|
if (list_empty(&card->files_list))
|
|
|
|
wake_up_all(&card->remove_sleep);
|
2006-06-23 12:38:23 +00:00
|
|
|
spin_unlock(&card->files_lock);
|
2009-02-23 15:35:21 +00:00
|
|
|
if (!found) {
|
2014-02-04 17:21:03 +00:00
|
|
|
dev_err(card->dev, "card file remove problem (%p)\n", file);
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOENT;
|
|
|
|
}
|
2009-02-23 15:35:21 +00:00
|
|
|
kfree(found);
|
2014-01-29 11:13:43 +00:00
|
|
|
put_device(&card->card_dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2006-04-28 13:13:39 +00:00
|
|
|
EXPORT_SYMBOL(snd_card_file_remove);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
/**
|
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 09:09:16 +00:00
|
|
|
* snd_power_ref_and_wait - wait until the card gets powered up
|
|
|
|
* @card: soundcard structure
|
2005-04-16 22:20:36 +00: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 09:09:16 +00:00
|
|
|
* Take the power_ref reference count of the given card, and
|
|
|
|
* wait until the card gets powered up to SNDRV_CTL_POWER_D0 state.
|
|
|
|
* The refcount is down again while sleeping until power-up, hence this
|
|
|
|
* function can be used for syncing the floating control ops accesses,
|
|
|
|
* typically around calling control ops.
|
2005-04-16 22:20:36 +00: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 09:09:16 +00:00
|
|
|
* The caller needs to pull down the refcount via snd_power_unref() later
|
|
|
|
* no matter whether the error is returned from this function or not.
|
|
|
|
*
|
|
|
|
* Return: Zero if successful, or a negative error code.
|
2005-04-16 22:20:36 +00: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 09:09:16 +00:00
|
|
|
int snd_power_ref_and_wait(struct snd_card *card)
|
2005-04-16 22:20:36 +00: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 09:09:16 +00:00
|
|
|
snd_power_ref(card);
|
|
|
|
if (snd_power_get_state(card) == SNDRV_CTL_POWER_D0)
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
2022-01-19 09:10:50 +00:00
|
|
|
wait_event_cmd(card->power_sleep,
|
|
|
|
card->shutdown ||
|
|
|
|
snd_power_get_state(card) == SNDRV_CTL_POWER_D0,
|
|
|
|
snd_power_unref(card), snd_power_ref(card));
|
|
|
|
return card->shutdown ? -ENODEV : 0;
|
2005-04-16 22:20:36 +00: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 09:09:16 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_power_ref_and_wait);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_power_wait - wait until the card gets powered up (old form)
|
|
|
|
* @card: soundcard structure
|
|
|
|
*
|
|
|
|
* Wait until the card gets powered up to SNDRV_CTL_POWER_D0 state.
|
|
|
|
*
|
|
|
|
* Return: Zero if successful, or a negative error code.
|
|
|
|
*/
|
2021-05-23 09:09:19 +00: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 09:09:16 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = snd_power_ref_and_wait(card);
|
|
|
|
snd_power_unref(card);
|
|
|
|
return ret;
|
|
|
|
}
|
2006-04-28 13:13:39 +00:00
|
|
|
EXPORT_SYMBOL(snd_power_wait);
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* CONFIG_PM */
|