LXR linux/sound/isa/gus/gus_mem

   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
  12struct 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
  19static 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
  34static 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
  40static struct snd_info_entry_ops snd_gf1_mem_proc_ops = {
  41        .read = snd_gf1_mem_proc_dump,
  42};
  43
  44int 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}
  88