root/sound/isa/gus/gus_mem_proc.c

DEFINITIONS

1. snd_gf1_mem_proc_dump
2. snd_gf1_mem_proc_free
3. snd_gf1_mem_proc_init

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   4  *  GUS's memory access via proc filesystem
   5  */
   6 
   7 #include <linux/slab.h>
   8 #include <sound/core.h>
   9 #include <sound/gus.h>
  10 #include <sound/info.h>
  11 
  12 struct gus_proc_private {
  13         int rom;                /* data are in ROM */
  14         unsigned int address;
  15         unsigned int size;
  16         struct snd_gus_card * gus;
  17 };
  18 
  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)
  23 {
  24         struct gus_proc_private *priv = entry->private_data;
  25         struct snd_gus_card *gus = priv->gus;
  26         int err;
  27 
  28         err = snd_gus_dram_read(gus, buf, pos, count, priv->rom);
  29         if (err < 0)
  30                 return err;
  31         return count;
  32 }                       
  33 
  34 static void snd_gf1_mem_proc_free(struct snd_info_entry *entry)
  35 {
  36         struct gus_proc_private *priv = entry->private_data;
  37         kfree(priv);
  38 }
  39 
  40 static struct snd_info_entry_ops snd_gf1_mem_proc_ops = {
  41         .read = snd_gf1_mem_proc_dump,
  42 };
  43 
  44 int snd_gf1_mem_proc_init(struct snd_gus_card * gus)
  45 {
  46         int idx;
  47         char name[16];
  48         struct gus_proc_private *priv;
  49         struct snd_info_entry *entry;
  50 
  51         for (idx = 0; idx < 4; idx++) {
  52                 if (gus->gf1.mem_alloc.banks_8[idx].size > 0) {
  53                         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
  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)) {
  70                         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
  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 }