mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-06 03:16:39 +07:00
7d8e829201
Currently we're taking power_lock at each card component for assuring the power-up sequence, but it doesn't help anything in the implementation at the moment: it just serializes unnecessarily the callers, but it doesn't protect about the power state change itself. It used to have some usefulness in the early days where we managed the PM manually. But now the suspend/resume core procedure is beyond our hands, and power_lock lost its meaning. This patch drops the power_lock from allover the places. There shouldn't be any issues by this change, as it's no helper regarding the power state change. Rather we'll get better performance by removing the serialization; which is the only slight concern of any behavior change, but it can't be a showstopper, after all. Signed-off-by: Takashi Iwai <tiwai@suse.de>
1006 lines
26 KiB
C
1006 lines
26 KiB
C
/*
|
|
* Initialization routines
|
|
* Copyright (c) by Jaroslav Kysela <perex@perex.cz>
|
|
*
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/module.h>
|
|
#include <linux/device.h>
|
|
#include <linux/file.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/time.h>
|
|
#include <linux/ctype.h>
|
|
#include <linux/pm.h>
|
|
#include <linux/completion.h>
|
|
|
|
#include <sound/core.h>
|
|
#include <sound/control.h>
|
|
#include <sound/info.h>
|
|
|
|
/* 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 */
|
|
};
|
|
|
|
static DEFINE_SPINLOCK(shutdown_lock);
|
|
static LIST_HEAD(shutdown_files);
|
|
|
|
static const struct file_operations snd_shutdown_f_ops;
|
|
|
|
/* locked for registering/using */
|
|
static DECLARE_BITMAP(snd_cards_lock, SNDRV_CARDS);
|
|
struct snd_card *snd_cards[SNDRV_CARDS];
|
|
EXPORT_SYMBOL(snd_cards);
|
|
|
|
static DEFINE_MUTEX(snd_card_mutex);
|
|
|
|
static char *slots[SNDRV_CARDS];
|
|
module_param_array(slots, charp, NULL, 0444);
|
|
MODULE_PARM_DESC(slots, "Module names assigned to the slots.");
|
|
|
|
/* return non-zero if the given index is reserved for the given
|
|
* module via slots option
|
|
*/
|
|
static int module_slot_match(struct module *module, int idx)
|
|
{
|
|
int match = 1;
|
|
#ifdef MODULE
|
|
const char *s1, *s2;
|
|
|
|
if (!module || !*module->name || !slots[idx])
|
|
return 0;
|
|
|
|
s1 = module->name;
|
|
s2 = slots[idx];
|
|
if (*s2 == '!') {
|
|
match = 0; /* negative match */
|
|
s2++;
|
|
}
|
|
/* 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)
|
|
return !match;
|
|
if (!c1)
|
|
break;
|
|
}
|
|
#endif /* MODULE */
|
|
return match;
|
|
}
|
|
|
|
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
|
int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag);
|
|
EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
|
|
#endif
|
|
|
|
#ifdef CONFIG_SND_PROC_FS
|
|
static void snd_card_id_read(struct snd_info_entry *entry,
|
|
struct snd_info_buffer *buffer)
|
|
{
|
|
snd_iprintf(buffer, "%s\n", entry->card->id);
|
|
}
|
|
|
|
static int init_info_for_card(struct snd_card *card)
|
|
{
|
|
struct snd_info_entry *entry;
|
|
|
|
entry = snd_info_create_card_entry(card, "id", card->proc_root);
|
|
if (!entry) {
|
|
dev_dbg(card->dev, "unable to create card entry\n");
|
|
return -ENOMEM;
|
|
}
|
|
entry->c.text.read = snd_card_id_read;
|
|
card->proc_id = entry;
|
|
|
|
return snd_info_card_register(card);
|
|
}
|
|
#else /* !CONFIG_SND_PROC_FS */
|
|
#define init_info_for_card(card)
|
|
#endif
|
|
|
|
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 */
|
|
}
|
|
|
|
/* the default release callback set in snd_device_initialize() below;
|
|
* this is just NOP for now, as almost all jobs are already done in
|
|
* dev_free callback of snd_device chain instead.
|
|
*/
|
|
static void default_release(struct device *dev)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* snd_device_initialize - Initialize struct device for sound devices
|
|
* @dev: device to initialize
|
|
* @card: card to assign, optional
|
|
*/
|
|
void snd_device_initialize(struct device *dev, struct snd_card *card)
|
|
{
|
|
device_initialize(dev);
|
|
if (card)
|
|
dev->parent = &card->card_dev;
|
|
dev->class = sound_class;
|
|
dev->release = default_release;
|
|
}
|
|
EXPORT_SYMBOL_GPL(snd_device_initialize);
|
|
|
|
static int snd_card_do_free(struct snd_card *card);
|
|
static const struct attribute_group card_dev_attr_group;
|
|
|
|
static void release_card_device(struct device *dev)
|
|
{
|
|
snd_card_do_free(dev_to_snd_card(dev));
|
|
}
|
|
|
|
/**
|
|
* snd_card_new - create and initialize a soundcard structure
|
|
* @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
|
|
*
|
|
* Creates and initializes a soundcard structure.
|
|
*
|
|
* 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.
|
|
*
|
|
* Return: Zero if successful or a negative error code.
|
|
*/
|
|
int snd_card_new(struct device *parent, int idx, const char *xid,
|
|
struct module *module, int extra_size,
|
|
struct snd_card **card_ret)
|
|
{
|
|
struct snd_card *card;
|
|
int err;
|
|
|
|
if (snd_BUG_ON(!card_ret))
|
|
return -EINVAL;
|
|
*card_ret = NULL;
|
|
|
|
if (extra_size < 0)
|
|
extra_size = 0;
|
|
card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
|
|
if (!card)
|
|
return -ENOMEM;
|
|
if (extra_size > 0)
|
|
card->private_data = (char *)card + sizeof(struct snd_card);
|
|
if (xid)
|
|
strlcpy(card->id, xid, sizeof(card->id));
|
|
err = 0;
|
|
mutex_lock(&snd_card_mutex);
|
|
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);
|
|
if (idx < 0)
|
|
err = -ENODEV;
|
|
else if (idx < snd_ecards_limit) {
|
|
if (test_bit(idx, snd_cards_lock))
|
|
err = -EBUSY; /* invalid */
|
|
} else if (idx >= SNDRV_CARDS)
|
|
err = -ENODEV;
|
|
if (err < 0) {
|
|
mutex_unlock(&snd_card_mutex);
|
|
dev_err(parent, "cannot find the slot for index %d (range 0-%i), error: %d\n",
|
|
idx, snd_ecards_limit - 1, err);
|
|
kfree(card);
|
|
return err;
|
|
}
|
|
set_bit(idx, snd_cards_lock); /* lock it */
|
|
if (idx >= snd_ecards_limit)
|
|
snd_ecards_limit = idx + 1; /* increase the limit */
|
|
mutex_unlock(&snd_card_mutex);
|
|
card->dev = parent;
|
|
card->number = idx;
|
|
card->module = module;
|
|
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);
|
|
spin_lock_init(&card->files_lock);
|
|
INIT_LIST_HEAD(&card->files_list);
|
|
#ifdef CONFIG_PM
|
|
init_waitqueue_head(&card->power_sleep);
|
|
#endif
|
|
|
|
device_initialize(&card->card_dev);
|
|
card->card_dev.parent = parent;
|
|
card->card_dev.class = sound_class;
|
|
card->card_dev.release = release_card_device;
|
|
card->card_dev.groups = card->dev_groups;
|
|
card->dev_groups[0] = &card_dev_attr_group;
|
|
err = kobject_set_name(&card->card_dev.kobj, "card%d", idx);
|
|
if (err < 0)
|
|
goto __error;
|
|
|
|
snprintf(card->irq_descr, sizeof(card->irq_descr), "%s:%s",
|
|
dev_driver_string(card->dev), dev_name(&card->card_dev));
|
|
|
|
/* the control interface cannot be accessed from the user space until */
|
|
/* snd_cards_bitmask and snd_cards are set with snd_card_register */
|
|
err = snd_ctl_create(card);
|
|
if (err < 0) {
|
|
dev_err(parent, "unable to register control minors\n");
|
|
goto __error;
|
|
}
|
|
err = snd_info_card_create(card);
|
|
if (err < 0) {
|
|
dev_err(parent, "unable to create card info\n");
|
|
goto __error_ctl;
|
|
}
|
|
*card_ret = card;
|
|
return 0;
|
|
|
|
__error_ctl:
|
|
snd_device_free_all(card);
|
|
__error:
|
|
put_device(&card->card_dev);
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(snd_card_new);
|
|
|
|
/* return non-zero if a card is already locked */
|
|
int snd_card_locked(int card)
|
|
{
|
|
int locked;
|
|
|
|
mutex_lock(&snd_card_mutex);
|
|
locked = test_bit(card, snd_cards_lock);
|
|
mutex_unlock(&snd_card_mutex);
|
|
return locked;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
list_del_init(&df->shutdown_list);
|
|
break;
|
|
}
|
|
}
|
|
spin_unlock(&shutdown_lock);
|
|
|
|
if (likely(df)) {
|
|
if ((file->f_flags & FASYNC) && df->disconnected_f_op->fasync)
|
|
df->disconnected_f_op->fasync(-1, file, 0);
|
|
return df->disconnected_f_op->release(inode, file);
|
|
}
|
|
|
|
panic("%s(%p, %p) failed!", __func__, inode, file);
|
|
}
|
|
|
|
static unsigned int snd_disconnect_poll(struct file * file, poll_table * wait)
|
|
{
|
|
return POLLERR | POLLNVAL;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static const struct file_operations snd_shutdown_f_ops =
|
|
{
|
|
.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
|
|
};
|
|
|
|
/**
|
|
* snd_card_disconnect - disconnect all APIs from the file-operations (user space)
|
|
* @card: soundcard structure
|
|
*
|
|
* Disconnects all APIs from the file-operations (user space).
|
|
*
|
|
* Return: Zero, otherwise a negative error code.
|
|
*
|
|
* Note: The current implementation replaces all active file->f_op with special
|
|
* dummy file operations (they do nothing except release).
|
|
*/
|
|
int snd_card_disconnect(struct snd_card *card)
|
|
{
|
|
struct snd_monitor_file *mfile;
|
|
|
|
if (!card)
|
|
return -EINVAL;
|
|
|
|
spin_lock(&card->files_lock);
|
|
if (card->shutdown) {
|
|
spin_unlock(&card->files_lock);
|
|
return 0;
|
|
}
|
|
card->shutdown = 1;
|
|
spin_unlock(&card->files_lock);
|
|
|
|
/* phase 1: 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);
|
|
|
|
/* phase 2: replace file->f_op with special dummy operations */
|
|
|
|
spin_lock(&card->files_lock);
|
|
list_for_each_entry(mfile, &card->files_list, list) {
|
|
/* it's critical part, use endless loop */
|
|
/* we have no room to fail */
|
|
mfile->disconnected_f_op = mfile->file->f_op;
|
|
|
|
spin_lock(&shutdown_lock);
|
|
list_add(&mfile->shutdown_list, &shutdown_files);
|
|
spin_unlock(&shutdown_lock);
|
|
|
|
mfile->file->f_op = &snd_shutdown_f_ops;
|
|
fops_get(mfile->file->f_op);
|
|
}
|
|
spin_unlock(&card->files_lock);
|
|
|
|
/* phase 3: notify all connected devices about disconnection */
|
|
/* at this point, they cannot respond to any calls except release() */
|
|
|
|
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
|
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 */
|
|
snd_device_disconnect_all(card);
|
|
|
|
snd_info_card_disconnect(card);
|
|
if (card->registered) {
|
|
device_del(&card->card_dev);
|
|
card->registered = false;
|
|
}
|
|
#ifdef CONFIG_PM
|
|
wake_up(&card->power_sleep);
|
|
#endif
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(snd_card_disconnect);
|
|
|
|
static int snd_card_do_free(struct snd_card *card)
|
|
{
|
|
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
|
if (snd_mixer_oss_notify_callback)
|
|
snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
|
|
#endif
|
|
snd_device_free_all(card);
|
|
if (card->private_free)
|
|
card->private_free(card);
|
|
snd_info_free_entry(card->proc_id);
|
|
if (snd_info_card_free(card) < 0) {
|
|
dev_warn(card->dev, "unable to free card info\n");
|
|
/* Not fatal error */
|
|
}
|
|
if (card->release_completion)
|
|
complete(card->release_completion);
|
|
kfree(card);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
int snd_card_free_when_closed(struct snd_card *card)
|
|
{
|
|
int ret = snd_card_disconnect(card);
|
|
if (ret)
|
|
return ret;
|
|
put_device(&card->card_dev);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(snd_card_free_when_closed);
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
int snd_card_free(struct snd_card *card)
|
|
{
|
|
struct completion released;
|
|
int ret;
|
|
|
|
init_completion(&released);
|
|
card->release_completion = &released;
|
|
ret = snd_card_free_when_closed(card);
|
|
if (ret)
|
|
return ret;
|
|
/* wait, until all devices are ready for the free operation */
|
|
wait_for_completion(&released);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(snd_card_free);
|
|
|
|
/* retrieve the last word of shortname or longname */
|
|
static const char *retrieve_id_from_card_name(const char *name)
|
|
{
|
|
const char *spos = name;
|
|
|
|
while (*name) {
|
|
if (isspace(*name) && isalnum(name[1]))
|
|
spos = name + 1;
|
|
name++;
|
|
}
|
|
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;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* 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;
|
|
|
|
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)) {
|
|
strcpy(id, "Default");
|
|
is_default = true;
|
|
}
|
|
|
|
len = strlen(id);
|
|
for (loops = 0; loops < SNDRV_CARDS; loops++) {
|
|
char *spos;
|
|
char sfxstr[5]; /* "_012" */
|
|
int sfxlen;
|
|
|
|
if (card_id_ok(card, id))
|
|
return; /* OK */
|
|
|
|
/* 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);
|
|
}
|
|
/* fallback to the default id */
|
|
if (!is_default) {
|
|
*id = 0;
|
|
goto again;
|
|
}
|
|
/* last resort... */
|
|
dev_err(card->dev, "unable to set card id (%s)\n", id);
|
|
if (card->proc_root->name)
|
|
strlcpy(card->id, card->proc_root->name, sizeof(card->id));
|
|
}
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
/* check if user specified own card->id */
|
|
if (card->id[0] != '\0')
|
|
return;
|
|
mutex_lock(&snd_card_mutex);
|
|
snd_card_set_id_no_lock(card, nid, nid);
|
|
mutex_unlock(&snd_card_mutex);
|
|
}
|
|
EXPORT_SYMBOL(snd_card_set_id);
|
|
|
|
static ssize_t
|
|
card_id_show_attr(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct snd_card *card = container_of(dev, struct snd_card, card_dev);
|
|
return snprintf(buf, PAGE_SIZE, "%s\n", card->id);
|
|
}
|
|
|
|
static ssize_t
|
|
card_id_store_attr(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct snd_card *card = container_of(dev, struct snd_card, card_dev);
|
|
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);
|
|
if (!card_id_ok(NULL, buf1)) {
|
|
mutex_unlock(&snd_card_mutex);
|
|
return -EEXIST;
|
|
}
|
|
strcpy(card->id, buf1);
|
|
snd_info_card_id_change(card);
|
|
mutex_unlock(&snd_card_mutex);
|
|
|
|
return count;
|
|
}
|
|
|
|
static DEVICE_ATTR(id, S_IRUGO | S_IWUSR, card_id_show_attr, card_id_store_attr);
|
|
|
|
static ssize_t
|
|
card_number_show_attr(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct snd_card *card = container_of(dev, struct snd_card, card_dev);
|
|
return snprintf(buf, PAGE_SIZE, "%i\n", card->number);
|
|
}
|
|
|
|
static DEVICE_ATTR(number, S_IRUGO, card_number_show_attr, NULL);
|
|
|
|
static struct attribute *card_dev_attrs[] = {
|
|
&dev_attr_id.attr,
|
|
&dev_attr_number.attr,
|
|
NULL
|
|
};
|
|
|
|
static const struct attribute_group card_dev_attr_group = {
|
|
.attrs = card_dev_attrs,
|
|
};
|
|
|
|
/**
|
|
* snd_card_add_dev_attr - Append a new sysfs attribute group to card
|
|
* @card: card instance
|
|
* @group: attribute group to append
|
|
*/
|
|
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;
|
|
}
|
|
EXPORT_SYMBOL_GPL(snd_card_add_dev_attr);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* Return: Zero otherwise a negative error code if the registration failed.
|
|
*/
|
|
int snd_card_register(struct snd_card *card)
|
|
{
|
|
int err;
|
|
|
|
if (snd_BUG_ON(!card))
|
|
return -EINVAL;
|
|
|
|
if (!card->registered) {
|
|
err = device_add(&card->card_dev);
|
|
if (err < 0)
|
|
return err;
|
|
card->registered = true;
|
|
}
|
|
|
|
if ((err = snd_device_register_all(card)) < 0)
|
|
return err;
|
|
mutex_lock(&snd_card_mutex);
|
|
if (snd_cards[card->number]) {
|
|
/* already registered */
|
|
mutex_unlock(&snd_card_mutex);
|
|
return snd_info_card_register(card); /* register pending info */
|
|
}
|
|
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));
|
|
}
|
|
snd_cards[card->number] = card;
|
|
mutex_unlock(&snd_card_mutex);
|
|
init_info_for_card(card);
|
|
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
|
|
if (snd_mixer_oss_notify_callback)
|
|
snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
|
|
#endif
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(snd_card_register);
|
|
|
|
#ifdef CONFIG_SND_PROC_FS
|
|
static void snd_card_info_read(struct snd_info_entry *entry,
|
|
struct snd_info_buffer *buffer)
|
|
{
|
|
int idx, count;
|
|
struct snd_card *card;
|
|
|
|
for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
|
|
mutex_lock(&snd_card_mutex);
|
|
if ((card = snd_cards[idx]) != NULL) {
|
|
count++;
|
|
snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n",
|
|
idx,
|
|
card->id,
|
|
card->driver,
|
|
card->shortname);
|
|
snd_iprintf(buffer, " %s\n",
|
|
card->longname);
|
|
}
|
|
mutex_unlock(&snd_card_mutex);
|
|
}
|
|
if (!count)
|
|
snd_iprintf(buffer, "--- no soundcards ---\n");
|
|
}
|
|
|
|
#ifdef CONFIG_SND_OSSEMUL
|
|
void snd_card_info_read_oss(struct snd_info_buffer *buffer)
|
|
{
|
|
int idx, count;
|
|
struct snd_card *card;
|
|
|
|
for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
|
|
mutex_lock(&snd_card_mutex);
|
|
if ((card = snd_cards[idx]) != NULL) {
|
|
count++;
|
|
snd_iprintf(buffer, "%s\n", card->longname);
|
|
}
|
|
mutex_unlock(&snd_card_mutex);
|
|
}
|
|
if (!count) {
|
|
snd_iprintf(buffer, "--- no soundcards ---\n");
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef MODULE
|
|
static void snd_card_module_info_read(struct snd_info_entry *entry,
|
|
struct snd_info_buffer *buffer)
|
|
{
|
|
int idx;
|
|
struct snd_card *card;
|
|
|
|
for (idx = 0; idx < SNDRV_CARDS; idx++) {
|
|
mutex_lock(&snd_card_mutex);
|
|
if ((card = snd_cards[idx]) != NULL)
|
|
snd_iprintf(buffer, "%2i %s\n",
|
|
idx, card->module->name);
|
|
mutex_unlock(&snd_card_mutex);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
int __init snd_card_info_init(void)
|
|
{
|
|
struct snd_info_entry *entry;
|
|
|
|
entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
|
|
if (! entry)
|
|
return -ENOMEM;
|
|
entry->c.text.read = snd_card_info_read;
|
|
if (snd_info_register(entry) < 0)
|
|
return -ENOMEM; /* freed in error path */
|
|
|
|
#ifdef MODULE
|
|
entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL);
|
|
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 */
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
#endif /* CONFIG_SND_PROC_FS */
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* Return: Zero otherwise a negative error code.
|
|
*/
|
|
|
|
int snd_component_add(struct snd_card *card, const char *component)
|
|
{
|
|
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;
|
|
}
|
|
EXPORT_SYMBOL(snd_component_add);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* Return: zero or a negative error code.
|
|
*/
|
|
int snd_card_file_add(struct snd_card *card, struct file *file)
|
|
{
|
|
struct snd_monitor_file *mfile;
|
|
|
|
mfile = kmalloc(sizeof(*mfile), GFP_KERNEL);
|
|
if (mfile == NULL)
|
|
return -ENOMEM;
|
|
mfile->file = file;
|
|
mfile->disconnected_f_op = NULL;
|
|
INIT_LIST_HEAD(&mfile->shutdown_list);
|
|
spin_lock(&card->files_lock);
|
|
if (card->shutdown) {
|
|
spin_unlock(&card->files_lock);
|
|
kfree(mfile);
|
|
return -ENODEV;
|
|
}
|
|
list_add(&mfile->list, &card->files_list);
|
|
get_device(&card->card_dev);
|
|
spin_unlock(&card->files_lock);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(snd_card_file_add);
|
|
|
|
/**
|
|
* 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.
|
|
* If all files are removed and snd_card_free_when_closed() was
|
|
* called beforehand, it processes the pending release of
|
|
* resources.
|
|
*
|
|
* Return: Zero or a negative error code.
|
|
*/
|
|
int snd_card_file_remove(struct snd_card *card, struct file *file)
|
|
{
|
|
struct snd_monitor_file *mfile, *found = NULL;
|
|
|
|
spin_lock(&card->files_lock);
|
|
list_for_each_entry(mfile, &card->files_list, list) {
|
|
if (mfile->file == file) {
|
|
list_del(&mfile->list);
|
|
spin_lock(&shutdown_lock);
|
|
list_del(&mfile->shutdown_list);
|
|
spin_unlock(&shutdown_lock);
|
|
if (mfile->disconnected_f_op)
|
|
fops_put(mfile->disconnected_f_op);
|
|
found = mfile;
|
|
break;
|
|
}
|
|
}
|
|
spin_unlock(&card->files_lock);
|
|
if (!found) {
|
|
dev_err(card->dev, "card file remove problem (%p)\n", file);
|
|
return -ENOENT;
|
|
}
|
|
kfree(found);
|
|
put_device(&card->card_dev);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(snd_card_file_remove);
|
|
|
|
#ifdef CONFIG_PM
|
|
/**
|
|
* snd_power_wait - wait until the power-state is changed.
|
|
* @card: soundcard structure
|
|
* @power_state: expected power state
|
|
*
|
|
* Waits until the power-state is changed.
|
|
*
|
|
* Return: Zero if successful, or a negative error code.
|
|
*/
|
|
int snd_power_wait(struct snd_card *card, unsigned int power_state)
|
|
{
|
|
wait_queue_entry_t wait;
|
|
int result = 0;
|
|
|
|
/* fastpath */
|
|
if (snd_power_get_state(card) == power_state)
|
|
return 0;
|
|
init_waitqueue_entry(&wait, current);
|
|
add_wait_queue(&card->power_sleep, &wait);
|
|
while (1) {
|
|
if (card->shutdown) {
|
|
result = -ENODEV;
|
|
break;
|
|
}
|
|
if (snd_power_get_state(card) == power_state)
|
|
break;
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
schedule_timeout(30 * HZ);
|
|
}
|
|
remove_wait_queue(&card->power_sleep, &wait);
|
|
return result;
|
|
}
|
|
EXPORT_SYMBOL(snd_power_wait);
|
|
#endif /* CONFIG_PM */
|