Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 214 insertions, 0 deletions

diff --git a/sound/oss/dev_table.c b/sound/oss/dev_table.c
new file mode 100644
index 000000000000..f65a90469d8a
--- /dev/null
+++ b/sound/oss/dev_table.c
@@ -0,0 +1,214 @@
+/*
+ * sound/dev_table.c
+ *
+ * Device call tables.
+ *
+ *
+ * Copyright (C) by Hannu Savolainen 1993-1997
+ *
+ * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
+ * Version 2 (June 1991). See the "COPYING" file distributed with this software
+ * for more info.
+ */
+
+#include <linux/init.h>
+
+#define _DEV_TABLE_C_
+#include "sound_config.h"
+
+static int sound_alloc_audiodev(void);
+
+int sound_install_audiodrv(int vers, char *name, struct audio_driver *driver,
+                        int driver_size, int flags, unsigned int format_mask,
+                        void *devc, int dma1, int dma2)
+{
+        struct audio_driver *d;
+        struct audio_operations *op;
+        int num;
+
+        if (vers != AUDIO_DRIVER_VERSION || driver_size > sizeof(struct audio_driver)) {
+                printk(KERN_ERR "Sound: Incompatible audio driver for %s\n", name);
+                return -(EINVAL);
+        }
+        num = sound_alloc_audiodev();
+
+        if (num == -1) {
+                printk(KERN_ERR "sound: Too many audio drivers\n");
+                return -(EBUSY);
+        }
+        d = (struct audio_driver *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct audio_driver)));
+
+        if (sound_nblocks < 1024)
+                sound_nblocks++;
+
+        op = (struct audio_operations *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct audio_operations)));
+
+        if (sound_nblocks < 1024)
+                sound_nblocks++;
+        if (d == NULL || op == NULL) {
+                printk(KERN_ERR "Sound: Can't allocate driver for (%s)\n", name);
+                sound_unload_audiodev(num);
+                return -(ENOMEM);
+        }
+        memset((char *) op, 0, sizeof(struct audio_operations));
+        init_waitqueue_head(&op->in_sleeper);
+        init_waitqueue_head(&op->out_sleeper);  
+        init_waitqueue_head(&op->poll_sleeper);
+        if (driver_size < sizeof(struct audio_driver))
+                memset((char *) d, 0, sizeof(struct audio_driver));
+
+        memcpy((char *) d, (char *) driver, driver_size);
+
+        op->d = d;
+        strlcpy(op->name, name, sizeof(op->name));
+        op->flags = flags;
+        op->format_mask = format_mask;
+        op->devc = devc;
+
+        /*
+         *    Hardcoded defaults
+         */
+        audio_devs[num] = op;
+
+        DMAbuf_init(num, dma1, dma2);
+
+        audio_init_devices();
+        return num;
+}
+
+int sound_install_mixer(int vers, char *name, struct mixer_operations *driver,
+        int driver_size, void *devc)
+{
+        struct mixer_operations *op;
+
+        int n = sound_alloc_mixerdev();
+
+        if (n == -1) {
+                printk(KERN_ERR "Sound: Too many mixer drivers\n");
+                return -EBUSY;
+        }
+        if (vers != MIXER_DRIVER_VERSION ||
+                driver_size > sizeof(struct mixer_operations)) {
+                printk(KERN_ERR "Sound: Incompatible mixer driver for %s\n", name);
+                return -EINVAL;
+        }
+        
+        /* FIXME: This leaks a mixer_operations struct every time its called
+           until you unload sound! */
+           
+        op = (struct mixer_operations *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct mixer_operations)));
+
+        if (sound_nblocks < 1024)
+                sound_nblocks++;
+        if (op == NULL) {
+                printk(KERN_ERR "Sound: Can't allocate mixer driver for (%s)\n", name);
+                return -ENOMEM;
+        }
+        memset((char *) op, 0, sizeof(struct mixer_operations));
+        memcpy((char *) op, (char *) driver, driver_size);
+
+        strlcpy(op->name, name, sizeof(op->name));
+        op->devc = devc;
+
+        mixer_devs[n] = op;
+        return n;
+}
+
+void sound_unload_audiodev(int dev)
+{
+        if (dev != -1) {
+                DMAbuf_deinit(dev);
+                audio_devs[dev] = NULL;
+                unregister_sound_dsp((dev<<4)+3);
+        }
+}
+
+static int sound_alloc_audiodev(void)
+{ 
+        int i = register_sound_dsp(&oss_sound_fops, -1);
+        if(i==-1)
+                return i;
+        i>>=4;
+        if(i>=num_audiodevs)
+                num_audiodevs = i + 1;
+        return i;
+}
+
+int sound_alloc_mididev(void)
+{
+        int i = register_sound_midi(&oss_sound_fops, -1);
+        if(i==-1)
+                return i;
+        i>>=4;
+        if(i>=num_midis)
+                num_midis = i + 1;
+        return i;
+}
+
+int sound_alloc_synthdev(void)
+{
+        int i;
+
+        for (i = 0; i < MAX_SYNTH_DEV; i++) {
+                if (synth_devs[i] == NULL) {
+                        if (i >= num_synths)
+                                num_synths++;
+                        return i;
+                }
+        }
+        return -1;
+}
+
+int sound_alloc_mixerdev(void)
+{
+        int i = register_sound_mixer(&oss_sound_fops, -1);
+        if(i==-1)
+                return -1;
+        i>>=4;
+        if(i>=num_mixers)
+                num_mixers = i + 1;
+        return i;
+}
+
+int sound_alloc_timerdev(void)
+{
+        int i;
+
+        for (i = 0; i < MAX_TIMER_DEV; i++) {
+                if (sound_timer_devs[i] == NULL) {
+                        if (i >= num_sound_timers)
+                                num_sound_timers++;
+                        return i;
+                }
+        }
+        return -1;
+}
+
+void sound_unload_mixerdev(int dev)
+{
+        if (dev != -1) {
+                mixer_devs[dev] = NULL;
+                unregister_sound_mixer(dev<<4);
+                num_mixers--;
+        }
+}
+
+void sound_unload_mididev(int dev)
+{
+        if (dev != -1) {
+                midi_devs[dev] = NULL;
+                unregister_sound_midi((dev<<4)+2);
+        }
+}
+
+void sound_unload_synthdev(int dev)
+{
+        if (dev != -1)
+                synth_devs[dev] = NULL;
+}
+
+void sound_unload_timerdev(int dev)
+{
+        if (dev != -1)
+                sound_timer_devs[dev] = NULL;
+}