sound/oss/pas2_pcm.c - kernel/msm-4.9 - Gitiles

 /*
  * pas2_pcm.c Audio routines for PAS16
  *
  *
  * 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.
  *
  *
  * Thomas Sailer   : ioctl code reworked (vmalloc/vfree removed)
  * Alan Cox	   : Swatted a double allocation of device bug. Made a few
  *		     more things module options.
  * Bartlomiej Zolnierkiewicz : Added __init to pas_pcm_init()
  */

 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/timex.h>
 #include "sound_config.h"

 #include "pas2.h"

 #define PAS_PCM_INTRBITS (0x08)
 /*
  * Sample buffer timer interrupt enable
  */

 #define PCM_NON	0
 #define PCM_DAC	1
 #define PCM_ADC	2

 static unsigned long pcm_speed; 	/* sampling rate */
 static unsigned char pcm_channels = 1;	/* channels (1 or 2) */
 static unsigned char pcm_bits = 8;	/* bits/sample (8 or 16) */
 static unsigned char pcm_filter;	/* filter FLAG */
 static unsigned char pcm_mode = PCM_NON;
 static unsigned long pcm_count;
 static unsigned short pcm_bitsok = 8;	/* mask of OK bits */
 static int      pcm_busy;
 int             pas_audiodev = -1;
 static int      open_mode;

 extern spinlock_t pas_lock;

 static int pcm_set_speed(int arg)
 {
 	int foo, tmp;
 	unsigned long flags;

 	if (arg == 0)
 		return pcm_speed;

 	if (arg > 44100)
 		arg = 44100;
 	if (arg < 5000)
 		arg = 5000;

 	if (pcm_channels & 2)
 	{
 		foo = ((PIT_TICK_RATE / 2) + (arg / 2)) / arg;
 		arg = ((PIT_TICK_RATE / 2) + (foo / 2)) / foo;
 	}
 	else
 	{
 		foo = (PIT_TICK_RATE + (arg / 2)) / arg;
 		arg = (PIT_TICK_RATE + (foo / 2)) / foo;
 	}

 	pcm_speed = arg;

 	tmp = pas_read(0x0B8A);

 	/*
 	 * Set anti-aliasing filters according to sample rate. You really *NEED*
 	 * to enable this feature for all normal recording unless you want to
 	 * experiment with aliasing effects.
 	 * These filters apply to the selected "recording" source.
 	 * I (pfw) don't know the encoding of these 5 bits. The values shown
 	 * come from the SDK found on ftp.uwp.edu:/pub/msdos/proaudio/.
 	 *
 	 * I cleared bit 5 of these values, since that bit controls the master
 	 * mute flag. (Olav Wölfelschneider)
 	 *
 	 */
 #if !defined NO_AUTO_FILTER_SET
 	tmp &= 0xe0;
 	if (pcm_speed >= 2 * 17897)
 		tmp |= 0x01;
 	else if (pcm_speed >= 2 * 15909)
 		tmp |= 0x02;
 	else if (pcm_speed >= 2 * 11931)
 		tmp |= 0x09;
 	else if (pcm_speed >= 2 * 8948)
 		tmp |= 0x11;
 	else if (pcm_speed >= 2 * 5965)
 		tmp |= 0x19;
 	else if (pcm_speed >= 2 * 2982)
 		tmp |= 0x04;
 	pcm_filter = tmp;
 #endif

 	spin_lock_irqsave(&pas_lock, flags);

 	pas_write(tmp & ~(0x40 | 0x80), 0x0B8A);
 	pas_write(0x00 | 0x30 | 0x04, 0x138B);
 	pas_write(foo & 0xff, 0x1388);
 	pas_write((foo >> 8) & 0xff, 0x1388);
 	pas_write(tmp, 0x0B8A);

 	spin_unlock_irqrestore(&pas_lock, flags);

 	return pcm_speed;
 }

 static int pcm_set_channels(int arg)
 {

 	if ((arg != 1) && (arg != 2))
 		return pcm_channels;

 	if (arg != pcm_channels)
 	{
 		pas_write(pas_read(0xF8A) ^ 0x20, 0xF8A);

 		pcm_channels = arg;
 		pcm_set_speed(pcm_speed);	/* The speed must be reinitialized */
 	}
 	return pcm_channels;
 }

 static int pcm_set_bits(int arg)
 {
 	if (arg == 0)
 		return pcm_bits;

 	if ((arg & pcm_bitsok) != arg)
 		return pcm_bits;

 	if (arg != pcm_bits)
 	{
 		pas_write(pas_read(0x8389) ^ 0x04, 0x8389);

 		pcm_bits = arg;
 	}
 	return pcm_bits;
 }

 static int pas_audio_ioctl(int dev, unsigned int cmd, void __user *arg)
 {
 	int val, ret;
 	int __user *p = arg;

 	switch (cmd)
 	{
 	case SOUND_PCM_WRITE_RATE:
 		if (get_user(val, p))
 			return -EFAULT;
 		ret = pcm_set_speed(val);
 		break;

 	case SOUND_PCM_READ_RATE:
 		ret = pcm_speed;
 		break;

 	case SNDCTL_DSP_STEREO:
 		if (get_user(val, p))
 			return -EFAULT;
 		ret = pcm_set_channels(val + 1) - 1;
 		break;

 	case SOUND_PCM_WRITE_CHANNELS:
 		if (get_user(val, p))
 			return -EFAULT;
 		ret = pcm_set_channels(val);
 		break;

 	case SOUND_PCM_READ_CHANNELS:
 		ret = pcm_channels;
 		break;

 	case SNDCTL_DSP_SETFMT:
 		if (get_user(val, p))
 			return -EFAULT;
 		ret = pcm_set_bits(val);
 		break;

 	case SOUND_PCM_READ_BITS:
 		ret = pcm_bits;
 		break;

 	default:
 		return -EINVAL;
 	}
 	return put_user(ret, p);
 }

 static void pas_audio_reset(int dev)
 {
 	pas_write(pas_read(0xF8A) & ~0x40, 0xF8A);	/* Disable PCM */
 }

 static int pas_audio_open(int dev, int mode)
 {
 	int             err;
 	unsigned long   flags;

 	spin_lock_irqsave(&pas_lock, flags);
 	if (pcm_busy)
 	{
 		spin_unlock_irqrestore(&pas_lock, flags);
 		return -EBUSY;
 	}
 	pcm_busy = 1;
 	spin_unlock_irqrestore(&pas_lock, flags);

 	if ((err = pas_set_intr(PAS_PCM_INTRBITS)) < 0)
 		return err;


 	pcm_count = 0;
 	open_mode = mode;

 	return 0;
 }

 static void pas_audio_close(int dev)
 {
 	unsigned long   flags;

 	spin_lock_irqsave(&pas_lock, flags);

 	pas_audio_reset(dev);
 	pas_remove_intr(PAS_PCM_INTRBITS);
 	pcm_mode = PCM_NON;

 	pcm_busy = 0;
 	spin_unlock_irqrestore(&pas_lock, flags);
 }

 static void pas_audio_output_block(int dev, unsigned long buf, int count,
 		       int intrflag)
 {
 	unsigned long   flags, cnt;

 	cnt = count;
 	if (audio_devs[dev]->dmap_out->dma > 3)
 		cnt >>= 1;

 	if (audio_devs[dev]->flags & DMA_AUTOMODE &&
 	    intrflag &&
 	    cnt == pcm_count)
 		return;

 	spin_lock_irqsave(&pas_lock, flags);

 	pas_write(pas_read(0xF8A) & ~0x40,
 		  0xF8A);

 	/* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */

 	if (audio_devs[dev]->dmap_out->dma > 3)
 		count >>= 1;

 	if (count != pcm_count)
 	{
 		pas_write(pas_read(0x0B8A) & ~0x80, 0x0B8A);
 		pas_write(0x40 | 0x30 | 0x04, 0x138B);
 		pas_write(count & 0xff, 0x1389);
 		pas_write((count >> 8) & 0xff, 0x1389);
 		pas_write(pas_read(0x0B8A) | 0x80, 0x0B8A);

 		pcm_count = count;
 	}
 	pas_write(pas_read(0x0B8A) | 0x80 | 0x40, 0x0B8A);
 #ifdef NO_TRIGGER
 	pas_write(pas_read(0xF8A) | 0x40 | 0x10, 0xF8A);
 #endif

 	pcm_mode = PCM_DAC;

 	spin_unlock_irqrestore(&pas_lock, flags);
 }

 static void pas_audio_start_input(int dev, unsigned long buf, int count,
 		      int intrflag)
 {
 	unsigned long   flags;
 	int             cnt;

 	cnt = count;
 	if (audio_devs[dev]->dmap_out->dma > 3)
 		cnt >>= 1;

 	if (audio_devs[pas_audiodev]->flags & DMA_AUTOMODE &&
 	    intrflag &&
 	    cnt == pcm_count)
 		return;

 	spin_lock_irqsave(&pas_lock, flags);

 	/* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */

 	if (audio_devs[dev]->dmap_out->dma > 3)
 		count >>= 1;

 	if (count != pcm_count)
 	{
 		pas_write(pas_read(0x0B8A) & ~0x80, 0x0B8A);
 		pas_write(0x40 | 0x30 | 0x04, 0x138B);
 		pas_write(count & 0xff, 0x1389);
 		pas_write((count >> 8) & 0xff, 0x1389);
 		pas_write(pas_read(0x0B8A) | 0x80, 0x0B8A);

 		pcm_count = count;
 	}
 	pas_write(pas_read(0x0B8A) | 0x80 | 0x40, 0x0B8A);
 #ifdef NO_TRIGGER
 	pas_write((pas_read(0xF8A) | 0x40) & ~0x10, 0xF8A);
 #endif

 	pcm_mode = PCM_ADC;

 	spin_unlock_irqrestore(&pas_lock, flags);
 }

 #ifndef NO_TRIGGER
 static void pas_audio_trigger(int dev, int state)
 {
 	unsigned long   flags;

 	spin_lock_irqsave(&pas_lock, flags);
 	state &= open_mode;

 	if (state & PCM_ENABLE_OUTPUT)
 		pas_write(pas_read(0xF8A) | 0x40 | 0x10, 0xF8A);
 	else if (state & PCM_ENABLE_INPUT)
 		pas_write((pas_read(0xF8A) | 0x40) & ~0x10, 0xF8A);
 	else
 		pas_write(pas_read(0xF8A) & ~0x40, 0xF8A);

 	spin_unlock_irqrestore(&pas_lock, flags);
 }
 #endif

 static int pas_audio_prepare_for_input(int dev, int bsize, int bcount)
 {
 	pas_audio_reset(dev);
 	return 0;
 }

 static int pas_audio_prepare_for_output(int dev, int bsize, int bcount)
 {
 	pas_audio_reset(dev);
 	return 0;
 }

 static struct audio_driver pas_audio_driver =
 {
 	.owner			= THIS_MODULE,
 	.open			= pas_audio_open,
 	.close			= pas_audio_close,
 	.output_block		= pas_audio_output_block,
 	.start_input		= pas_audio_start_input,
 	.ioctl			= pas_audio_ioctl,
 	.prepare_for_input	= pas_audio_prepare_for_input,
 	.prepare_for_output	= pas_audio_prepare_for_output,
 	.halt_io		= pas_audio_reset,
 	.trigger		= pas_audio_trigger
 };

 void __init pas_pcm_init(struct address_info *hw_config)
 {
 	pcm_bitsok = 8;
 	if (pas_read(0xEF8B) & 0x08)
 		pcm_bitsok |= 16;

 	pcm_set_speed(DSP_DEFAULT_SPEED);

 	if ((pas_audiodev = sound_install_audiodrv(AUDIO_DRIVER_VERSION,
 					"Pro Audio Spectrum",
 					&pas_audio_driver,
 					sizeof(struct audio_driver),
 					DMA_AUTOMODE,
 					AFMT_U8 | AFMT_S16_LE,
 					NULL,
 					hw_config->dma,
 					hw_config->dma)) < 0)
 		printk(KERN_WARNING "PAS16: Too many PCM devices available\n");
 }

 void pas_pcm_interrupt(unsigned char status, int cause)
 {
 	if (cause == 1)
 	{
 		/*
 		 * Halt the PCM first. Otherwise we don't have time to start a new
 		 * block before the PCM chip proceeds to the next sample
 		 */

 		if (!(audio_devs[pas_audiodev]->flags & DMA_AUTOMODE))
 			pas_write(pas_read(0xF8A) & ~0x40, 0xF8A);

 		switch (pcm_mode)
 		{
 			case PCM_DAC:
 				DMAbuf_outputintr(pas_audiodev, 1);
 				break;

 			case PCM_ADC:
 				DMAbuf_inputintr(pas_audiodev);
 				break;

 			default:
 				printk(KERN_WARNING "PAS: Unexpected PCM interrupt\n");
 		}
 	}
 }
	/*
	* pas2_pcm.c Audio routines for PAS16
	*
	*
	* 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.
	*
	*
	* Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
	* Alan Cox : Swatted a double allocation of device bug. Made a few
	* more things module options.
	* Bartlomiej Zolnierkiewicz : Added __init to pas_pcm_init()
	*/

	#include <linux/init.h>
	#include <linux/spinlock.h>
	#include <linux/timex.h>
	#include "sound_config.h"

	#include "pas2.h"

	#define PAS_PCM_INTRBITS (0x08)
	/*
	* Sample buffer timer interrupt enable
	*/

	#define PCM_NON 0
	#define PCM_DAC 1
	#define PCM_ADC 2

	static unsigned long pcm_speed; /* sampling rate */
	static unsigned char pcm_channels = 1; /* channels (1 or 2) */
	static unsigned char pcm_bits = 8; /* bits/sample (8 or 16) */
	static unsigned char pcm_filter; /* filter FLAG */
	static unsigned char pcm_mode = PCM_NON;
	static unsigned long pcm_count;
	static unsigned short pcm_bitsok = 8; /* mask of OK bits */
	static int pcm_busy;
	int pas_audiodev = -1;
	static int open_mode;

	extern spinlock_t pas_lock;

	static int pcm_set_speed(int arg)
	{
	int foo, tmp;
	unsigned long flags;

	if (arg == 0)
	return pcm_speed;

	if (arg > 44100)
	arg = 44100;
	if (arg < 5000)
	arg = 5000;

	if (pcm_channels & 2)
	{
	foo = ((PIT_TICK_RATE / 2) + (arg / 2)) / arg;
	arg = ((PIT_TICK_RATE / 2) + (foo / 2)) / foo;
	}
	else
	{
	foo = (PIT_TICK_RATE + (arg / 2)) / arg;
	arg = (PIT_TICK_RATE + (foo / 2)) / foo;
	}

	pcm_speed = arg;

	tmp = pas_read(0x0B8A);

	/*
	* Set anti-aliasing filters according to sample rate. You really NEED
	* to enable this feature for all normal recording unless you want to
	* experiment with aliasing effects.
	* These filters apply to the selected "recording" source.
	* I (pfw) don't know the encoding of these 5 bits. The values shown
	* come from the SDK found on ftp.uwp.edu:/pub/msdos/proaudio/.
	*
	* I cleared bit 5 of these values, since that bit controls the master
	* mute flag. (Olav Wölfelschneider)
	*
	*/
	#if !defined NO_AUTO_FILTER_SET
	tmp &= 0xe0;
	if (pcm_speed >= 2 * 17897)
	tmp \|= 0x01;
	else if (pcm_speed >= 2 * 15909)
	tmp \|= 0x02;
	else if (pcm_speed >= 2 * 11931)
	tmp \|= 0x09;
	else if (pcm_speed >= 2 * 8948)
	tmp \|= 0x11;
	else if (pcm_speed >= 2 * 5965)
	tmp \|= 0x19;
	else if (pcm_speed >= 2 * 2982)
	tmp \|= 0x04;
	pcm_filter = tmp;
	#endif

	spin_lock_irqsave(&pas_lock, flags);

	pas_write(tmp & ~(0x40 \| 0x80), 0x0B8A);
	pas_write(0x00 \| 0x30 \| 0x04, 0x138B);
	pas_write(foo & 0xff, 0x1388);
	pas_write((foo >> 8) & 0xff, 0x1388);
	pas_write(tmp, 0x0B8A);

	spin_unlock_irqrestore(&pas_lock, flags);

	return pcm_speed;
	}

	static int pcm_set_channels(int arg)
	{

	if ((arg != 1) && (arg != 2))
	return pcm_channels;

	if (arg != pcm_channels)
	{
	pas_write(pas_read(0xF8A) ^ 0x20, 0xF8A);

	pcm_channels = arg;
	pcm_set_speed(pcm_speed); /* The speed must be reinitialized */
	}
	return pcm_channels;
	}

	static int pcm_set_bits(int arg)
	{
	if (arg == 0)
	return pcm_bits;

	if ((arg & pcm_bitsok) != arg)
	return pcm_bits;

	if (arg != pcm_bits)
	{
	pas_write(pas_read(0x8389) ^ 0x04, 0x8389);

	pcm_bits = arg;
	}
	return pcm_bits;
	}

	static int pas_audio_ioctl(int dev, unsigned int cmd, void __user *arg)
	{
	int val, ret;
	int __user *p = arg;

	switch (cmd)
	{
	case SOUND_PCM_WRITE_RATE:
	if (get_user(val, p))
	return -EFAULT;
	ret = pcm_set_speed(val);
	break;

	case SOUND_PCM_READ_RATE:
	ret = pcm_speed;
	break;

	case SNDCTL_DSP_STEREO:
	if (get_user(val, p))
	return -EFAULT;
	ret = pcm_set_channels(val + 1) - 1;
	break;

	case SOUND_PCM_WRITE_CHANNELS:
	if (get_user(val, p))
	return -EFAULT;
	ret = pcm_set_channels(val);
	break;

	case SOUND_PCM_READ_CHANNELS:
	ret = pcm_channels;
	break;

	case SNDCTL_DSP_SETFMT:
	if (get_user(val, p))
	return -EFAULT;
	ret = pcm_set_bits(val);
	break;

	case SOUND_PCM_READ_BITS:
	ret = pcm_bits;
	break;

	default:
	return -EINVAL;
	}
	return put_user(ret, p);
	}

	static void pas_audio_reset(int dev)
	{
	pas_write(pas_read(0xF8A) & ~0x40, 0xF8A); /* Disable PCM */
	}

	static int pas_audio_open(int dev, int mode)
	{
	int err;
	unsigned long flags;

	spin_lock_irqsave(&pas_lock, flags);
	if (pcm_busy)
	{
	spin_unlock_irqrestore(&pas_lock, flags);
	return -EBUSY;
	}
	pcm_busy = 1;
	spin_unlock_irqrestore(&pas_lock, flags);

	if ((err = pas_set_intr(PAS_PCM_INTRBITS)) < 0)
	return err;


	pcm_count = 0;
	open_mode = mode;

	return 0;
	}

	static void pas_audio_close(int dev)
	{
	unsigned long flags;

	spin_lock_irqsave(&pas_lock, flags);

	pas_audio_reset(dev);
	pas_remove_intr(PAS_PCM_INTRBITS);
	pcm_mode = PCM_NON;

	pcm_busy = 0;
	spin_unlock_irqrestore(&pas_lock, flags);
	}

	static void pas_audio_output_block(int dev, unsigned long buf, int count,
	int intrflag)
	{
	unsigned long flags, cnt;

	cnt = count;
	if (audio_devs[dev]->dmap_out->dma > 3)
	cnt >>= 1;

	if (audio_devs[dev]->flags & DMA_AUTOMODE &&
	intrflag &&
	cnt == pcm_count)
	return;

	spin_lock_irqsave(&pas_lock, flags);

	pas_write(pas_read(0xF8A) & ~0x40,
	0xF8A);

	/* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */

	if (audio_devs[dev]->dmap_out->dma > 3)
	count >>= 1;

	if (count != pcm_count)
	{
	pas_write(pas_read(0x0B8A) & ~0x80, 0x0B8A);
	pas_write(0x40 \| 0x30 \| 0x04, 0x138B);
	pas_write(count & 0xff, 0x1389);
	pas_write((count >> 8) & 0xff, 0x1389);
	pas_write(pas_read(0x0B8A) \| 0x80, 0x0B8A);

	pcm_count = count;
	}
	pas_write(pas_read(0x0B8A) \| 0x80 \| 0x40, 0x0B8A);
	#ifdef NO_TRIGGER
	pas_write(pas_read(0xF8A) \| 0x40 \| 0x10, 0xF8A);
	#endif

	pcm_mode = PCM_DAC;

	spin_unlock_irqrestore(&pas_lock, flags);
	}

	static void pas_audio_start_input(int dev, unsigned long buf, int count,
	int intrflag)
	{
	unsigned long flags;
	int cnt;

	cnt = count;
	if (audio_devs[dev]->dmap_out->dma > 3)
	cnt >>= 1;

	if (audio_devs[pas_audiodev]->flags & DMA_AUTOMODE &&
	intrflag &&
	cnt == pcm_count)
	return;

	spin_lock_irqsave(&pas_lock, flags);

	/* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */

	if (audio_devs[dev]->dmap_out->dma > 3)
	count >>= 1;

	if (count != pcm_count)
	{
	pas_write(pas_read(0x0B8A) & ~0x80, 0x0B8A);
	pas_write(0x40 \| 0x30 \| 0x04, 0x138B);
	pas_write(count & 0xff, 0x1389);
	pas_write((count >> 8) & 0xff, 0x1389);
	pas_write(pas_read(0x0B8A) \| 0x80, 0x0B8A);

	pcm_count = count;
	}
	pas_write(pas_read(0x0B8A) \| 0x80 \| 0x40, 0x0B8A);
	#ifdef NO_TRIGGER
	pas_write((pas_read(0xF8A) \| 0x40) & ~0x10, 0xF8A);
	#endif

	pcm_mode = PCM_ADC;

	spin_unlock_irqrestore(&pas_lock, flags);
	}

	#ifndef NO_TRIGGER
	static void pas_audio_trigger(int dev, int state)
	{
	unsigned long flags;

	spin_lock_irqsave(&pas_lock, flags);
	state &= open_mode;

	if (state & PCM_ENABLE_OUTPUT)
	pas_write(pas_read(0xF8A) \| 0x40 \| 0x10, 0xF8A);
	else if (state & PCM_ENABLE_INPUT)
	pas_write((pas_read(0xF8A) \| 0x40) & ~0x10, 0xF8A);
	else
	pas_write(pas_read(0xF8A) & ~0x40, 0xF8A);

	spin_unlock_irqrestore(&pas_lock, flags);
	}
	#endif

	static int pas_audio_prepare_for_input(int dev, int bsize, int bcount)
	{
	pas_audio_reset(dev);
	return 0;
	}

	static int pas_audio_prepare_for_output(int dev, int bsize, int bcount)
	{
	pas_audio_reset(dev);
	return 0;
	}

	static struct audio_driver pas_audio_driver =
	{
	.owner = THIS_MODULE,
	.open = pas_audio_open,
	.close = pas_audio_close,
	.output_block = pas_audio_output_block,
	.start_input = pas_audio_start_input,
	.ioctl = pas_audio_ioctl,
	.prepare_for_input = pas_audio_prepare_for_input,
	.prepare_for_output = pas_audio_prepare_for_output,
	.halt_io = pas_audio_reset,
	.trigger = pas_audio_trigger
	};

	void __init pas_pcm_init(struct address_info *hw_config)
	{
	pcm_bitsok = 8;
	if (pas_read(0xEF8B) & 0x08)
	pcm_bitsok \|= 16;

	pcm_set_speed(DSP_DEFAULT_SPEED);

	if ((pas_audiodev = sound_install_audiodrv(AUDIO_DRIVER_VERSION,
	"Pro Audio Spectrum",
	&pas_audio_driver,
	sizeof(struct audio_driver),
	DMA_AUTOMODE,
	AFMT_U8 \| AFMT_S16_LE,
	NULL,
	hw_config->dma,
	hw_config->dma)) < 0)
	printk(KERN_WARNING "PAS16: Too many PCM devices available\n");
	}

	void pas_pcm_interrupt(unsigned char status, int cause)
	{
	if (cause == 1)
	{
	/*
	* Halt the PCM first. Otherwise we don't have time to start a new
	* block before the PCM chip proceeds to the next sample
	*/

	if (!(audio_devs[pas_audiodev]->flags & DMA_AUTOMODE))
	pas_write(pas_read(0xF8A) & ~0x40, 0xF8A);

	switch (pcm_mode)
	{
	case PCM_DAC:
	DMAbuf_outputintr(pas_audiodev, 1);
	break;

	case PCM_ADC:
	DMAbuf_inputintr(pas_audiodev);
	break;

	default:
	printk(KERN_WARNING "PAS: Unexpected PCM interrupt\n");
	}
	}
	}