sound/isa/gus/gus_mem_proc.c

   1 /*
   2  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   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 loff_t snd_gf1_mem_proc_llseek(struct snd_info_entry *entry,
  50                                       void *private_file_data,
  51                                       struct file *file,
  52                                       loff_t offset, int orig)
  53 {
  54         struct gus_proc_private *priv = entry->private_data;
  55
  56         switch (orig) {
  57         case SEEK_SET:
  58                 file->f_pos = offset;
  59                 break;
  60         case SEEK_CUR:
  61                 file->f_pos += offset;
  62                 break;
  63         case SEEK_END: /* offset is negative */
  64                 file->f_pos = priv->size + offset;
  65                 break;
  66         default:
  67                 return -EINVAL;
  68         }
  69         if (file->f_pos > priv->size)
  70                 file->f_pos = priv->size;
  71         return file->f_pos;
  72 }
  73
  74 static void snd_gf1_mem_proc_free(struct snd_info_entry *entry)
  75 {
  76         struct gus_proc_private *priv = entry->private_data;
  77         kfree(priv);
  78 }
  79
  80 static struct snd_info_entry_ops snd_gf1_mem_proc_ops = {
  81         .read = snd_gf1_mem_proc_dump,
  82         .llseek = snd_gf1_mem_proc_llseek,
  83 };
  84
  85 int snd_gf1_mem_proc_init(struct snd_gus_card * gus)
  86 {
  87         int idx;
  88         char name[16];
  89         struct gus_proc_private *priv;
  90         struct snd_info_entry *entry;
  91
  92         for (idx = 0; idx < 4; idx++) {
  93                 if (gus->gf1.mem_alloc.banks_8[idx].size > 0) {
  94                         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
  95                         if (priv == NULL)
  96                                 return -ENOMEM;
  97                         priv->gus = gus;
  98                         sprintf(name, "gus-ram-%i", idx);
  99                         if (! snd_card_proc_new(gus->card, name, &entry)) {
 100                                 entry->content = SNDRV_INFO_CONTENT_DATA;
 101                                 entry->private_data = priv;
 102                                 entry->private_free = snd_gf1_mem_proc_free;
 103                                 entry->c.ops = &snd_gf1_mem_proc_ops;
 104                                 priv->address = gus->gf1.mem_alloc.banks_8[idx].address;
 105                                 priv->size = entry->size = gus->gf1.mem_alloc.banks_8[idx].size;
 106                         }
 107                 }
 108         }
 109         for (idx = 0; idx < 4; idx++) {
 110                 if (gus->gf1.rom_present & (1 << idx)) {
 111                         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 112                         if (priv == NULL)
 113                                 return -ENOMEM;
 114                         priv->rom = 1;
 115                         priv->gus = gus;
 116                         sprintf(name, "gus-rom-%i", idx);
 117                         if (! snd_card_proc_new(gus->card, name, &entry)) {
 118                                 entry->content = SNDRV_INFO_CONTENT_DATA;
 119                                 entry->private_data = priv;
 120                                 entry->private_free = snd_gf1_mem_proc_free;
 121                                 entry->c.ops = &snd_gf1_mem_proc_ops;
 122                                 priv->address = idx * 4096 * 1024;
 123                                 priv->size = entry->size = gus->gf1.rom_memory;
 124                         }
 125                 }
 126         }
 127         return 0;
 128 }