sound/oss/dev_table.c

   1 /*
   2  * sound/oss/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 #include "sound_config.h"
  17
  18 struct audio_operations *audio_devs[MAX_AUDIO_DEV];
  19 EXPORT_SYMBOL(audio_devs);
  20
  21 int num_audiodevs;
  22 EXPORT_SYMBOL(num_audiodevs);
  23
  24 struct mixer_operations *mixer_devs[MAX_MIXER_DEV];
  25 EXPORT_SYMBOL(mixer_devs);
  26
  27 int num_mixers;
  28 EXPORT_SYMBOL(num_mixers);
  29
  30 struct synth_operations *synth_devs[MAX_SYNTH_DEV+MAX_MIDI_DEV];
  31 EXPORT_SYMBOL(synth_devs);
  32
  33 int num_synths;
  34
  35 struct midi_operations *midi_devs[MAX_MIDI_DEV];
  36 EXPORT_SYMBOL(midi_devs);
  37
  38 int num_midis;
  39 EXPORT_SYMBOL(num_midis);
  40
  41 struct sound_timer_operations *sound_timer_devs[MAX_TIMER_DEV] = {
  42         &default_sound_timer, NULL
  43 };
  44 EXPORT_SYMBOL(sound_timer_devs);
  45
  46 int num_sound_timers = 1;
  47
  48
  49 static int sound_alloc_audiodev(void);
  50
  51 int sound_install_audiodrv(int vers, char *name, struct audio_driver *driver,
  52                         int driver_size, int flags, unsigned int format_mask,
  53                         void *devc, int dma1, int dma2)
  54 {
  55         struct audio_driver *d;
  56         struct audio_operations *op;
  57         int num;
  58
  59         if (vers != AUDIO_DRIVER_VERSION || driver_size > sizeof(struct audio_driver)) {
  60                 printk(KERN_ERR "Sound: Incompatible audio driver for %s\n", name);
  61                 return -(EINVAL);
  62         }
  63         num = sound_alloc_audiodev();
  64
  65         if (num == -1) {
  66                 printk(KERN_ERR "sound: Too many audio drivers\n");
  67                 return -(EBUSY);
  68         }
  69         d = (struct audio_driver *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct audio_driver)));
  70         sound_nblocks++;
  71         if (sound_nblocks >= MAX_MEM_BLOCKS)
  72                 sound_nblocks = MAX_MEM_BLOCKS - 1;
  73
  74         op = (struct audio_operations *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct audio_operations)));
  75         sound_nblocks++;
  76         if (sound_nblocks >= MAX_MEM_BLOCKS)
  77                 sound_nblocks = MAX_MEM_BLOCKS - 1;
  78
  79         if (d == NULL || op == NULL) {
  80                 printk(KERN_ERR "Sound: Can't allocate driver for (%s)\n", name);
  81                 sound_unload_audiodev(num);
  82                 return -(ENOMEM);
  83         }
  84         memset((char *) op, 0, sizeof(struct audio_operations));
  85         init_waitqueue_head(&op->in_sleeper);
  86         init_waitqueue_head(&op->out_sleeper);
  87         init_waitqueue_head(&op->poll_sleeper);
  88         if (driver_size < sizeof(struct audio_driver))
  89                 memset((char *) d, 0, sizeof(struct audio_driver));
  90
  91         memcpy((char *) d, (char *) driver, driver_size);
  92
  93         op->d = d;
  94         strlcpy(op->name, name, sizeof(op->name));
  95         op->flags = flags;
  96         op->format_mask = format_mask;
  97         op->devc = devc;
  98
  99         /*
 100          *    Hardcoded defaults
 101          */
 102         audio_devs[num] = op;
 103
 104         DMAbuf_init(num, dma1, dma2);
 105
 106         audio_init_devices();
 107         return num;
 108 }
 109 EXPORT_SYMBOL(sound_install_audiodrv);
 110
 111 int sound_install_mixer(int vers, char *name, struct mixer_operations *driver,
 112         int driver_size, void *devc)
 113 {
 114         struct mixer_operations *op;
 115
 116         int n = sound_alloc_mixerdev();
 117
 118         if (n == -1) {
 119                 printk(KERN_ERR "Sound: Too many mixer drivers\n");
 120                 return -EBUSY;
 121         }
 122         if (vers != MIXER_DRIVER_VERSION ||
 123                 driver_size > sizeof(struct mixer_operations)) {
 124                 printk(KERN_ERR "Sound: Incompatible mixer driver for %s\n", name);
 125                 return -EINVAL;
 126         }
 127
 128         /* FIXME: This leaks a mixer_operations struct every time its called
 129            until you unload sound! */
 130
 131         op = (struct mixer_operations *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct mixer_operations)));
 132         sound_nblocks++;
 133         if (sound_nblocks >= MAX_MEM_BLOCKS)
 134                 sound_nblocks = MAX_MEM_BLOCKS - 1;
 135
 136         if (op == NULL) {
 137                 printk(KERN_ERR "Sound: Can't allocate mixer driver for (%s)\n", name);
 138                 return -ENOMEM;
 139         }
 140         memset((char *) op, 0, sizeof(struct mixer_operations));
 141         memcpy((char *) op, (char *) driver, driver_size);
 142
 143         strlcpy(op->name, name, sizeof(op->name));
 144         op->devc = devc;
 145
 146         mixer_devs[n] = op;
 147         return n;
 148 }
 149 EXPORT_SYMBOL(sound_install_mixer);
 150
 151 void sound_unload_audiodev(int dev)
 152 {
 153         if (dev != -1) {
 154                 DMAbuf_deinit(dev);
 155                 audio_devs[dev] = NULL;
 156                 unregister_sound_dsp((dev<<4)+3);
 157         }
 158 }
 159 EXPORT_SYMBOL(sound_unload_audiodev);
 160
 161 static int sound_alloc_audiodev(void)
 162 {
 163         int i = register_sound_dsp(&oss_sound_fops, -1);
 164         if(i==-1)
 165                 return i;
 166         i>>=4;
 167         if(i>=num_audiodevs)
 168                 num_audiodevs = i + 1;
 169         return i;
 170 }
 171
 172 int sound_alloc_mididev(void)
 173 {
 174         int i = register_sound_midi(&oss_sound_fops, -1);
 175         if(i==-1)
 176                 return i;
 177         i>>=4;
 178         if(i>=num_midis)
 179                 num_midis = i + 1;
 180         return i;
 181 }
 182 EXPORT_SYMBOL(sound_alloc_mididev);
 183
 184 int sound_alloc_synthdev(void)
 185 {
 186         int i;
 187
 188         for (i = 0; i < MAX_SYNTH_DEV; i++) {
 189                 if (synth_devs[i] == NULL) {
 190                         if (i >= num_synths)
 191                                 num_synths++;
 192                         return i;
 193                 }
 194         }
 195         return -1;
 196 }
 197 EXPORT_SYMBOL(sound_alloc_synthdev);
 198
 199 int sound_alloc_mixerdev(void)
 200 {
 201         int i = register_sound_mixer(&oss_sound_fops, -1);
 202         if(i==-1)
 203                 return -1;
 204         i>>=4;
 205         if(i>=num_mixers)
 206                 num_mixers = i + 1;
 207         return i;
 208 }
 209 EXPORT_SYMBOL(sound_alloc_mixerdev);
 210
 211 int sound_alloc_timerdev(void)
 212 {
 213         int i;
 214
 215         for (i = 0; i < MAX_TIMER_DEV; i++) {
 216                 if (sound_timer_devs[i] == NULL) {
 217                         if (i >= num_sound_timers)
 218                                 num_sound_timers++;
 219                         return i;
 220                 }
 221         }
 222         return -1;
 223 }
 224 EXPORT_SYMBOL(sound_alloc_timerdev);
 225
 226 void sound_unload_mixerdev(int dev)
 227 {
 228         if (dev != -1) {
 229                 mixer_devs[dev] = NULL;
 230                 unregister_sound_mixer(dev<<4);
 231                 num_mixers--;
 232         }
 233 }
 234 EXPORT_SYMBOL(sound_unload_mixerdev);
 235
 236 void sound_unload_mididev(int dev)
 237 {
 238         if (dev != -1) {
 239                 midi_devs[dev] = NULL;
 240                 unregister_sound_midi((dev<<4)+2);
 241         }
 242 }
 243 EXPORT_SYMBOL(sound_unload_mididev);
 244
 245 void sound_unload_synthdev(int dev)
 246 {
 247         if (dev != -1)
 248                 synth_devs[dev] = NULL;
 249 }
 250 EXPORT_SYMBOL(sound_unload_synthdev);
 251
 252 void sound_unload_timerdev(int dev)
 253 {
 254         if (dev != -1)
 255                 sound_timer_devs[dev] = NULL;
 256 }
 257 EXPORT_SYMBOL(sound_unload_timerdev);
 258