cregit-Linux how code gets into the kernel

Release 4.17 sound/core/init.c

Directory: sound/core
/*
 *  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; }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai144100.00%3100.00%
Total144100.00%3100.00%

#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); }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela2586.21%150.00%
Takashi Iwai413.79%150.00%
Total29100.00%2100.00%


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); }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai6997.18%375.00%
Colin Ian King22.82%125.00%
Total71100.00%4100.00%

#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]; }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai28100.00%1100.00%
Total28100.00%1100.00%

/* 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 */ }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai92100.00%1100.00%
Total92100.00%1100.00%

/* 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) { }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai10100.00%1100.00%
Total10100.00%1100.00%

/** * 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; }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai45100.00%1100.00%
Total45100.00%1100.00%

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)); }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai19100.00%1100.00%
Total19100.00%1100.00%

/** * 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 init_waitqueue_head(&card->remove_sleep); 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; }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela28048.87%1037.04%
Takashi Iwai25845.03%1555.56%
Heiner Kallweit315.41%13.70%
Oliver Neukum40.70%13.70%
Total573100.00%27100.00%

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; }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai35100.00%2100.00%
Total35100.00%2100.00%


static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig) { return -ENODEV; }

Contributors

PersonTokensPropCommitsCommitProp
Clemens Ladisch21100.00%1100.00%
Total21100.00%1100.00%


static ssize_t snd_disconnect_read(struct file *file, char __user *buf, size_t count, loff_t *offset) { return -ENODEV; }

Contributors

PersonTokensPropCommitsCommitProp
Clemens Ladisch27100.00%1100.00%
Total27100.00%1100.00%


static ssize_t snd_disconnect_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) { return -ENODEV; }

Contributors

PersonTokensPropCommitsCommitProp
Clemens Ladisch28100.00%1100.00%
Total28100.00%1100.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; 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); }

Contributors

PersonTokensPropCommitsCommitProp
Karsten Wiese9269.17%125.00%
Al Viro3224.06%125.00%
Takashi Iwai86.02%125.00%
Harvey Harrison10.75%125.00%
Total133100.00%4100.00%


static __poll_t snd_disconnect_poll(struct file * file, poll_table * wait) { return EPOLLERR | EPOLLNVAL; }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela1785.00%133.33%
Linus Torvalds210.00%133.33%
Al Viro15.00%133.33%
Total20100.00%3100.00%


static long snd_disconnect_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { return -ENODEV; }

Contributors

PersonTokensPropCommitsCommitProp
Clemens Ladisch23100.00%1100.00%
Total23100.00%1100.00%


static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma) { return -ENODEV; }

Contributors

PersonTokensPropCommitsCommitProp
Clemens Ladisch20100.00%1100.00%
Total20100.00%1100.00%


static int snd_disconnect_fasync(int fd, struct file *file, int on) { return -ENODEV; }

Contributors

PersonTokensPropCommitsCommitProp
Clemens Ladisch21100.00%1100.00%
Total21100.00%1100.00%

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; }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela13755.69%425.00%
Takashi Iwai7329.67%956.25%
Karsten Wiese2510.16%16.25%
Miguel Botón93.66%16.25%
Clemens Ladisch20.81%16.25%
Total246100.00%16100.00%

EXPORT_SYMBOL(snd_card_disconnect); /** * 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) { int err; err = snd_card_disconnect(card); if (err < 0) { dev_err(card->dev, "snd_card_disconnect error (%d), skipping sync\n", err); return; } 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); }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai75100.00%1100.00%
Total75100.00%1100.00%

EXPORT_SYMBOL_GPL(snd_card_disconnect_sync);
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; }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela6465.98%222.22%
Takashi Iwai3334.02%777.78%
Total97100.00%9100.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. */
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; }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai36100.00%4100.00%
Total36100.00%4100.00%

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; }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai4888.89%375.00%
Jaroslav Kysela611.11%125.00%
Total54100.00%4100.00%

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; }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela2952.73%250.00%
Takashi Iwai2545.45%125.00%
Mark Brown11.82%125.00%
Total55100.00%4100.00%

/* 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; }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai7697.44%150.00%
Jaroslav Kysela22.56%150.00%
Total78100.00%2100.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; }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela8270.09%480.00%
Takashi Iwai3529.91%120.00%
Total117100.00%5100.00%

/* 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)); }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai17671.54%457.14%
Jaroslav Kysela6626.83%228.57%
Clemens Ladisch41.63%114.29%
Total246100.00%7100.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) { /* 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); }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela2653.06%133.33%
Mark Brown2142.86%133.33%
Takashi Iwai24.08%133.33%
Total49100.00%3100.00%

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 scnprintf(buf, PAGE_SIZE, "%s\n", card->id); }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela4285.71%133.33%
Takashi Iwai612.24%133.33%
Kim Jae Joong12.04%133.33%
Total49100.00%3100.00%


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; }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela18195.26%250.00%
Takashi Iwai94.74%250.00%
Total190100.00%4100.00%

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 scnprintf(buf, PAGE_SIZE, "%i\n", card->number); }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela4285.71%133.33%
Takashi Iwai612.24%133.33%
Kim Jae Joong12.04%133.33%
Total49100.00%3100.00%

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; }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai7898.73%266.67%
Jaroslav Kysela11.27%133.33%
Total79100.00%3100.00%

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; }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai10846.96%853.33%
Jaroslav Kysela10143.91%533.33%
Greg Kroah-Hartman219.13%213.33%
Total230100.00%15100.00%

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"); }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela10589.74%125.00%
Takashi Iwai108.55%250.00%
Clemens Ladisch21.71%125.00%
Total117100.00%4100.00%

#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"); } }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela8491.30%133.33%
Takashi Iwai88.70%266.67%
Total92100.00%3100.00%

#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); } }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela6886.08%125.00%
Takashi Iwai1012.66%250.00%
Clemens Ladisch11.27%125.00%
Total79100.00%4100.00%

#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; }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela8779.82%240.00%
Takashi Iwai2220.18%360.00%
Total109100.00%5100.00%

#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; }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela12798.45%150.00%
Takashi Iwai21.55%150.00%
Total129100.00%2100.00%

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; }

Contributors

PersonTokensPropCommitsCommitProp
Jaroslav Kysela9876.56%114.29%
Takashi Iwai2620.31%571.43%
Karsten Wiese43.12%114.29%
Total128100.00%7100.00%

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; } } if (list_empty(&card->files_list)) wake_up_all(&card->remove_sleep); 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; }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai7646.63%872.73%
Jaroslav Kysela7344.79%218.18%
Karsten Wiese148.59%19.09%
Total163100.00%11100.00%

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; }

Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai8173.64%333.33%
Jaroslav Kysela2825.45%555.56%
Ingo Molnar10.91%111.11%
Total110100.00%9100.00%

EXPORT_SYMBOL(snd_power_wait); #endif /* CONFIG_PM */

Overall Contributors

PersonTokensPropCommitsCommitProp
Takashi Iwai196345.19%4045.98%
Jaroslav Kysela187643.19%2629.89%
Karsten Wiese2104.83%11.15%
Clemens Ladisch1493.43%22.30%
Al Viro330.76%22.30%
Heiner Kallweit310.71%11.15%
Mark Brown230.53%11.15%
Greg Kroah-Hartman210.48%22.30%
Miguel Botón90.21%11.15%
Paul Gortmaker60.14%22.30%
Yacine Belkadi50.12%11.15%
Oliver Neukum40.09%11.15%
Jie Yang40.09%11.15%
Kim Jae Joong20.05%11.15%
Arjan van de Ven20.05%11.15%
Linus Torvalds20.05%11.15%
Colin Ian King20.05%11.15%
Harvey Harrison10.02%11.15%
Ingo Molnar10.02%11.15%
Total4344100.00%87100.00%
Directory: sound/core
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.