[deliverable/linux.git] / sound / drivers / opl4 / opl4_proc.c

/*
 * Functions for the OPL4 proc file
 * Copyright (c) 2003 by Clemens Ladisch <clemens@ladisch.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
 */

#include "opl4_local.h"
#include <linux/vmalloc.h>
#include <linux/export.h>
#include <sound/info.h>

#ifdef CONFIG_PROC_FS

static int snd_opl4_mem_proc_open(struct snd_info_entry *entry,
				  unsigned short mode, void **file_private_data)
{
	struct snd_opl4 *opl4 = entry->private_data;

	mutex_lock(&opl4->access_mutex);
	if (opl4->memory_access) {
		mutex_unlock(&opl4->access_mutex);
		return -EBUSY;
	}
	opl4->memory_access++;
	mutex_unlock(&opl4->access_mutex);
	return 0;
}

static int snd_opl4_mem_proc_release(struct snd_info_entry *entry,
				     unsigned short mode, void *file_private_data)
{
	struct snd_opl4 *opl4 = entry->private_data;

	mutex_lock(&opl4->access_mutex);
	opl4->memory_access--;
	mutex_unlock(&opl4->access_mutex);
	return 0;
}

static ssize_t snd_opl4_mem_proc_read(struct snd_info_entry *entry,
				      void *file_private_data,
				      struct file *file, char __user *_buf,
				      size_t count, loff_t pos)
{
	struct snd_opl4 *opl4 = entry->private_data;
	char* buf;

	buf = vmalloc(count);
	if (!buf)
		return -ENOMEM;
	snd_opl4_read_memory(opl4, buf, pos, count);
	if (copy_to_user(_buf, buf, count)) {
		vfree(buf);
		return -EFAULT;
	}
	vfree(buf);
	return count;
}

static ssize_t snd_opl4_mem_proc_write(struct snd_info_entry *entry,
				       void *file_private_data,
				       struct file *file,
				       const char __user *_buf,
				       size_t count, loff_t pos)
{
	struct snd_opl4 *opl4 = entry->private_data;
	char *buf;

	buf = vmalloc(count);
	if (!buf)
		return -ENOMEM;
	if (copy_from_user(buf, _buf, count)) {
		vfree(buf);
		return -EFAULT;
	}
	snd_opl4_write_memory(opl4, buf, pos, count);
	vfree(buf);
	return count;
}

static struct snd_info_entry_ops snd_opl4_mem_proc_ops = {
	.open = snd_opl4_mem_proc_open,
	.release = snd_opl4_mem_proc_release,
	.read = snd_opl4_mem_proc_read,
	.write = snd_opl4_mem_proc_write,
};

int snd_opl4_create_proc(struct snd_opl4 *opl4)
{
	struct snd_info_entry *entry;

	entry = snd_info_create_card_entry(opl4->card, "opl4-mem", opl4->card->proc_root);
	if (entry) {
		if (opl4->hardware < OPL3_HW_OPL4_ML) {
			/* OPL4 can access 4 MB external ROM/SRAM */
			entry->mode |= S_IWUSR;
			entry->size = 4 * 1024 * 1024;
		} else {
			/* OPL4-ML has 1 MB internal ROM */
			entry->size = 1 * 1024 * 1024;
		}
		entry->content = SNDRV_INFO_CONTENT_DATA;
		entry->c.ops = &snd_opl4_mem_proc_ops;
		entry->module = THIS_MODULE;
		entry->private_data = opl4;
		if (snd_info_register(entry) < 0) {
			snd_info_free_entry(entry);
			entry = NULL;
		}
	}
	opl4->proc_entry = entry;
	return 0;
}

void snd_opl4_free_proc(struct snd_opl4 *opl4)
{
	snd_info_free_entry(opl4->proc_entry);
}

#endif /* CONFIG_PROC_FS */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Functions for the OPL4 proc file
	3	* Copyright (c) 2003 by Clemens Ladisch <clemens@ladisch.de>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
	19
	20	#include "opl4_local.h"
	21	#include <linux/vmalloc.h>
d81a6d71	22	#include <linux/export.h>
1da177e4 LT	23	#include <sound/info.h>
	24
	25	#ifdef CONFIG_PROC_FS
	26
a42dd420	27	static int snd_opl4_mem_proc_open(struct snd_info_entry *entry,
1da177e4 LT	28	unsigned short mode, void **file_private_data)
1da177e4 LT	29	{
a42dd420	30	struct snd_opl4 *opl4 = entry->private_data;
1da177e4	31
ef9f0a42	32	mutex_lock(&opl4->access_mutex);
1da177e4	33	if (opl4->memory_access) {
ef9f0a42	34	mutex_unlock(&opl4->access_mutex);
1da177e4 LT	35	return -EBUSY;
	36	}
	37	opl4->memory_access++;
ef9f0a42	38	mutex_unlock(&opl4->access_mutex);
1da177e4 LT	39	return 0;
	40	}
	41
a42dd420	42	static int snd_opl4_mem_proc_release(struct snd_info_entry *entry,
1da177e4 LT	43	unsigned short mode, void *file_private_data)
1da177e4 LT	44	{
a42dd420	45	struct snd_opl4 *opl4 = entry->private_data;
1da177e4	46
ef9f0a42	47	mutex_lock(&opl4->access_mutex);
1da177e4	48	opl4->memory_access--;
ef9f0a42	49	mutex_unlock(&opl4->access_mutex);
1da177e4 LT	50	return 0;
	51	}
	52
24e4a121 TI	53	static ssize_t snd_opl4_mem_proc_read(struct snd_info_entry *entry,
	54	void *file_private_data,
	55	struct file file, char __user _buf,
	56	size_t count, loff_t pos)
1da177e4	57	{
a42dd420	58	struct snd_opl4 *opl4 = entry->private_data;
1da177e4 LT	59	char* buf;
1da177e4 LT	60
d97e1b78 TI	61	buf = vmalloc(count);
	62	if (!buf)
	63	return -ENOMEM;
	64	snd_opl4_read_memory(opl4, buf, pos, count);
	65	if (copy_to_user(_buf, buf, count)) {
1da177e4	66	vfree(buf);
d97e1b78	67	return -EFAULT;
1da177e4	68	}
d97e1b78 TI	69	vfree(buf);
d97e1b78 TI	70	return count;
1da177e4 LT	71	}
1da177e4 LT	72
24e4a121 TI	73	static ssize_t snd_opl4_mem_proc_write(struct snd_info_entry *entry,
	74	void *file_private_data,
	75	struct file *file,
	76	const char __user *_buf,
670ff6ab	77	size_t count, loff_t pos)
1da177e4	78	{
a42dd420	79	struct snd_opl4 *opl4 = entry->private_data;
1da177e4 LT	80	char *buf;
1da177e4 LT	81
d97e1b78 TI	82	buf = vmalloc(count);
	83	if (!buf)
	84	return -ENOMEM;
	85	if (copy_from_user(buf, _buf, count)) {
1da177e4	86	vfree(buf);
d97e1b78	87	return -EFAULT;
1da177e4	88	}
d97e1b78 TI	89	snd_opl4_write_memory(opl4, buf, pos, count);
	90	vfree(buf);
	91	return count;
1da177e4 LT	92	}
1da177e4 LT	93
1da177e4 LT	94	static struct snd_info_entry_ops snd_opl4_mem_proc_ops = {
	95	.open = snd_opl4_mem_proc_open,
	96	.release = snd_opl4_mem_proc_release,
	97	.read = snd_opl4_mem_proc_read,
	98	.write = snd_opl4_mem_proc_write,
1da177e4 LT	99	};
1da177e4 LT	100
a42dd420	101	int snd_opl4_create_proc(struct snd_opl4 *opl4)
1da177e4	102	{
a42dd420	103	struct snd_info_entry *entry;
1da177e4 LT	104
	105	entry = snd_info_create_card_entry(opl4->card, "opl4-mem", opl4->card->proc_root);
	106	if (entry) {
	107	if (opl4->hardware < OPL3_HW_OPL4_ML) {
	108	/* OPL4 can access 4 MB external ROM/SRAM */
	109	entry->mode \|= S_IWUSR;
	110	entry->size = 4 * 1024 * 1024;
	111	} else {
	112	/* OPL4-ML has 1 MB internal ROM */
	113	entry->size = 1 * 1024 * 1024;
	114	}
	115	entry->content = SNDRV_INFO_CONTENT_DATA;
	116	entry->c.ops = &snd_opl4_mem_proc_ops;
	117	entry->module = THIS_MODULE;
	118	entry->private_data = opl4;
	119	if (snd_info_register(entry) < 0) {
	120	snd_info_free_entry(entry);
	121	entry = NULL;
	122	}
	123	}
	124	opl4->proc_entry = entry;
	125	return 0;
	126	}
	127
a42dd420	128	void snd_opl4_free_proc(struct snd_opl4 *opl4)
1da177e4	129	{
746d4a02	130	snd_info_free_entry(opl4->proc_entry);
1da177e4 LT	131	}
	132
	133	#endif /* CONFIG_PROC_FS */