[linux-2.6-block.git] / arch / um / drivers / hostaudio_kern.c

/*
 * Copyright (C) 2002 Steve Schmidtke
 * Licensed under the GPL
 */

#include <linux/fs.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/sound.h>
#include <linux/soundcard.h>
#include <linux/mutex.h>
#include <asm/uaccess.h>
#include <init.h>
#include <os.h>

struct hostaudio_state {
	int fd;
};

struct hostmixer_state {
	int fd;
};

#define HOSTAUDIO_DEV_DSP "/dev/sound/dsp"
#define HOSTAUDIO_DEV_MIXER "/dev/sound/mixer"

/*
 * Changed either at boot time or module load time.  At boot, this is
 * single-threaded; at module load, multiple modules would each have
 * their own copy of these variables.
 */
static char *dsp = HOSTAUDIO_DEV_DSP;
static char *mixer = HOSTAUDIO_DEV_MIXER;

#define DSP_HELP \
"    This is used to specify the host dsp device to the hostaudio driver.\n" \
"    The default is \"" HOSTAUDIO_DEV_DSP "\".\n\n"

#define MIXER_HELP \
"    This is used to specify the host mixer device to the hostaudio driver.\n"\
"    The default is \"" HOSTAUDIO_DEV_MIXER "\".\n\n"

module_param(dsp, charp, 0644);
MODULE_PARM_DESC(dsp, DSP_HELP);
module_param(mixer, charp, 0644);
MODULE_PARM_DESC(mixer, MIXER_HELP);

#ifndef MODULE
static int set_dsp(char *name, int *add)
{
	dsp = name;
	return 0;
}

__uml_setup("dsp=", set_dsp, "dsp=<dsp device>\n" DSP_HELP);

static int set_mixer(char *name, int *add)
{
	mixer = name;
	return 0;
}

__uml_setup("mixer=", set_mixer, "mixer=<mixer device>\n" MIXER_HELP);
#endif

static DEFINE_MUTEX(hostaudio_mutex);

/* /dev/dsp file operations */

static ssize_t hostaudio_read(struct file *file, char __user *buffer,
			      size_t count, loff_t *ppos)
{
	struct hostaudio_state *state = file->private_data;
	void *kbuf;
	int err;

#ifdef DEBUG
	printk(KERN_DEBUG "hostaudio: read called, count = %d\n", count);
#endif

	kbuf = kmalloc(count, GFP_KERNEL);
	if (kbuf == NULL)
		return -ENOMEM;

	err = os_read_file(state->fd, kbuf, count);
	if (err < 0)
		goto out;

	if (copy_to_user(buffer, kbuf, err))
		err = -EFAULT;

out:
	kfree(kbuf);
	return err;
}

static ssize_t hostaudio_write(struct file *file, const char __user *buffer,
			       size_t count, loff_t *ppos)
{
	struct hostaudio_state *state = file->private_data;
	void *kbuf;
	int err;

#ifdef DEBUG
	printk(KERN_DEBUG "hostaudio: write called, count = %d\n", count);
#endif

	kbuf = kmalloc(count, GFP_KERNEL);
	if (kbuf == NULL)
		return -ENOMEM;

	err = -EFAULT;
	if (copy_from_user(kbuf, buffer, count))
		goto out;

	err = os_write_file(state->fd, kbuf, count);
	if (err < 0)
		goto out;
	*ppos += err;

 out:
	kfree(kbuf);
	return err;
}

static unsigned int hostaudio_poll(struct file *file,
				   struct poll_table_struct *wait)
{
	unsigned int mask = 0;

#ifdef DEBUG
	printk(KERN_DEBUG "hostaudio: poll called (unimplemented)\n");
#endif

	return mask;
}

static long hostaudio_ioctl(struct file *file,
			   unsigned int cmd, unsigned long arg)
{
	struct hostaudio_state *state = file->private_data;
	unsigned long data = 0;
	int err;

#ifdef DEBUG
	printk(KERN_DEBUG "hostaudio: ioctl called, cmd = %u\n", cmd);
#endif
	switch(cmd){
	case SNDCTL_DSP_SPEED:
	case SNDCTL_DSP_STEREO:
	case SNDCTL_DSP_GETBLKSIZE:
	case SNDCTL_DSP_CHANNELS:
	case SNDCTL_DSP_SUBDIVIDE:
	case SNDCTL_DSP_SETFRAGMENT:
		if (get_user(data, (int __user *) arg))
			return -EFAULT;
		break;
	default:
		break;
	}

	err = os_ioctl_generic(state->fd, cmd, (unsigned long) &data);

	switch(cmd){
	case SNDCTL_DSP_SPEED:
	case SNDCTL_DSP_STEREO:
	case SNDCTL_DSP_GETBLKSIZE:
	case SNDCTL_DSP_CHANNELS:
	case SNDCTL_DSP_SUBDIVIDE:
	case SNDCTL_DSP_SETFRAGMENT:
		if (put_user(data, (int __user *) arg))
			return -EFAULT;
		break;
	default:
		break;
	}

	return err;
}

static int hostaudio_open(struct inode *inode, struct file *file)
{
	struct hostaudio_state *state;
	int r = 0, w = 0;
	int ret;

#ifdef DEBUG
	kernel_param_lock(THIS_MODULE);
	printk(KERN_DEBUG "hostaudio: open called (host: %s)\n", dsp);
	kernel_param_unlock(THIS_MODULE);
#endif

	state = kmalloc(sizeof(struct hostaudio_state), GFP_KERNEL);
	if (state == NULL)
		return -ENOMEM;

	if (file->f_mode & FMODE_READ)
		r = 1;
	if (file->f_mode & FMODE_WRITE)
		w = 1;

	kernel_param_lock(THIS_MODULE);
	mutex_lock(&hostaudio_mutex);
	ret = os_open_file(dsp, of_set_rw(OPENFLAGS(), r, w), 0);
	mutex_unlock(&hostaudio_mutex);
	kernel_param_unlock(THIS_MODULE);

	if (ret < 0) {
		kfree(state);
		return ret;
	}
	state->fd = ret;
	file->private_data = state;
	return 0;
}

static int hostaudio_release(struct inode *inode, struct file *file)
{
	struct hostaudio_state *state = file->private_data;

#ifdef DEBUG
	printk(KERN_DEBUG "hostaudio: release called\n");
#endif
	os_close_file(state->fd);
	kfree(state);

	return 0;
}

/* /dev/mixer file operations */

static long hostmixer_ioctl_mixdev(struct file *file,
				  unsigned int cmd, unsigned long arg)
{
	struct hostmixer_state *state = file->private_data;

#ifdef DEBUG
	printk(KERN_DEBUG "hostmixer: ioctl called\n");
#endif

	return os_ioctl_generic(state->fd, cmd, arg);
}

static int hostmixer_open_mixdev(struct inode *inode, struct file *file)
{
	struct hostmixer_state *state;
	int r = 0, w = 0;
	int ret;

#ifdef DEBUG
	printk(KERN_DEBUG "hostmixer: open called (host: %s)\n", mixer);
#endif

	state = kmalloc(sizeof(struct hostmixer_state), GFP_KERNEL);
	if (state == NULL)
		return -ENOMEM;

	if (file->f_mode & FMODE_READ)
		r = 1;
	if (file->f_mode & FMODE_WRITE)
		w = 1;

	kernel_param_lock(THIS_MODULE);
	mutex_lock(&hostaudio_mutex);
	ret = os_open_file(mixer, of_set_rw(OPENFLAGS(), r, w), 0);
	mutex_unlock(&hostaudio_mutex);
	kernel_param_unlock(THIS_MODULE);

	if (ret < 0) {
		kernel_param_lock(THIS_MODULE);
		printk(KERN_ERR "hostaudio_open_mixdev failed to open '%s', "
		       "err = %d\n", dsp, -ret);
		kernel_param_unlock(THIS_MODULE);
		kfree(state);
		return ret;
	}

	file->private_data = state;
	return 0;
}

static int hostmixer_release(struct inode *inode, struct file *file)
{
	struct hostmixer_state *state = file->private_data;

#ifdef DEBUG
	printk(KERN_DEBUG "hostmixer: release called\n");
#endif

	os_close_file(state->fd);
	kfree(state);

	return 0;
}

/* kernel module operations */

static const struct file_operations hostaudio_fops = {
	.owner          = THIS_MODULE,
	.llseek         = no_llseek,
	.read           = hostaudio_read,
	.write          = hostaudio_write,
	.poll           = hostaudio_poll,
	.unlocked_ioctl	= hostaudio_ioctl,
	.mmap           = NULL,
	.open           = hostaudio_open,
	.release        = hostaudio_release,
};

static const struct file_operations hostmixer_fops = {
	.owner          = THIS_MODULE,
	.llseek         = no_llseek,
	.unlocked_ioctl	= hostmixer_ioctl_mixdev,
	.open           = hostmixer_open_mixdev,
	.release        = hostmixer_release,
};

struct {
	int dev_audio;
	int dev_mixer;
} module_data;

MODULE_AUTHOR("Steve Schmidtke");
MODULE_DESCRIPTION("UML Audio Relay");
MODULE_LICENSE("GPL");

static int __init hostaudio_init_module(void)
{
	kernel_param_lock(THIS_MODULE);
	printk(KERN_INFO "UML Audio Relay (host dsp = %s, host mixer = %s)\n",
	       dsp, mixer);
	kernel_param_unlock(THIS_MODULE);

	module_data.dev_audio = register_sound_dsp(&hostaudio_fops, -1);
	if (module_data.dev_audio < 0) {
		printk(KERN_ERR "hostaudio: couldn't register DSP device!\n");
		return -ENODEV;
	}

	module_data.dev_mixer = register_sound_mixer(&hostmixer_fops, -1);
	if (module_data.dev_mixer < 0) {
		printk(KERN_ERR "hostmixer: couldn't register mixer "
		       "device!\n");
		unregister_sound_dsp(module_data.dev_audio);
		return -ENODEV;
	}

	return 0;
}

static void __exit hostaudio_cleanup_module (void)
{
	unregister_sound_mixer(module_data.dev_mixer);
	unregister_sound_dsp(module_data.dev_audio);
}

module_init(hostaudio_init_module);
module_exit(hostaudio_cleanup_module);
Commit	Line	Data
cb8fa61c JD	1	/*
cb8fa61c JD	2	* Copyright (C) 2002 Steve Schmidtke
1da177e4 LT	3	* Licensed under the GPL
	4	*/
	5
37185b33 AV	6	#include <linux/fs.h>
	7	#include <linux/module.h>
	8	#include <linux/slab.h>
	9	#include <linux/sound.h>
	10	#include <linux/soundcard.h>
	11	#include <linux/mutex.h>
	12	#include <asm/uaccess.h>
	13	#include <init.h>
	14	#include <os.h>
1da177e4 LT	15
1da177e4 LT	16	struct hostaudio_state {
d471c0fc	17	int fd;
1da177e4 LT	18	};
	19
	20	struct hostmixer_state {
d471c0fc	21	int fd;
1da177e4 LT	22	};
	23
	24	#define HOSTAUDIO_DEV_DSP "/dev/sound/dsp"
	25	#define HOSTAUDIO_DEV_MIXER "/dev/sound/mixer"
	26
cb8fa61c JD	27	/*
cb8fa61c JD	28	* Changed either at boot time or module load time. At boot, this is
b612e475 JD	29	* single-threaded; at module load, multiple modules would each have
	30	* their own copy of these variables.
	31	*/
	32	static char *dsp = HOSTAUDIO_DEV_DSP;
	33	static char *mixer = HOSTAUDIO_DEV_MIXER;
1da177e4 LT	34
	35	#define DSP_HELP \
	36	" This is used to specify the host dsp device to the hostaudio driver.\n" \
	37	" The default is \"" HOSTAUDIO_DEV_DSP "\".\n\n"
	38
	39	#define MIXER_HELP \
	40	" This is used to specify the host mixer device to the hostaudio driver.\n"\
	41	" The default is \"" HOSTAUDIO_DEV_MIXER "\".\n\n"
	42
e3c6cf61 FT	43	module_param(dsp, charp, 0644);
	44	MODULE_PARM_DESC(dsp, DSP_HELP);
	45	module_param(mixer, charp, 0644);
	46	MODULE_PARM_DESC(mixer, MIXER_HELP);
	47
1da177e4 LT	48	#ifndef MODULE
	49	static int set_dsp(char name, int add)
	50	{
	51	dsp = name;
cb8fa61c	52	return 0;
1da177e4 LT	53	}
	54
	55	__uml_setup("dsp=", set_dsp, "dsp=<dsp device>\n" DSP_HELP);
	56
	57	static int set_mixer(char name, int add)
	58	{
	59	mixer = name;
cb8fa61c	60	return 0;
1da177e4 LT	61	}
	62
	63	__uml_setup("mixer=", set_mixer, "mixer=<mixer device>\n" MIXER_HELP);
1da177e4 LT	64	#endif
1da177e4 LT	65
9a181c58 AB	66	static DEFINE_MUTEX(hostaudio_mutex);
9a181c58 AB	67
1da177e4 LT	68	/* /dev/dsp file operations */
1da177e4 LT	69
4d338e1a AV	70	static ssize_t hostaudio_read(struct file file, char __user buffer,
4d338e1a AV	71	size_t count, loff_t *ppos)
1da177e4	72	{
d471c0fc	73	struct hostaudio_state *state = file->private_data;
1da177e4 LT	74	void *kbuf;
	75	int err;
	76
	77	#ifdef DEBUG
cb8fa61c	78	printk(KERN_DEBUG "hostaudio: read called, count = %d\n", count);
1da177e4 LT	79	#endif
	80
	81	kbuf = kmalloc(count, GFP_KERNEL);
cb8fa61c JD	82	if (kbuf == NULL)
cb8fa61c JD	83	return -ENOMEM;
1da177e4	84
a6ea4cce	85	err = os_read_file(state->fd, kbuf, count);
cb8fa61c	86	if (err < 0)
1da177e4 LT	87	goto out;
1da177e4 LT	88
cb8fa61c	89	if (copy_to_user(buffer, kbuf, err))
1da177e4 LT	90	err = -EFAULT;
1da177e4 LT	91
d471c0fc	92	out:
1da177e4	93	kfree(kbuf);
cb8fa61c	94	return err;
1da177e4 LT	95	}
1da177e4 LT	96
4d338e1a	97	static ssize_t hostaudio_write(struct file file, const char __user buffer,
1da177e4 LT	98	size_t count, loff_t *ppos)
1da177e4 LT	99	{
d471c0fc	100	struct hostaudio_state *state = file->private_data;
1da177e4 LT	101	void *kbuf;
	102	int err;
	103
	104	#ifdef DEBUG
cb8fa61c	105	printk(KERN_DEBUG "hostaudio: write called, count = %d\n", count);
1da177e4 LT	106	#endif
	107
	108	kbuf = kmalloc(count, GFP_KERNEL);
cb8fa61c JD	109	if (kbuf == NULL)
cb8fa61c JD	110	return -ENOMEM;
1da177e4 LT	111
1da177e4 LT	112	err = -EFAULT;
cb8fa61c	113	if (copy_from_user(kbuf, buffer, count))
1da177e4 LT	114	goto out;
1da177e4 LT	115
a6ea4cce	116	err = os_write_file(state->fd, kbuf, count);
cb8fa61c	117	if (err < 0)
1da177e4 LT	118	goto out;
	119	*ppos += err;
	120
	121	out:
	122	kfree(kbuf);
cb8fa61c	123	return err;
1da177e4 LT	124	}
1da177e4 LT	125
cb8fa61c	126	static unsigned int hostaudio_poll(struct file *file,
1da177e4 LT	127	struct poll_table_struct *wait)
1da177e4 LT	128	{
d471c0fc	129	unsigned int mask = 0;
1da177e4 LT	130
1da177e4 LT	131	#ifdef DEBUG
cb8fa61c	132	printk(KERN_DEBUG "hostaudio: poll called (unimplemented)\n");
1da177e4 LT	133	#endif
1da177e4 LT	134
cb8fa61c	135	return mask;
1da177e4 LT	136	}
1da177e4 LT	137
d6c89d9a	138	static long hostaudio_ioctl(struct file *file,
1da177e4 LT	139	unsigned int cmd, unsigned long arg)
1da177e4 LT	140	{
d471c0fc	141	struct hostaudio_state *state = file->private_data;
1da177e4 LT	142	unsigned long data = 0;
	143	int err;
	144
	145	#ifdef DEBUG
cb8fa61c	146	printk(KERN_DEBUG "hostaudio: ioctl called, cmd = %u\n", cmd);
1da177e4 LT	147	#endif
	148	switch(cmd){
	149	case SNDCTL_DSP_SPEED:
	150	case SNDCTL_DSP_STEREO:
	151	case SNDCTL_DSP_GETBLKSIZE:
	152	case SNDCTL_DSP_CHANNELS:
	153	case SNDCTL_DSP_SUBDIVIDE:
	154	case SNDCTL_DSP_SETFRAGMENT:
cb8fa61c	155	if (get_user(data, (int __user *) arg))
484f1e2c	156	return -EFAULT;
1da177e4 LT	157	break;
	158	default:
	159	break;
	160	}
	161
	162	err = os_ioctl_generic(state->fd, cmd, (unsigned long) &data);
	163
	164	switch(cmd){
	165	case SNDCTL_DSP_SPEED:
	166	case SNDCTL_DSP_STEREO:
	167	case SNDCTL_DSP_GETBLKSIZE:
	168	case SNDCTL_DSP_CHANNELS:
	169	case SNDCTL_DSP_SUBDIVIDE:
	170	case SNDCTL_DSP_SETFRAGMENT:
cb8fa61c JD	171	if (put_user(data, (int __user *) arg))
cb8fa61c JD	172	return -EFAULT;
1da177e4 LT	173	break;
	174	default:
	175	break;
	176	}
	177
cb8fa61c	178	return err;
1da177e4 LT	179	}
	180
	181	static int hostaudio_open(struct inode inode, struct file file)
	182	{
d471c0fc JD	183	struct hostaudio_state *state;
	184	int r = 0, w = 0;
	185	int ret;
1da177e4 LT	186
1da177e4 LT	187	#ifdef DEBUG
b51d23e4	188	kernel_param_lock(THIS_MODULE);
cb8fa61c	189	printk(KERN_DEBUG "hostaudio: open called (host: %s)\n", dsp);
b51d23e4	190	kernel_param_unlock(THIS_MODULE);
1da177e4 LT	191	#endif
1da177e4 LT	192
d471c0fc	193	state = kmalloc(sizeof(struct hostaudio_state), GFP_KERNEL);
cb8fa61c JD	194	if (state == NULL)
cb8fa61c JD	195	return -ENOMEM;
1da177e4	196
cb8fa61c JD	197	if (file->f_mode & FMODE_READ)
	198	r = 1;
	199	if (file->f_mode & FMODE_WRITE)
	200	w = 1;
1da177e4	201
b51d23e4	202	kernel_param_lock(THIS_MODULE);
9a181c58	203	mutex_lock(&hostaudio_mutex);
1da177e4	204	ret = os_open_file(dsp, of_set_rw(OPENFLAGS(), r, w), 0);
9a181c58	205	mutex_unlock(&hostaudio_mutex);
b51d23e4	206	kernel_param_unlock(THIS_MODULE);
90dc763f	207
cb8fa61c	208	if (ret < 0) {
1da177e4	209	kfree(state);
cb8fa61c	210	return ret;
d471c0fc	211	}
1da177e4	212	state->fd = ret;
d471c0fc	213	file->private_data = state;
cb8fa61c	214	return 0;
1da177e4 LT	215	}
	216
	217	static int hostaudio_release(struct inode inode, struct file file)
	218	{
d471c0fc	219	struct hostaudio_state *state = file->private_data;
1da177e4 LT	220
1da177e4 LT	221	#ifdef DEBUG
cb8fa61c	222	printk(KERN_DEBUG "hostaudio: release called\n");
1da177e4	223	#endif
d471c0fc JD	224	os_close_file(state->fd);
d471c0fc JD	225	kfree(state);
1da177e4	226
cb8fa61c	227	return 0;
1da177e4 LT	228	}
	229
	230	/* /dev/mixer file operations */
	231
d6c89d9a	232	static long hostmixer_ioctl_mixdev(struct file *file,
1da177e4 LT	233	unsigned int cmd, unsigned long arg)
1da177e4 LT	234	{
d471c0fc	235	struct hostmixer_state *state = file->private_data;
1da177e4 LT	236
1da177e4 LT	237	#ifdef DEBUG
cb8fa61c	238	printk(KERN_DEBUG "hostmixer: ioctl called\n");
1da177e4 LT	239	#endif
1da177e4 LT	240
cb8fa61c	241	return os_ioctl_generic(state->fd, cmd, arg);
1da177e4 LT	242	}
	243
	244	static int hostmixer_open_mixdev(struct inode inode, struct file file)
	245	{
d471c0fc JD	246	struct hostmixer_state *state;
	247	int r = 0, w = 0;
	248	int ret;
1da177e4 LT	249
1da177e4 LT	250	#ifdef DEBUG
cb8fa61c	251	printk(KERN_DEBUG "hostmixer: open called (host: %s)\n", mixer);
1da177e4 LT	252	#endif
1da177e4 LT	253
d471c0fc	254	state = kmalloc(sizeof(struct hostmixer_state), GFP_KERNEL);
cb8fa61c JD	255	if (state == NULL)
cb8fa61c JD	256	return -ENOMEM;
1da177e4	257
cb8fa61c JD	258	if (file->f_mode & FMODE_READ)
	259	r = 1;
	260	if (file->f_mode & FMODE_WRITE)
	261	w = 1;
1da177e4	262
b51d23e4	263	kernel_param_lock(THIS_MODULE);
9a181c58	264	mutex_lock(&hostaudio_mutex);
1da177e4	265	ret = os_open_file(mixer, of_set_rw(OPENFLAGS(), r, w), 0);
9a181c58	266	mutex_unlock(&hostaudio_mutex);
b51d23e4	267	kernel_param_unlock(THIS_MODULE);
cb8fa61c JD	268
cb8fa61c JD	269	if (ret < 0) {
b51d23e4	270	kernel_param_lock(THIS_MODULE);
cb8fa61c JD	271	printk(KERN_ERR "hostaudio_open_mixdev failed to open '%s', "
cb8fa61c JD	272	"err = %d\n", dsp, -ret);
b51d23e4	273	kernel_param_unlock(THIS_MODULE);
1da177e4	274	kfree(state);
cb8fa61c	275	return ret;
d471c0fc	276	}
1da177e4	277
d471c0fc	278	file->private_data = state;
cb8fa61c	279	return 0;
1da177e4 LT	280	}
	281
	282	static int hostmixer_release(struct inode inode, struct file file)
	283	{
d471c0fc	284	struct hostmixer_state *state = file->private_data;
1da177e4 LT	285
1da177e4 LT	286	#ifdef DEBUG
cb8fa61c	287	printk(KERN_DEBUG "hostmixer: release called\n");
1da177e4 LT	288	#endif
1da177e4 LT	289
d471c0fc JD	290	os_close_file(state->fd);
d471c0fc JD	291	kfree(state);
1da177e4	292
cb8fa61c	293	return 0;
1da177e4 LT	294	}
1da177e4 LT	295
1da177e4 LT	296	/* kernel module operations */
1da177e4 LT	297
5e7672ec	298	static const struct file_operations hostaudio_fops = {
d471c0fc JD	299	.owner = THIS_MODULE,
	300	.llseek = no_llseek,
	301	.read = hostaudio_read,
	302	.write = hostaudio_write,
	303	.poll = hostaudio_poll,
d6c89d9a	304	.unlocked_ioctl = hostaudio_ioctl,
d471c0fc JD	305	.mmap = NULL,
	306	.open = hostaudio_open,
	307	.release = hostaudio_release,
1da177e4 LT	308	};
1da177e4 LT	309
5e7672ec	310	static const struct file_operations hostmixer_fops = {
d471c0fc JD	311	.owner = THIS_MODULE,
d471c0fc JD	312	.llseek = no_llseek,
d6c89d9a	313	.unlocked_ioctl = hostmixer_ioctl_mixdev,
d471c0fc JD	314	.open = hostmixer_open_mixdev,
d471c0fc JD	315	.release = hostmixer_release,
1da177e4 LT	316	};
	317
	318	struct {
	319	int dev_audio;
	320	int dev_mixer;
	321	} module_data;
	322
	323	MODULE_AUTHOR("Steve Schmidtke");
	324	MODULE_DESCRIPTION("UML Audio Relay");
	325	MODULE_LICENSE("GPL");
	326
	327	static int __init hostaudio_init_module(void)
	328	{
b51d23e4	329	kernel_param_lock(THIS_MODULE);
d471c0fc	330	printk(KERN_INFO "UML Audio Relay (host dsp = %s, host mixer = %s)\n",
1da177e4	331	dsp, mixer);
b51d23e4	332	kernel_param_unlock(THIS_MODULE);
1da177e4 LT	333
1da177e4 LT	334	module_data.dev_audio = register_sound_dsp(&hostaudio_fops, -1);
cb8fa61c	335	if (module_data.dev_audio < 0) {
d471c0fc JD	336	printk(KERN_ERR "hostaudio: couldn't register DSP device!\n");
	337	return -ENODEV;
	338	}
1da177e4 LT	339
1da177e4 LT	340	module_data.dev_mixer = register_sound_mixer(&hostmixer_fops, -1);
cb8fa61c	341	if (module_data.dev_mixer < 0) {
d471c0fc	342	printk(KERN_ERR "hostmixer: couldn't register mixer "
1da177e4	343	"device!\n");
d471c0fc JD	344	unregister_sound_dsp(module_data.dev_audio);
	345	return -ENODEV;
	346	}
1da177e4	347
d471c0fc	348	return 0;
1da177e4 LT	349	}
	350
	351	static void __exit hostaudio_cleanup_module (void)
	352	{
d471c0fc JD	353	unregister_sound_mixer(module_data.dev_mixer);
d471c0fc JD	354	unregister_sound_dsp(module_data.dev_audio);
1da177e4 LT	355	}
	356
	357	module_init(hostaudio_init_module);
	358	module_exit(hostaudio_cleanup_module);