drivers/sound/dev_table.c

   1 /*
   2  * sound/dev_table.c
   3  *
   4  * Device call tables.
   5  *
   6  *
   7  * Copyright (C) by Hannu Savolainen 1993-1997
   8  *
   9  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11  * for more info.
  12  */
  13
  14 #include <linux/init.h>
  15
  16 #define _DEV_TABLE_C_
  17 #include "sound_config.h"
  18
  19 int softoss_dev = 0;
  20
  21 int sound_install_audiodrv(int vers, char *name, struct audio_driver *driver,
  22                         int driver_size, int flags, unsigned int format_mask,
  23                         void *devc, int dma1, int dma2)
  24 {
  25         struct audio_driver *d;
  26         struct audio_operations *op;
  27         int l, num;
  28
  29         if (vers != AUDIO_DRIVER_VERSION || driver_size > sizeof(struct audio_driver)) {
  30                 printk(KERN_ERR "Sound: Incompatible audio driver for %s\n", name);
  31                 return -(EINVAL);
  32         }
  33         num = sound_alloc_audiodev();
  34
  35         if (num == -1) {
  36                 printk(KERN_ERR "sound: Too many audio drivers\n");
  37                 return -(EBUSY);
  38         }
  39         d = (struct audio_driver *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct audio_driver)));
  40
  41         if (sound_nblocks < 1024)
  42                 sound_nblocks++;
  43
  44         op = (struct audio_operations *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct audio_operations)));
  45
  46         if (sound_nblocks < 1024)
  47                 sound_nblocks++;
  48         if (d == NULL || op == NULL) {
  49                 printk(KERN_ERR "Sound: Can't allocate driver for (%s)\n", name);
  50                 sound_unload_audiodev(num);
  51                 return -(ENOMEM);
  52         }
  53         memset((char *) op, 0, sizeof(struct audio_operations));
  54         init_waitqueue_head(&op->in_sleeper);
  55         init_waitqueue_head(&op->out_sleeper);
  56         init_waitqueue_head(&op->poll_sleeper);
  57         if (driver_size < sizeof(struct audio_driver))
  58                 memset((char *) d, 0, sizeof(struct audio_driver));
  59
  60         memcpy((char *) d, (char *) driver, driver_size);
  61
  62         op->d = d;
  63         l = strlen(name) + 1;
  64         if (l > sizeof(op->name))
  65                 l = sizeof(op->name);
  66         strncpy(op->name, name, l);
  67         op->name[l - 1] = 0;
  68         op->flags = flags;
  69         op->format_mask = format_mask;
  70         op->devc = devc;
  71
  72         /*
  73          *    Hardcoded defaults
  74          */
  75         audio_devs[num] = op;
  76
  77         DMAbuf_init(num, dma1, dma2);
  78
  79         audio_init_devices();
  80         return num;
  81 }
  82
  83 int sound_install_mixer(int vers, char *name, struct mixer_operations *driver,
  84         int driver_size, void *devc)
  85 {
  86         struct mixer_operations *op;
  87         int l;
  88
  89         int n = sound_alloc_mixerdev();
  90
  91         if (n == -1) {
  92                 printk(KERN_ERR "Sound: Too many mixer drivers\n");
  93                 return -EBUSY;
  94         }
  95         if (vers != MIXER_DRIVER_VERSION ||
  96                 driver_size > sizeof(struct mixer_operations)) {
  97                 printk(KERN_ERR "Sound: Incompatible mixer driver for %s\n", name);
  98                 return -EINVAL;
  99         }
 100
 101         /* FIXME: This leaks a mixer_operations struct every time its called
 102            until you unload sound! */
 103
 104         op = (struct mixer_operations *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct mixer_operations)));
 105
 106         if (sound_nblocks < 1024)
 107                 sound_nblocks++;
 108         if (op == NULL) {
 109                 printk(KERN_ERR "Sound: Can't allocate mixer driver for (%s)\n", name);
 110                 return -ENOMEM;
 111         }
 112         memset((char *) op, 0, sizeof(struct mixer_operations));
 113         memcpy((char *) op, (char *) driver, driver_size);
 114
 115         l = strlen(name) + 1;
 116         if (l > sizeof(op->name))
 117                 l = sizeof(op->name);
 118         strncpy(op->name, name, l);
 119         op->name[l - 1] = 0;
 120         op->devc = devc;
 121
 122         mixer_devs[n] = op;
 123         return n;
 124 }
 125
 126 void sound_unload_audiodev(int dev)
 127 {
 128         if (dev != -1) {
 129                 DMAbuf_deinit(dev);
 130                 audio_devs[dev] = NULL;
 131                 unregister_sound_dsp((dev<<4)+3);
 132         }
 133 }
 134
 135 int sound_alloc_audiodev(void)
 136 {
 137         int i = register_sound_dsp(&oss_sound_fops, -1);
 138         if(i==-1)
 139                 return i;
 140         i>>=4;
 141         if(i>=num_audiodevs)
 142                 num_audiodevs = i + 1;
 143         return i;
 144 }
 145
 146 int sound_alloc_mididev(void)
 147 {
 148         int i = register_sound_midi(&oss_sound_fops, -1);
 149         if(i==-1)
 150                 return i;
 151         i>>=4;
 152         if(i>=num_midis)
 153                 num_midis = i + 1;
 154         return i;
 155 }
 156
 157 int sound_alloc_synthdev(void)
 158 {
 159         int i;
 160
 161         for (i = 0; i < MAX_SYNTH_DEV; i++) {
 162                 if (synth_devs[i] == NULL) {
 163                         if (i >= num_synths)
 164                                 num_synths++;
 165                         return i;
 166                 }
 167         }
 168         return -1;
 169 }
 170
 171 int sound_alloc_mixerdev(void)
 172 {
 173         int i = register_sound_mixer(&oss_sound_fops, -1);
 174         if(i==-1)
 175                 return -1;
 176         i>>=4;
 177         if(i>=num_mixers)
 178                 num_mixers = i + 1;
 179         return i;
 180 }
 181
 182 int sound_alloc_timerdev(void)
 183 {
 184         int i;
 185
 186         for (i = 0; i < MAX_TIMER_DEV; i++) {
 187                 if (sound_timer_devs[i] == NULL) {
 188                         if (i >= num_sound_timers)
 189                                 num_sound_timers++;
 190                         return i;
 191                 }
 192         }
 193         return -1;
 194 }
 195
 196 void sound_unload_mixerdev(int dev)
 197 {
 198         if (dev != -1) {
 199                 mixer_devs[dev] = NULL;
 200                 unregister_sound_mixer(dev<<4);
 201                 num_mixers--;
 202         }
 203 }
 204
 205 void sound_unload_mididev(int dev)
 206 {
 207         if (dev != -1) {
 208                 midi_devs[dev] = NULL;
 209                 unregister_sound_midi((dev<<4)+2);
 210         }
 211 }
 212
 213 void sound_unload_synthdev(int dev)
 214 {
 215         if (dev != -1)
 216                 synth_devs[dev] = NULL;
 217 }
 218
 219 void sound_unload_timerdev(int dev)
 220 {
 221         if (dev != -1)
 222                 sound_timer_devs[dev] = NULL;
 223 }