[linux-block.git] / sound / isa / gus / gus_mem_proc.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
 *  GUS's memory access via proc filesystem
 */

#include <linux/slab.h>
#include <sound/core.h>
#include <sound/gus.h>
#include <sound/info.h>

struct gus_proc_private {
	int rom;		/* data are in ROM */
	unsigned int address;
	unsigned int size;
	struct snd_gus_card * gus;
};

static ssize_t snd_gf1_mem_proc_dump(struct snd_info_entry *entry,
				     void *file_private_data,
				     struct file *file, char __user *buf,
				     size_t count, loff_t pos)
{
	struct gus_proc_private *priv = entry->private_data;
	struct snd_gus_card *gus = priv->gus;
	int err;

	err = snd_gus_dram_read(gus, buf, pos, count, priv->rom);
	if (err < 0)
		return err;
	return count;
}			

static void snd_gf1_mem_proc_free(struct snd_info_entry *entry)
{
	struct gus_proc_private *priv = entry->private_data;
	kfree(priv);
}

static struct snd_info_entry_ops snd_gf1_mem_proc_ops = {
	.read = snd_gf1_mem_proc_dump,
};

int snd_gf1_mem_proc_init(struct snd_gus_card * gus)
{
	int idx;
	char name[16];
	struct gus_proc_private *priv;
	struct snd_info_entry *entry;

	for (idx = 0; idx < 4; idx++) {
		if (gus->gf1.mem_alloc.banks_8[idx].size > 0) {
			priv = kzalloc(sizeof(*priv), GFP_KERNEL);
			if (priv == NULL)
				return -ENOMEM;
			priv->gus = gus;
			sprintf(name, "gus-ram-%i", idx);
			if (! snd_card_proc_new(gus->card, name, &entry)) {
				entry->content = SNDRV_INFO_CONTENT_DATA;
				entry->private_data = priv;
				entry->private_free = snd_gf1_mem_proc_free;
				entry->c.ops = &snd_gf1_mem_proc_ops;
				priv->address = gus->gf1.mem_alloc.banks_8[idx].address;
				priv->size = entry->size = gus->gf1.mem_alloc.banks_8[idx].size;
			}
		}
	}
	for (idx = 0; idx < 4; idx++) {
		if (gus->gf1.rom_present & (1 << idx)) {
			priv = kzalloc(sizeof(*priv), GFP_KERNEL);
			if (priv == NULL)
				return -ENOMEM;
			priv->rom = 1;
			priv->gus = gus;
			sprintf(name, "gus-rom-%i", idx);
			if (! snd_card_proc_new(gus->card, name, &entry)) {
				entry->content = SNDRV_INFO_CONTENT_DATA;
				entry->private_data = priv;
				entry->private_free = snd_gf1_mem_proc_free;
				entry->c.ops = &snd_gf1_mem_proc_ops;
				priv->address = idx * 4096 * 1024;
				priv->size = entry->size = gus->gf1.rom_memory;
			}
		}
	}
	return 0;
}
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4	2	/*
c1017a4c	3	* Copyright (c) by Jaroslav Kysela <perex@perex.cz>
1da177e4	4	* GUS's memory access via proc filesystem
1da177e4 LT	5	*/
1da177e4 LT	6
1da177e4 LT	7	#include <linux/slab.h>
	8	#include <sound/core.h>
	9	#include <sound/gus.h>
	10	#include <sound/info.h>
	11
5e2da206	12	struct gus_proc_private {
1da177e4 LT	13	int rom; /* data are in ROM */
	14	unsigned int address;
	15	unsigned int size;
5e2da206 TI	16	struct snd_gus_card * gus;
5e2da206 TI	17	};
1da177e4	18
24e4a121 TI	19	static ssize_t snd_gf1_mem_proc_dump(struct snd_info_entry *entry,
	20	void *file_private_data,
	21	struct file file, char __user buf,
	22	size_t count, loff_t pos)
1da177e4	23	{
5e2da206 TI	24	struct gus_proc_private *priv = entry->private_data;
5e2da206 TI	25	struct snd_gus_card *gus = priv->gus;
1da177e4 LT	26	int err;
1da177e4 LT	27
d97e1b78 TI	28	err = snd_gus_dram_read(gus, buf, pos, count, priv->rom);
	29	if (err < 0)
	30	return err;
	31	return count;
1da177e4 LT	32	}
1da177e4 LT	33
5e2da206	34	static void snd_gf1_mem_proc_free(struct snd_info_entry *entry)
1da177e4	35	{
5e2da206	36	struct gus_proc_private *priv = entry->private_data;
1da177e4 LT	37	kfree(priv);
	38	}
	39
	40	static struct snd_info_entry_ops snd_gf1_mem_proc_ops = {
	41	.read = snd_gf1_mem_proc_dump,
1da177e4 LT	42	};
1da177e4 LT	43
5e2da206	44	int snd_gf1_mem_proc_init(struct snd_gus_card * gus)
1da177e4 LT	45	{
	46	int idx;
	47	char name[16];
5e2da206 TI	48	struct gus_proc_private *priv;
5e2da206 TI	49	struct snd_info_entry *entry;
1da177e4 LT	50
	51	for (idx = 0; idx < 4; idx++) {
	52	if (gus->gf1.mem_alloc.banks_8[idx].size > 0) {
9e76a76e	53	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1da177e4 LT	54	if (priv == NULL)
	55	return -ENOMEM;
	56	priv->gus = gus;
	57	sprintf(name, "gus-ram-%i", idx);
	58	if (! snd_card_proc_new(gus->card, name, &entry)) {
	59	entry->content = SNDRV_INFO_CONTENT_DATA;
	60	entry->private_data = priv;
	61	entry->private_free = snd_gf1_mem_proc_free;
	62	entry->c.ops = &snd_gf1_mem_proc_ops;
	63	priv->address = gus->gf1.mem_alloc.banks_8[idx].address;
	64	priv->size = entry->size = gus->gf1.mem_alloc.banks_8[idx].size;
	65	}
	66	}
	67	}
	68	for (idx = 0; idx < 4; idx++) {
	69	if (gus->gf1.rom_present & (1 << idx)) {
9e76a76e	70	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1da177e4 LT	71	if (priv == NULL)
	72	return -ENOMEM;
	73	priv->rom = 1;
	74	priv->gus = gus;
	75	sprintf(name, "gus-rom-%i", idx);
	76	if (! snd_card_proc_new(gus->card, name, &entry)) {
	77	entry->content = SNDRV_INFO_CONTENT_DATA;
	78	entry->private_data = priv;
	79	entry->private_free = snd_gf1_mem_proc_free;
	80	entry->c.ops = &snd_gf1_mem_proc_ops;
	81	priv->address = idx * 4096 * 1024;
	82	priv->size = entry->size = gus->gf1.rom_memory;
	83	}
	84	}
	85	}
	86	return 0;
	87	}