Release 4.17 sound/core/seq_device.c

Directory: sound/core
/*
 *  ALSA sequencer device management
 *  Copyright (c) 1999 by Takashi Iwai <tiwai@suse.de>
 *
 *   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
 *
 *
 *----------------------------------------------------------------
 *
 * This device handler separates the card driver module from sequencer
 * stuff (sequencer core, synth drivers, etc), so that user can avoid
 * to spend unnecessary resources e.g. if he needs only listening to
 * MP3s.
 *
 * The card (or lowlevel) driver creates a sequencer device entry
 * via snd_seq_device_new().  This is an entry pointer to communicate
 * with the sequencer device "driver", which is involved with the
 * actual part to communicate with the sequencer core.
 * Each sequencer device entry has an id string and the corresponding
 * driver with the same id is loaded when required.  For example,
 * lowlevel codes to access emu8000 chip on sbawe card are included in
 * emu8000-synth module.  To activate this module, the hardware
 * resources like i/o port are passed via snd_seq_device argument.
 *
 */

#include <linux/device.h>
#include <linux/init.h>
#include <linux/module.h>
#include <sound/core.h>
#include <sound/info.h>
#include <sound/seq_device.h>
#include <sound/seq_kernel.h>
#include <sound/initval.h>
#include <linux/kmod.h>
#include <linux/slab.h>
#include <linux/mutex.h>

MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
MODULE_DESCRIPTION("ALSA sequencer device management");
MODULE_LICENSE("GPL");

/*
 * bus definition
 */


static int snd_seq_bus_match(struct device *dev, struct device_driver *drv)
{
	struct snd_seq_device *sdev = to_seq_dev(dev);
	struct snd_seq_driver *sdrv = to_seq_drv(drv);

	return strcmp(sdrv->id, sdev->id) == 0 &&
		sdrv->argsize == sdev->argsize;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 44 75.86% 2 50.00%
Jaroslav Kysela 14 24.14% 2 50.00%
Total 58 100.00% 4 100.00%


static struct bus_type snd_seq_bus_type = {
	.name = "snd_seq",
	.match = snd_seq_bus_match,
};

/*
 * proc interface -- just for compatibility
 */
#ifdef CONFIG_SND_PROC_FS

static struct snd_info_entry *info_entry;



static int print_dev_info(struct device *dev, void *data)
{
	struct snd_seq_device *sdev = to_seq_dev(dev);
	struct snd_info_buffer *buffer = data;

	snd_iprintf(buffer, "snd-%s,%s,%d\n", sdev->id,
		    dev->driver ? "loaded" : "empty",
		    dev->driver ? 1 : 0);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 33 53.23% 2 66.67%
Jaroslav Kysela 29 46.77% 1 33.33%
Total 62 100.00% 3 100.00%



static void snd_seq_device_info(struct snd_info_entry *entry,
				struct snd_info_buffer *buffer)
{
	bus_for_each_dev(&snd_seq_bus_type, NULL, buffer, print_dev_info);
}
Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 23 82.14% 1 50.00%
Jaroslav Kysela 5 17.86% 1 50.00%
Total 28 100.00% 2 100.00%

#endif

/*
 * load all registered drivers (called from seq_clientmgr.c)
 */

#ifdef CONFIG_MODULES
/* flag to block auto-loading */

static atomic_t snd_seq_in_init = ATOMIC_INIT(1); 
/* blocked as default */



static int request_seq_drv(struct device *dev, void *data)
{
	struct snd_seq_device *sdev = to_seq_dev(dev);

	if (!dev->driver)
		request_module("snd-%s", sdev->id);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 24 54.55% 2 50.00%
Jaroslav Kysela 19 43.18% 1 25.00%
Linus Torvalds 1 2.27% 1 25.00%
Total 44 100.00% 4 100.00%



static void autoload_drivers(struct work_struct *work)
{
	/* avoid reentrance */
	if (atomic_inc_return(&snd_seq_in_init) == 1)
		bus_for_each_dev(&snd_seq_bus_type, NULL, NULL,
				 request_seq_drv);
	atomic_dec(&snd_seq_in_init);
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 40 100.00% 2 100.00%
Total 40 100.00% 2 100.00%

static DECLARE_WORK(autoload_work, autoload_drivers);



static void queue_autoload_drivers(void)
{
	schedule_work(&autoload_work);
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 14 100.00% 2 100.00%
Total 14 100.00% 2 100.00%



void snd_seq_autoload_init(void)
{
	atomic_dec(&snd_seq_in_init);
#ifdef CONFIG_SND_SEQUENCER_MODULE
	/* initial autoload only when snd-seq is a module */
	queue_autoload_drivers();
#endif
}
Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 22 100.00% 1 100.00%
Total 22 100.00% 1 100.00%

EXPORT_SYMBOL(snd_seq_autoload_init);



void snd_seq_autoload_exit(void)
{
	atomic_inc(&snd_seq_in_init);
}
Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 13 100.00% 1 100.00%
Total 13 100.00% 1 100.00%

EXPORT_SYMBOL(snd_seq_autoload_exit);



void snd_seq_device_load_drivers(void)
{
	queue_autoload_drivers();
	flush_work(&autoload_work);
}
Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 15 93.75% 1 50.00%
Jaroslav Kysela 1 6.25% 1 50.00%
Total 16 100.00% 2 100.00%

EXPORT_SYMBOL(snd_seq_device_load_drivers);

#define cancel_autoload_drivers()	cancel_work_sync(&autoload_work)
#else

#define queue_autoload_drivers() 
/* NOP */

#define cancel_autoload_drivers() 
/* NOP */
#endif

/*
 * device management
 */


static int snd_seq_device_dev_free(struct snd_device *device)
{
	struct snd_seq_device *dev = device->device_data;

	cancel_autoload_drivers();
	put_device(&dev->dev);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 25 73.53% 3 75.00%
Jaroslav Kysela 9 26.47% 1 25.00%
Total 34 100.00% 4 100.00%



static int snd_seq_device_dev_register(struct snd_device *device)
{
	struct snd_seq_device *dev = device->device_data;
	int err;

	err = device_add(&dev->dev);
	if (err < 0)
		return err;
	if (!dev->dev.driver)
		queue_autoload_drivers();
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 57 100.00% 1 100.00%
Total 57 100.00% 1 100.00%



static int snd_seq_device_dev_disconnect(struct snd_device *device)
{
	struct snd_seq_device *dev = device->device_data;

	device_del(&dev->dev);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%



static void snd_seq_dev_release(struct device *dev)
{
	struct snd_seq_device *sdev = to_seq_dev(dev);

	if (sdev->private_free)
		sdev->private_free(sdev);
	kfree(sdev);
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 39 100.00% 1 100.00%
Total 39 100.00% 1 100.00%

/*
 * register a sequencer device
 * card = card info
 * device = device number (if any)
 * id = id of driver
 * result = return pointer (NULL allowed if unnecessary)
 */


int snd_seq_device_new(struct snd_card *card, int device, const char *id,
		       int argsize, struct snd_seq_device **result)
{
	struct snd_seq_device *dev;
	int err;
	static struct snd_device_ops dops = {
		.dev_free = snd_seq_device_dev_free,
		.dev_register = snd_seq_device_dev_register,
		.dev_disconnect = snd_seq_device_dev_disconnect,
        };

	if (result)
		*result = NULL;

	if (snd_BUG_ON(!id))
		return -EINVAL;

	dev = kzalloc(sizeof(*dev) + argsize, GFP_KERNEL);
	if (!dev)
		return -ENOMEM;

	/* set up device info */
	dev->card = card;
	dev->device = device;
	dev->id = id;
	dev->argsize = argsize;

	device_initialize(&dev->dev);
	dev->dev.parent = &card->card_dev;
	dev->dev.bus = &snd_seq_bus_type;
	dev->dev.release = snd_seq_dev_release;
	dev_set_name(&dev->dev, "%s-%d-%d", dev->id, card->number, device);

	/* add this device to the list */
	err = snd_device_new(card, SNDRV_DEV_SEQUENCER, dev, &dops);
	if (err < 0) {
		put_device(&dev->dev);
		return err;
	}
	
	if (result)
		*result = dev;

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Jaroslav Kysela 132 57.64% 3 33.33%
Takashi Iwai 97 42.36% 6 66.67%
Total 229 100.00% 9 100.00%

EXPORT_SYMBOL(snd_seq_device_new);

/*
 * driver registration
 */


int __snd_seq_driver_register(struct snd_seq_driver *drv, struct module *mod)
{
	if (WARN_ON(!drv->driver.name || !drv->id))
		return -EINVAL;
	drv->driver.bus = &snd_seq_bus_type;
	drv->driver.owner = mod;
	return driver_register(&drv->driver);
}
Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 41 66.13% 3 60.00%
Jaroslav Kysela 21 33.87% 2 40.00%
Total 62 100.00% 5 100.00%

EXPORT_SYMBOL_GPL(__snd_seq_driver_register);



void snd_seq_driver_unregister(struct snd_seq_driver *drv)
{
	driver_unregister(&drv->driver);
}
Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 11 61.11% 2 66.67%
Jaroslav Kysela 7 38.89% 1 33.33%
Total 18 100.00% 3 100.00%

EXPORT_SYMBOL_GPL(snd_seq_driver_unregister);

/*
 * module part
 */



static int __init seq_dev_proc_init(void)
{
#ifdef CONFIG_SND_PROC_FS
	info_entry = snd_info_create_module_entry(THIS_MODULE, "drivers",
						  snd_seq_root);
	if (info_entry == NULL)
		return -ENOMEM;
	info_entry->content = SNDRV_INFO_CONTENT_TEXT;
	info_entry->c.text.read = snd_seq_device_info;
	if (snd_info_register(info_entry) < 0) {
		snd_info_free_entry(info_entry);
		return -ENOMEM;
	}
#endif
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jaroslav Kysela 68 91.89% 1 25.00%
Takashi Iwai 6 8.11% 3 75.00%
Total 74 100.00% 4 100.00%



static int __init alsa_seq_device_init(void)
{
	int err;

	err = bus_register(&snd_seq_bus_type);
	if (err < 0)
		return err;
	err = seq_dev_proc_init();
	if (err < 0)
		bus_unregister(&snd_seq_bus_type);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 49 100.00% 1 100.00%
Total 49 100.00% 1 100.00%



static void __exit alsa_seq_device_exit(void)
{
#ifdef CONFIG_MODULES
	cancel_work_sync(&autoload_work);
#endif
#ifdef CONFIG_SND_PROC_FS
	snd_info_free_entry(info_entry);
#endif
	bus_unregister(&snd_seq_bus_type);
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 20 55.56% 5 83.33%
Jaroslav Kysela 16 44.44% 1 16.67%
Total 36 100.00% 6 100.00%

subsys_initcall(alsa_seq_device_init)
module_exit(alsa_seq_device_exit)
Overall Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 704 64.65% 17 58.62%
Jaroslav Kysela 376 34.53% 7 24.14%
Ingo Molnar 3 0.28% 1 3.45%
Paul Gortmaker 3 0.28% 1 3.45%
Johannes Berg 1 0.09% 1 3.45%
Jie Yang 1 0.09% 1 3.45%
Linus Torvalds 1 0.09% 1 3.45%
Total 1089 100.00% 29 100.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.
Person	Tokens	Prop	Commits	CommitProp
Takashi Iwai	44	75.86%	2	50.00%
Jaroslav Kysela	14	24.14%	2	50.00%
Total	58	100.00%	4	100.00%
cregit-Linux how code gets into the kernel

Release 4.17 sound/core/seq_device.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
