/*
   *  linux/drivers/sound/vidc.c
   *
   *  Copyright (C) 1997-2000 by Russell King <rmk@arm.linux.org.uk>
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License version 2 as
   * published by the Free Software Foundation.
   *
   *  VIDC20 audio driver.
   *
   * The VIDC20 sound hardware consists of the VIDC20 itself, a DAC and a DMA
   * engine.  The DMA transfers fixed-format (16-bit little-endian linear)
   * samples to the VIDC20, which then transfers this data serially to the
   * DACs.  The samplerate is controlled by the VIDC.
   *
   * We currently support a mixer device, but it is currently non-functional.
   */
  
  #include <linux/gfp.h>
  #include <linux/init.h>
  #include <linux/module.h>
  #include <linux/kernel.h>
  #include <linux/interrupt.h>
  
  #include <mach/hardware.h>
  #include <asm/dma.h>
  #include <asm/io.h>
  #include <asm/hardware/iomd.h>
  #include <asm/irq.h>
  
  #include "sound_config.h"
  #include "vidc.h"
  
  #ifndef _SIOC_TYPE
  #define _SIOC_TYPE(x)	_IOC_TYPE(x)
  #endif
  #ifndef _SIOC_NR
  #define _SIOC_NR(x)	_IOC_NR(x)
  #endif
  
  #define VIDC_SOUND_CLOCK	(250000)
  #define VIDC_SOUND_CLOCK_EXT	(176400)
  
  /*
   * When using SERIAL SOUND mode (external DAC), the number of physical
   * channels is fixed at 2.
   */
  static int		vidc_busy;
  static int		vidc_adev;
  static int		vidc_audio_rate;
  static char		vidc_audio_format;
  static char		vidc_audio_channels;
  
  static unsigned char	vidc_level_l[SOUND_MIXER_NRDEVICES] = {
  	85,		/* master	*/
  	50,		/* bass		*/
  	50,		/* treble	*/
  	0,		/* synth	*/
  	75,		/* pcm		*/
  	0,		/* speaker	*/
  	100,		/* ext line	*/
  	0,		/* mic		*/
  	100,		/* CD		*/
  	0,
  };
  
  static unsigned char	vidc_level_r[SOUND_MIXER_NRDEVICES] = {
  	85,		/* master	*/
  	50,		/* bass		*/
  	50,		/* treble	*/
  	0,		/* synth	*/
  	75,		/* pcm		*/
  	0,		/* speaker	*/
  	100,		/* ext line	*/
  	0,		/* mic		*/
  	100,		/* CD		*/
  	0,
  };
  
  static unsigned int	vidc_audio_volume_l;	/* left PCM vol, 0 - 65536 */
  static unsigned int	vidc_audio_volume_r;	/* right PCM vol, 0 - 65536 */
  
  extern void	vidc_update_filler(int bits, int channels);
  extern int	softoss_dev;
  
  static void
  vidc_mixer_set(int mdev, unsigned int level)
  {
  	unsigned int lev_l = level & 0x007f;
  	unsigned int lev_r = (level & 0x7f00) >> 8;
  	unsigned int mlev_l, mlev_r;
  
  	if (lev_l > 100)
  		lev_l = 100;
  	if (lev_r > 100)
  		lev_r = 100;
  
  #define SCALE(lev,master)	((lev) * (master) * 65536 / 10000)
  
  	mlev_l = vidc_level_l[SOUND_MIXER_VOLUME];
  	mlev_r = vidc_level_r[SOUND_MIXER_VOLUME];
  
  	switch (mdev) {
  	case SOUND_MIXER_VOLUME:
  	case SOUND_MIXER_PCM:
  		vidc_level_l[mdev] = lev_l;
  		vidc_level_r[mdev] = lev_r;
  
  		vidc_audio_volume_l = SCALE(lev_l, mlev_l);
  		vidc_audio_volume_r = SCALE(lev_r, mlev_r);
  /*printk("VIDC: PCM vol %05X %05X
  ", vidc_audio_volume_l, vidc_audio_volume_r);*/
  		break;
  	}
  #undef SCALE
  }
  
  static int vidc_mixer_ioctl(int dev, unsigned int cmd, void __user *arg)
  {
  	unsigned int val;
  	unsigned int mdev;
  
  	if (_SIOC_TYPE(cmd) != 'M')
  		return -EINVAL;
  
  	mdev = _SIOC_NR(cmd);
  
  	if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
  		if (get_user(val, (unsigned int __user *)arg))
  			return -EFAULT;
  
  		if (mdev < SOUND_MIXER_NRDEVICES)
  			vidc_mixer_set(mdev, val);
  		else
  			return -EINVAL;
  	}
  
  	/*
  	 * Return parameters
  	 */
  	switch (mdev) {
  	case SOUND_MIXER_RECSRC:
  		val = 0;
  		break;
  
  	case SOUND_MIXER_DEVMASK:
  		val = SOUND_MASK_VOLUME | SOUND_MASK_PCM | SOUND_MASK_SYNTH;
  		break;
  
  	case SOUND_MIXER_STEREODEVS:
  		val = SOUND_MASK_VOLUME | SOUND_MASK_PCM | SOUND_MASK_SYNTH;
  		break;
  
  	case SOUND_MIXER_RECMASK:
  		val = 0;
  		break;
  
  	case SOUND_MIXER_CAPS:
  		val = 0;
  		break;
  
  	default:
  		if (mdev < SOUND_MIXER_NRDEVICES)
  			val = vidc_level_l[mdev] | vidc_level_r[mdev] << 8;
  		else
  			return -EINVAL;
  	}
  
  	return put_user(val, (unsigned int __user *)arg) ? -EFAULT : 0;
  }
  
  static unsigned int vidc_audio_set_format(int dev, unsigned int fmt)
  {
  	switch (fmt) {
  	default:
  		fmt = AFMT_S16_LE;
  	case AFMT_U8:
  	case AFMT_S8:
  	case AFMT_S16_LE:
  		vidc_audio_format = fmt;
  		vidc_update_filler(vidc_audio_format, vidc_audio_channels);
  	case AFMT_QUERY:
  		break;
  	}
  	return vidc_audio_format;
  }
  
  #define my_abs(i) ((i)<0 ? -(i) : (i))
  
  static int vidc_audio_set_speed(int dev, int rate)
  {
  	if (rate) {
  		unsigned int hwctrl, hwrate, hwrate_ext, rate_int, rate_ext;
  		unsigned int diff_int, diff_ext;
  		unsigned int newsize, new2size;
  
  		hwctrl = 0x00000003;
  
  		/* Using internal clock */
  		hwrate = (((VIDC_SOUND_CLOCK * 2) / rate) + 1) >> 1;
  		if (hwrate < 3)
  			hwrate = 3;
  		if (hwrate > 255)
  			hwrate = 255;
  
  		/* Using exernal clock */
  		hwrate_ext = (((VIDC_SOUND_CLOCK_EXT * 2) / rate) + 1) >> 1;
  		if (hwrate_ext < 3)
  			hwrate_ext = 3;
  		if (hwrate_ext > 255)
  			hwrate_ext = 255;
  
  		rate_int = VIDC_SOUND_CLOCK / hwrate;
  		rate_ext = VIDC_SOUND_CLOCK_EXT / hwrate_ext;
  
  		/* Chose between external and internal clock */
  		diff_int = my_abs(rate_ext-rate);
  		diff_ext = my_abs(rate_int-rate);
  		if (diff_ext < diff_int) {
  			/*printk("VIDC: external %d %d %d
  ", rate, rate_ext, hwrate_ext);*/
  			hwrate=hwrate_ext;
  			hwctrl=0x00000002;
  			/* Allow roughly 0.4% tolerance */
  			if (diff_ext > (rate/256))
  				rate=rate_ext;
  		} else {
  			/*printk("VIDC: internal %d %d %d
  ", rate, rate_int, hwrate);*/
  			hwctrl=0x00000003;
  			/* Allow roughly 0.4% tolerance */
  			if (diff_int > (rate/256))
  				rate=rate_int;
  		}
  
  		vidc_writel(0xb0000000 | (hwrate - 2));
  		vidc_writel(0xb1000000 | hwctrl);
  
  		newsize = (10000 / hwrate) & ~3;
  		if (newsize < 208)
  			newsize = 208;
  		if (newsize > 4096)
  			newsize = 4096;
  		for (new2size = 128; new2size < newsize; new2size <<= 1);
  		if (new2size - newsize > newsize - (new2size >> 1))
  			new2size >>= 1;
  		if (new2size > 4096) {
  			printk(KERN_ERR "VIDC: error: dma buffer (%d) %d > 4K
  ",
  				newsize, new2size);
  			new2size = 4096;
  		}
  		/*printk("VIDC: dma size %d
  ", new2size);*/
  		dma_bufsize = new2size;
  		vidc_audio_rate = rate;
  	}
  	return vidc_audio_rate;
  }
  
  static short vidc_audio_set_channels(int dev, short channels)
  {
  	switch (channels) {
  	default:
  		channels = 2;
  	case 1:
  	case 2:
  		vidc_audio_channels = channels;
  		vidc_update_filler(vidc_audio_format, vidc_audio_channels);
  	case 0:
  		break;
  	}
  	return vidc_audio_channels;
  }
  
  /*
   * Open the device
   */
  static int vidc_audio_open(int dev, int mode)
  {
  	/* This audio device does not have recording capability */
  	if (mode == OPEN_READ)
  		return -EPERM;
  
  	if (vidc_busy)
  		return -EBUSY;
  
  	vidc_busy = 1;
  	return 0;
  }
  
  /*
   * Close the device
   */
  static void vidc_audio_close(int dev)
  {
  	vidc_busy = 0;
  }
  
  /*
   * Output a block via DMA to sound device.
   *
   * We just set the DMA start and count; the DMA interrupt routine
   * will take care of formatting the samples (via the appropriate
   * vidc_filler routine), and flag via vidc_audio_dma_interrupt when
   * more data is required.
   */
  static void
  vidc_audio_output_block(int dev, unsigned long buf, int total_count, int one)
  {
  	struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
  	unsigned long flags;
  
  	local_irq_save(flags);
  	dma_start = buf - (unsigned long)dmap->raw_buf_phys + (unsigned long)dmap->raw_buf;
  	dma_count = total_count;
  	local_irq_restore(flags);
  }
  
  static void
  vidc_audio_start_input(int dev, unsigned long buf, int count, int intrflag)
  {
  }
  
  static int vidc_audio_prepare_for_input(int dev, int bsize, int bcount)
  {
  	return -EINVAL;
  }
  
  static irqreturn_t vidc_audio_dma_interrupt(void)
  {
  	DMAbuf_outputintr(vidc_adev, 1);
  	return IRQ_HANDLED;
  }
  
  /*
   * Prepare for outputting samples.
   *
   * Each buffer that will be passed will be `bsize' bytes long,
   * with a total of `bcount' buffers.
   */
  static int vidc_audio_prepare_for_output(int dev, int bsize, int bcount)
  {
  	struct audio_operations *adev = audio_devs[dev];
  
  	dma_interrupt = NULL;
  	adev->dmap_out->flags |= DMA_NODMA;
  
  	return 0;
  }
  
  /*
   * Stop our current operation.
   */
  static void vidc_audio_reset(int dev)
  {
  	dma_interrupt = NULL;
  }
  
  static int vidc_audio_local_qlen(int dev)
  {
  	return /*dma_count !=*/ 0;
  }
  
  static void vidc_audio_trigger(int dev, int enable_bits)
  {
  	struct audio_operations *adev = audio_devs[dev];
  
  	if (enable_bits & PCM_ENABLE_OUTPUT) {
  		if (!(adev->dmap_out->flags & DMA_ACTIVE)) {
  			unsigned long flags;
  
  			local_irq_save(flags);
  
  			/* prevent recusion */
  			adev->dmap_out->flags |= DMA_ACTIVE;
  
  			dma_interrupt = vidc_audio_dma_interrupt;
  			vidc_sound_dma_irq(0, NULL);
  			iomd_writeb(DMA_CR_E | 0x10, IOMD_SD0CR);
  
  			local_irq_restore(flags);
  		}
  	}
  }
  
  static struct audio_driver vidc_audio_driver =
  {
  	.owner			= THIS_MODULE,
  	.open			= vidc_audio_open,
  	.close			= vidc_audio_close,
  	.output_block		= vidc_audio_output_block,
  	.start_input		= vidc_audio_start_input,
  	.prepare_for_input	= vidc_audio_prepare_for_input,
  	.prepare_for_output	= vidc_audio_prepare_for_output,
  	.halt_io		= vidc_audio_reset,
  	.local_qlen		= vidc_audio_local_qlen,
  	.trigger		= vidc_audio_trigger,
  	.set_speed		= vidc_audio_set_speed,
  	.set_bits		= vidc_audio_set_format,
  	.set_channels		= vidc_audio_set_channels
  };
  
  static struct mixer_operations vidc_mixer_operations = {
  	.owner		= THIS_MODULE,
  	.id		= "VIDC",
  	.name		= "VIDCsound",
  	.ioctl		= vidc_mixer_ioctl
  };
  
  void vidc_update_filler(int format, int channels)
  {
  #define TYPE(fmt,ch) (((fmt)<<2) | ((ch)&3))
  
  	switch (TYPE(format, channels)) {
  	default:
  	case TYPE(AFMT_U8, 1):
  		vidc_filler = vidc_fill_1x8_u;
  		break;
  
  	case TYPE(AFMT_U8, 2):
  		vidc_filler = vidc_fill_2x8_u;
  		break;
  
  	case TYPE(AFMT_S8, 1):
  		vidc_filler = vidc_fill_1x8_s;
  		break;
  
  	case TYPE(AFMT_S8, 2):
  		vidc_filler = vidc_fill_2x8_s;
  		break;
  
  	case TYPE(AFMT_S16_LE, 1):
  		vidc_filler = vidc_fill_1x16_s;
  		break;
  
  	case TYPE(AFMT_S16_LE, 2):
  		vidc_filler = vidc_fill_2x16_s;
  		break;
  	}
  }
  
  static void __init attach_vidc(struct address_info *hw_config)
  {
  	char name[32];
  	int i, adev;
  
  	sprintf(name, "VIDC %d-bit sound", hw_config->card_subtype);
  	conf_printf(name, hw_config);
  	memset(dma_buf, 0, sizeof(dma_buf));
  
  	adev = sound_install_audiodrv(AUDIO_DRIVER_VERSION, name,
  			&vidc_audio_driver, sizeof(vidc_audio_driver),
  			DMA_AUTOMODE, AFMT_U8 | AFMT_S8 | AFMT_S16_LE,
  			NULL, hw_config->dma, hw_config->dma2);
  
  	if (adev < 0)
  		goto audio_failed;
  
  	/*
  	 * 1024 bytes => 64 buffers
  	 */
  	audio_devs[adev]->min_fragment = 10;
  	audio_devs[adev]->mixer_dev = num_mixers;
  
  	audio_devs[adev]->mixer_dev =
  		sound_install_mixer(MIXER_DRIVER_VERSION,
  				name, &vidc_mixer_operations,
  				sizeof(vidc_mixer_operations), NULL);
  
  	if (audio_devs[adev]->mixer_dev < 0)
  		goto mixer_failed;
  
  	for (i = 0; i < 2; i++) {
  		dma_buf[i] = get_zeroed_page(GFP_KERNEL);
  		if (!dma_buf[i]) {
  			printk(KERN_ERR "%s: can't allocate required buffers
  ",
  				name);
  			goto mem_failed;
  		}
  		dma_pbuf[i] = virt_to_phys((void *)dma_buf[i]);
  	}
  
  	if (sound_alloc_dma(hw_config->dma, hw_config->name)) {
  		printk(KERN_ERR "%s: DMA %d is in  use
  ", name, hw_config->dma);
  		goto dma_failed;
  	}
  
  	if (request_irq(hw_config->irq, vidc_sound_dma_irq, 0,
  			hw_config->name, &dma_start)) {
  		printk(KERN_ERR "%s: IRQ %d is in use
  ", name, hw_config->irq);
  		goto irq_failed;
  	}
  	vidc_adev = adev;
  	vidc_mixer_set(SOUND_MIXER_VOLUME, (85 | 85 << 8));
  
  	return;
  
  irq_failed:
  	sound_free_dma(hw_config->dma);
  dma_failed:
  mem_failed:
  	for (i = 0; i < 2; i++)
  		free_page(dma_buf[i]);
  	sound_unload_mixerdev(audio_devs[adev]->mixer_dev);
  mixer_failed:
  	sound_unload_audiodev(adev);
  audio_failed:
  	return;
  }
  
  static int __init probe_vidc(struct address_info *hw_config)
  {
  	hw_config->irq		= IRQ_DMAS0;
  	hw_config->dma		= DMA_VIRTUAL_SOUND;
  	hw_config->dma2		= -1;
  	hw_config->card_subtype	= 16;
  	hw_config->name		= "VIDC20";
  	return 1;
  }
  
  static void __exit unload_vidc(struct address_info *hw_config)
  {
  	int i, adev = vidc_adev;
  
  	vidc_adev = -1;
  
  	free_irq(hw_config->irq, &dma_start);
  	sound_free_dma(hw_config->dma);
  
  	if (adev >= 0) {
  		sound_unload_mixerdev(audio_devs[adev]->mixer_dev);
  		sound_unload_audiodev(adev);
  		for (i = 0; i < 2; i++)
  			free_page(dma_buf[i]);
  	}
  }
  
  static struct address_info cfg;
  
  static int __init init_vidc(void)
  {
  	if (probe_vidc(&cfg) == 0)
  		return -ENODEV;
  
  	attach_vidc(&cfg);
  
  	return 0;
  }
  
  static void __exit cleanup_vidc(void)
  {
  	unload_vidc(&cfg);
  }
  
  module_init(init_vidc);
  module_exit(cleanup_vidc);
  
  MODULE_AUTHOR("Russell King");
  MODULE_DESCRIPTION("VIDC20 audio driver");
  MODULE_LICENSE("GPL");