| | 1 | /* |
| | 2 | * Copyright (c) by Jaroslav Kysela <[email protected]> |
| | 3 | * GUS's memory access via proc filesystem |
| | 4 | * |
| | 5 | * |
| | 6 | * This program is free software; you can redistribute it and/or modify |
| | 7 | * it under the terms of the GNU General Public License as published by |
| | 8 | * the Free Software Foundation; either version 2 of the License, or |
| | 9 | * (at your option) any later version. |
| | 10 | * |
| | 11 | * This program is distributed in the hope that it will be useful, |
| | 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| | 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| | 14 | * GNU General Public License for more details. |
| | 15 | * |
| | 16 | * You should have received a copy of the GNU General Public License |
| | 17 | * along with this program; if not, write to the Free Software |
| | 18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| | 19 | * |
| | 20 | */ |
| | 21 | |
| | 22 | #include <linux/slab.h> |
| | 23 | #include <sound/core.h> |
| | 24 | #include <sound/gus.h> |
| | 25 | #include <sound/info.h> |
| | 26 | |
| | 27 | struct gus_proc_private { |
| | 28 | int rom; /* data are in ROM */ |
| | 29 | unsigned int address; |
| | 30 | unsigned int size; |
| | 31 | struct snd_gus_card * gus; |
| | 32 | }; |
| | 33 | |
| | 34 | static ssize_t snd_gf1_mem_proc_dump(struct snd_info_entry *entry, |
| | 35 | void *file_private_data, |
| | 36 | struct file *file, char __user *buf, |
| | 37 | size_t count, loff_t pos) |
| | 38 | { |
| | 39 | struct gus_proc_private *priv = entry->private_data; |
| | 40 | struct snd_gus_card *gus = priv->gus; |
| | 41 | int err; |
| | 42 | |
| | 43 | err = snd_gus_dram_read(gus, buf, pos, count, priv->rom); |
| | 44 | if (err < 0) |
| | 45 | return err; |
| | 46 | return count; |
| | 47 | } |
| | 48 | |
| | 49 | static void snd_gf1_mem_proc_free(struct snd_info_entry *entry) |
| | 50 | { |
| | 51 | struct gus_proc_private *priv = entry->private_data; |
| | 52 | kfree(priv); |
| | 53 | } |
| | 54 | |
| | 55 | static struct snd_info_entry_ops snd_gf1_mem_proc_ops = { |
| | 56 | .read = snd_gf1_mem_proc_dump, |
| | 57 | }; |
| | 58 | |
| | 59 | int snd_gf1_mem_proc_init(struct snd_gus_card * gus) |
| | 60 | { |
| | 61 | int idx; |
| | 62 | char name[16]; |
| | 63 | struct gus_proc_private *priv; |
| | 64 | struct snd_info_entry *entry; |
| | 65 | |
| | 66 | for (idx = 0; idx < 4; idx++) { |
| | 67 | if (gus->gf1.mem_alloc.banks_8[idx].size > 0) { |
| | 68 | priv = kzalloc(sizeof(*priv), GFP_KERNEL); |
| | 69 | if (priv == NULL) |
| | 70 | return -ENOMEM; |
| | 71 | priv->gus = gus; |
| | 72 | sprintf(name, "gus-ram-%i", idx); |
| | 73 | if (! snd_card_proc_new(gus->card, name, &entry)) { |
| | 74 | entry->content = SNDRV_INFO_CONTENT_DATA; |
| | 75 | entry->private_data = priv; |
| | 76 | entry->private_free = snd_gf1_mem_proc_free; |
| | 77 | entry->c.ops = &snd_gf1_mem_proc_ops; |
| | 78 | priv->address = gus->gf1.mem_alloc.banks_8[idx].address; |
| | 79 | priv->size = entry->size = gus->gf1.mem_alloc.banks_8[idx].size; |
| | 80 | } |
| | 81 | } |
| | 82 | } |
| | 83 | for (idx = 0; idx < 4; idx++) { |
| | 84 | if (gus->gf1.rom_present & (1 << idx)) { |
| | 85 | priv = kzalloc(sizeof(*priv), GFP_KERNEL); |
| | 86 | if (priv == NULL) |
| | 87 | return -ENOMEM; |
| | 88 | priv->rom = 1; |
| | 89 | priv->gus = gus; |
| | 90 | sprintf(name, "gus-rom-%i", idx); |
| | 91 | if (! snd_card_proc_new(gus->card, name, &entry)) { |
| | 92 | entry->content = SNDRV_INFO_CONTENT_DATA; |
| | 93 | entry->private_data = priv; |
| | 94 | entry->private_free = snd_gf1_mem_proc_free; |
| | 95 | entry->c.ops = &snd_gf1_mem_proc_ops; |
| | 96 | priv->address = idx * 4096 * 1024; |
| | 97 | priv->size = entry->size = gus->gf1.rom_memory; |
| | 98 | } |
| | 99 | } |
| | 100 | } |
| | 101 | return 0; |
| | 102 | } |
projects / linux.git / blame_incremental