/*

   * sound/oss/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>

  #include "sound_config.h"

  struct audio_operations *audio_devs[MAX_AUDIO_DEV];
  EXPORT_SYMBOL(audio_devs);
  
  int num_audiodevs;
  EXPORT_SYMBOL(num_audiodevs);
  
  struct mixer_operations *mixer_devs[MAX_MIXER_DEV];
  EXPORT_SYMBOL(mixer_devs);
  
  int num_mixers;
  EXPORT_SYMBOL(num_mixers);
  
  struct synth_operations *synth_devs[MAX_SYNTH_DEV+MAX_MIDI_DEV];
  EXPORT_SYMBOL(synth_devs);
  
  int num_synths;
  
  struct midi_operations *midi_devs[MAX_MIDI_DEV];
  EXPORT_SYMBOL(midi_devs);
  
  int num_midis;
  EXPORT_SYMBOL(num_midis);
  
  struct sound_timer_operations *sound_timer_devs[MAX_TIMER_DEV] = {
  	&default_sound_timer, NULL
  };
  EXPORT_SYMBOL(sound_timer_devs);
  
  int num_sound_timers = 1;

  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
  ", name);

  		return -EINVAL;

  	}
  	num = sound_alloc_audiodev();
  
  	if (num == -1) {
  		printk(KERN_ERR "sound: Too many audio drivers
  ");

  		return -EBUSY;

  	}
  	d = (struct audio_driver *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct audio_driver)));

  	sound_nblocks++;
  	if (sound_nblocks >= MAX_MEM_BLOCKS)
  		sound_nblocks = MAX_MEM_BLOCKS - 1;

  	op = (struct audio_operations *) (sound_mem_blocks[sound_nblocks] = vzalloc(sizeof(struct audio_operations)));

  	sound_nblocks++;
  	if (sound_nblocks >= MAX_MEM_BLOCKS)
  		sound_nblocks = MAX_MEM_BLOCKS - 1;

  	if (d == NULL || op == NULL) {
  		printk(KERN_ERR "Sound: Can't allocate driver for (%s)
  ", name);
  		sound_unload_audiodev(num);

  		return -ENOMEM;

  	}

  	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;
  }

  EXPORT_SYMBOL(sound_install_audiodrv);

  
  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
  ");
  		return -EBUSY;
  	}
  	if (vers != MIXER_DRIVER_VERSION ||
  		driver_size > sizeof(struct mixer_operations)) {
  		printk(KERN_ERR "Sound: Incompatible mixer driver for %s
  ", 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] = vzalloc(sizeof(struct mixer_operations)));

  	sound_nblocks++;
  	if (sound_nblocks >= MAX_MEM_BLOCKS)
  		sound_nblocks = MAX_MEM_BLOCKS - 1;

  	if (op == NULL) {
  		printk(KERN_ERR "Sound: Can't allocate mixer driver for (%s)
  ", name);
  		return -ENOMEM;
  	}

  	memcpy((char *) op, (char *) driver, driver_size);
  
  	strlcpy(op->name, name, sizeof(op->name));
  	op->devc = devc;
  
  	mixer_devs[n] = op;
  	return n;
  }

  EXPORT_SYMBOL(sound_install_mixer);

  
  void sound_unload_audiodev(int dev)
  {
  	if (dev != -1) {
  		DMAbuf_deinit(dev);
  		audio_devs[dev] = NULL;
  		unregister_sound_dsp((dev<<4)+3);
  	}
  }

  EXPORT_SYMBOL(sound_unload_audiodev);

  
  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;
  }

  EXPORT_SYMBOL(sound_alloc_mididev);

  
  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;
  }

  EXPORT_SYMBOL(sound_alloc_synthdev);

  
  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;
  }

  EXPORT_SYMBOL(sound_alloc_mixerdev);

  
  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;
  }

  EXPORT_SYMBOL(sound_alloc_timerdev);

  
  void sound_unload_mixerdev(int dev)
  {
  	if (dev != -1) {
  		mixer_devs[dev] = NULL;
  		unregister_sound_mixer(dev<<4);
  		num_mixers--;
  	}
  }

  EXPORT_SYMBOL(sound_unload_mixerdev);

  
  void sound_unload_mididev(int dev)
  {
  	if (dev != -1) {
  		midi_devs[dev] = NULL;
  		unregister_sound_midi((dev<<4)+2);
  	}
  }

  EXPORT_SYMBOL(sound_unload_mididev);

  
  void sound_unload_synthdev(int dev)
  {
  	if (dev != -1)
  		synth_devs[dev] = NULL;
  }

  EXPORT_SYMBOL(sound_unload_synthdev);

  
  void sound_unload_timerdev(int dev)
  {
  	if (dev != -1)
  		sound_timer_devs[dev] = NULL;
  }

  EXPORT_SYMBOL(sound_unload_timerdev);