patch-2.1.94 linux/drivers/sound/sb_audio.c

Next file: linux/drivers/sound/sb_card.c
Previous file: linux/drivers/sound/sb.h
Back to the patch index
Back to the overall index

diff -u --recursive --new-file v2.1.93/linux/drivers/sound/sb_audio.c linux/drivers/sound/sb_audio.c
@@ -2,17 +2,22 @@
  * sound/sb_audio.c
  *
  * Audio routines for Sound Blaster compatible cards.
- */
-/*
+ *
+ *
  * 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.
+ *
+ * Changes
+ *	Alan Cox	:	Formatting and clean ups
+ *
+ * Status
+ *	Mostly working. mmap bug still present (swaps channels)
  */
-#include <linux/config.h>
-
 
+#include <linux/config.h>
 #include "sound_config.h"
 
 #if defined(CONFIG_SBDSP) || defined(MODULE)
@@ -20,67 +25,84 @@
 #include "sb_mixer.h"
 #include "sb.h"
 
-static int
-sb_audio_open(int dev, int mode)
+static int sb_audio_open(int dev, int mode)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
-	unsigned long   flags;
+	sb_devc *devc = audio_devs[dev]->devc;
+	unsigned long flags;
 
 	if (devc == NULL)
-	  {
-		  printk("SB: Incomplete initialization\n");
+	{
+		  printk(KERN_ERR "SB: Incomplete initialization\n");
 		  return -ENXIO;
-	  }
+	}
 	if (devc->caps & SB_NO_RECORDING && mode & OPEN_READ)
-	  {
-		  printk("Notice: Recording is not possible with /dev/dsp%d\n", dev);
-		  if (mode == OPEN_READ)
-			  return -EPERM;
-	  }
+	{
+		if (mode == OPEN_READ)
+			return -EPERM;
+	}
 	save_flags(flags);
 	cli();
 	if (devc->opened)
-	  {
+	{
 		  restore_flags(flags);
 		  return -EBUSY;
-	  }
+	}
 	if (devc->dma16 != -1 && devc->dma16 != devc->dma8)
-	  {
-		  if (sound_open_dma(devc->dma16, "Sound Blaster 16 bit"))
-		    {
-			    restore_flags(flags);
-			    return -EBUSY;
-		    }
-	  }
+	{
+		if (sound_open_dma(devc->dma16, "Sound Blaster 16 bit"))
+		{
+			restore_flags(flags);
+			return -EBUSY;
+		}
+	}
 	devc->opened = mode;
 	restore_flags(flags);
 
 	devc->irq_mode = IMODE_NONE;
 	sb_dsp_reset(devc);
 
+	/* The ALS007 seems to require that the DSP be removed from the output */
+	/* in order for recording to be activated properly.  This is done by   */
+	/* setting the appropriate bits of the output control register 4ch to  */
+	/* zero.  This code assumes that the output control registers are not  */
+	/* used anywhere else and therefore the DSP bits are *always* ON for   */
+	/* output and OFF for sampling.                                        */
+
+	if (devc->submodel == SUBMDL_ALS007) 
+	{
+		if (mode & OPEN_READ) 
+			sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
+				sb_getmixer(devc,ALS007_OUTPUT_CTRL2) & 0xf9);
+		else
+			sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
+				sb_getmixer(devc,ALS007_OUTPUT_CTRL2) | 0x06);
+	}
 	return 0;
 }
 
-static void
-sb_audio_close(int dev)
+static void sb_audio_close(int dev)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
+	sb_devc *devc = audio_devs[dev]->devc;
 
-	audio_devs[dev]->dmap_in->dma =
-	    audio_devs[dev]->dmap_out->dma =
-	    devc->dma8;
+	audio_devs[dev]->dmap_in->dma = audio_devs[dev]->dmap_out->dma = devc->dma8;
 
 	if (devc->dma16 != -1 && devc->dma16 != devc->dma8)
 		sound_close_dma(devc->dma16);
 
+	/* For ALS007, turn DSP output back on if closing the device for read */
+	
+	if ((devc->submodel == SUBMDL_ALS007) && (devc->opened & OPEN_READ)) 
+	{
+		sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
+			sb_getmixer(devc,ALS007_OUTPUT_CTRL2) | 0x06);
+	}
 	devc->opened = 0;
 }
 
-static void
-sb_set_output_parms(int dev, unsigned long buf, int nr_bytes,
+static void sb_set_output_parms(int dev, unsigned long buf, int nr_bytes,
 		    int intrflag)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	devc->trg_buf = buf;
 	devc->trg_bytes = nr_bytes;
@@ -88,10 +110,9 @@
 	devc->irq_mode = IMODE_OUTPUT;
 }
 
-static void
-sb_set_input_parms(int dev, unsigned long buf, int count, int intrflag)
+static void sb_set_input_parms(int dev, unsigned long buf, int count, int intrflag)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	devc->trg_buf = buf;
 	devc->trg_bytes = count;
@@ -103,13 +124,11 @@
  * SB1.x compatible routines 
  */
 
-static void
-sb1_audio_output_block(int dev, unsigned long buf, int nr_bytes,
-		       int intrflag)
+static void sb1_audio_output_block(int dev, unsigned long buf, int nr_bytes, int intrflag)
 {
-	unsigned long   flags;
-	int             count = nr_bytes;
-	sb_devc        *devc = audio_devs[dev]->devc;
+	unsigned long flags;
+	int count = nr_bytes;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	/* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
 
@@ -122,21 +141,21 @@
 	save_flags(flags);
 	cli();
 	if (sb_dsp_command(devc, 0x14))		/* 8 bit DAC using DMA */
-	  {
-		  sb_dsp_command(devc, (unsigned char) (count & 0xff));
-		  sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
-	} else
-		printk("SB: Unable to start DAC\n");
+	{
+		sb_dsp_command(devc, (unsigned char) (count & 0xff));
+		sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
+	}
+	else
+		printk(KERN_WARNING "soundblaster: Unable to start DAC\n");
 	restore_flags(flags);
 	devc->intr_active = 1;
 }
 
-static void
-sb1_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag)
+static void sb1_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag)
 {
-	unsigned long   flags;
-	int             count = nr_bytes;
-	sb_devc        *devc = audio_devs[dev]->devc;
+	unsigned long flags;
+	int count = nr_bytes;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	/*
 	 * Start a DMA input to the buffer pointed by dmaqtail
@@ -153,49 +172,47 @@
 	save_flags(flags);
 	cli();
 	if (sb_dsp_command(devc, 0x24))		/* 8 bit ADC using DMA */
-	  {
-		  sb_dsp_command(devc, (unsigned char) (count & 0xff));
-		  sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
-	} else
-		printk("SB Error: Unable to start ADC\n");
+	{
+		sb_dsp_command(devc, (unsigned char) (count & 0xff));
+		sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
+	}
+	else
+		printk(KERN_ERR "soundblaster: Unable to start ADC\n");
 	restore_flags(flags);
 
 	devc->intr_active = 1;
 }
 
-static void
-sb1_audio_trigger(int dev, int bits)
+static void sb1_audio_trigger(int dev, int bits)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	bits &= devc->irq_mode;
 
 	if (!bits)
 		sb_dsp_command(devc, 0xd0);	/* Halt DMA */
 	else
-	  {
-		  switch (devc->irq_mode)
-		    {
-		    case IMODE_INPUT:
-			    sb1_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
-						  devc->trg_intrflag);
-			    break;
-
-		    case IMODE_OUTPUT:
-			    sb1_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
-						   devc->trg_intrflag);
-			    break;
-		    }
-	  }
+	{
+		switch (devc->irq_mode)
+		{
+			case IMODE_INPUT:
+				sb1_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
+						devc->trg_intrflag);
+				break;
 
+			case IMODE_OUTPUT:
+				sb1_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
+						devc->trg_intrflag);
+				break;
+		}
+	}
 	devc->trigger_bits = bits;
 }
 
-static int
-sb1_audio_prepare_for_input(int dev, int bsize, int bcount)
+static int sb1_audio_prepare_for_input(int dev, int bsize, int bcount)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
-	unsigned long   flags;
+	sb_devc *devc = audio_devs[dev]->devc;
+	unsigned long flags;
 
 	save_flags(flags);
 	cli();
@@ -208,11 +225,10 @@
 	return 0;
 }
 
-static int
-sb1_audio_prepare_for_output(int dev, int bsize, int bcount)
+static int sb1_audio_prepare_for_output(int dev, int bsize, int bcount)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
-	unsigned long   flags;
+	sb_devc *devc = audio_devs[dev]->devc;
+	unsigned long flags;
 
 	save_flags(flags);
 	cli();
@@ -224,55 +240,48 @@
 	return 0;
 }
 
-static int
-sb1_audio_set_speed(int dev, int speed)
+static int sb1_audio_set_speed(int dev, int speed)
 {
-	int             max_speed = 23000;
-	sb_devc        *devc = audio_devs[dev]->devc;
-	int             tmp;
+	int max_speed = 23000;
+	sb_devc *devc = audio_devs[dev]->devc;
+	int tmp;
 
 	if (devc->opened & OPEN_READ)
 		max_speed = 13000;
 
 	if (speed > 0)
-	  {
-		  if (speed < 4000)
-			  speed = 4000;
-
-		  if (speed > max_speed)
-			  speed = max_speed;
+	{
+		if (speed < 4000)
+			speed = 4000;
 
-		  devc->tconst = (256 - ((1000000 + speed / 2) / speed)) & 0xff;
+		if (speed > max_speed)
+			speed = max_speed;
 
-		  tmp = 256 - devc->tconst;
-		  speed = (1000000 + tmp / 2) / tmp;
+		devc->tconst = (256 - ((1000000 + speed / 2) / speed)) & 0xff;
+		tmp = 256 - devc->tconst;
+		speed = (1000000 + tmp / 2) / tmp;
 
-		  devc->speed = speed;
-	  }
+		devc->speed = speed;
+	}
 	return devc->speed;
 }
 
-static short
-sb1_audio_set_channels(int dev, short channels)
+static short sb1_audio_set_channels(int dev, short channels)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
-
+	sb_devc *devc = audio_devs[dev]->devc;
 	return devc->channels = 1;
 }
 
-static unsigned int
-sb1_audio_set_bits(int dev, unsigned int bits)
+static unsigned int sb1_audio_set_bits(int dev, unsigned int bits)
 {
 	sb_devc        *devc = audio_devs[dev]->devc;
-
 	return devc->bits = 8;
 }
 
-static void
-sb1_audio_halt_xfer(int dev)
+static void sb1_audio_halt_xfer(int dev)
 {
-	unsigned long   flags;
-	sb_devc        *devc = audio_devs[dev]->devc;
+	unsigned long flags;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	save_flags(flags);
 	cli();
@@ -284,14 +293,13 @@
  * SB 2.0 and SB 2.01 compatible routines
  */
 
-static void
-sb20_audio_output_block(int dev, unsigned long buf, int nr_bytes,
+static void sb20_audio_output_block(int dev, unsigned long buf, int nr_bytes,
 			int intrflag)
 {
-	unsigned long   flags;
-	int             count = nr_bytes;
-	sb_devc        *devc = audio_devs[dev]->devc;
-	unsigned char   cmd;
+	unsigned long flags;
+	int count = nr_bytes;
+	sb_devc *devc = audio_devs[dev]->devc;
+	unsigned char cmd;
 
 	/* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
 
@@ -304,31 +312,30 @@
 	save_flags(flags);
 	cli();
 	if (sb_dsp_command(devc, 0x48))		/* DSP Block size */
-	  {
-		  sb_dsp_command(devc, (unsigned char) (count & 0xff));
-		  sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
-
-		  if (devc->speed * devc->channels <= 23000)
-			  cmd = 0x1c;	/* 8 bit PCM output */
-		  else
-			  cmd = 0x90;	/* 8 bit high speed PCM output (SB2.01/Pro) */
+	{
+		sb_dsp_command(devc, (unsigned char) (count & 0xff));
+		sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
 
-		  if (!sb_dsp_command(devc, cmd))
-			  printk("SB: Unable to start DAC\n");
+		if (devc->speed * devc->channels <= 23000)
+			cmd = 0x1c;	/* 8 bit PCM output */
+		else
+			cmd = 0x90;	/* 8 bit high speed PCM output (SB2.01/Pro) */
 
-	} else
-		printk("SB: Unable to start DAC\n");
+		if (!sb_dsp_command(devc, cmd))
+			printk(KERN_ERR "soundblaster: Unable to start DAC\n");
+	}
+	else
+		printk(KERN_ERR "soundblaster: Unable to start DAC\n");
 	restore_flags(flags);
 	devc->intr_active = 1;
 }
 
-static void
-sb20_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag)
+static void sb20_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag)
 {
-	unsigned long   flags;
-	int             count = nr_bytes;
-	sb_devc        *devc = audio_devs[dev]->devc;
-	unsigned char   cmd;
+	unsigned long flags;
+	int count = nr_bytes;
+	sb_devc *devc = audio_devs[dev]->devc;
+	unsigned char cmd;
 
 	/*
 	 * Start a DMA input to the buffer pointed by dmaqtail
@@ -345,49 +352,46 @@
 	save_flags(flags);
 	cli();
 	if (sb_dsp_command(devc, 0x48))		/* DSP Block size */
-	  {
-		  sb_dsp_command(devc, (unsigned char) (count & 0xff));
-		  sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
-
-		  if (devc->speed * devc->channels <= (devc->major == 3 ? 23000 : 13000))
-			  cmd = 0x2c;	/* 8 bit PCM input */
-		  else
-			  cmd = 0x98;	/* 8 bit high speed PCM input (SB2.01/Pro) */
-
-		  if (!sb_dsp_command(devc, cmd))
-			  printk("SB: Unable to start ADC\n");
-	} else
-		printk("SB Error: Unable to start ADC\n");
-	restore_flags(flags);
+	{
+		sb_dsp_command(devc, (unsigned char) (count & 0xff));
+		sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
 
+		if (devc->speed * devc->channels <= (devc->major == 3 ? 23000 : 13000))
+			cmd = 0x2c;	/* 8 bit PCM input */
+		else
+			cmd = 0x98;	/* 8 bit high speed PCM input (SB2.01/Pro) */
+
+		if (!sb_dsp_command(devc, cmd))
+			printk(KERN_ERR "soundblaster: Unable to start ADC\n");
+	}
+	else
+		printk(KERN_ERR "soundblaster: Unable to start ADC\n");
+	restore_flags(flags);
 	devc->intr_active = 1;
 }
 
-static void
-sb20_audio_trigger(int dev, int bits)
+static void sb20_audio_trigger(int dev, int bits)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
-
+	sb_devc *devc = audio_devs[dev]->devc;
 	bits &= devc->irq_mode;
 
 	if (!bits)
 		sb_dsp_command(devc, 0xd0);	/* Halt DMA */
 	else
-	  {
-		  switch (devc->irq_mode)
-		    {
-		    case IMODE_INPUT:
-			    sb20_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
-						   devc->trg_intrflag);
-			    break;
+	{
+		switch (devc->irq_mode)
+		{
+			case IMODE_INPUT:
+				sb20_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
+						devc->trg_intrflag);
+				break;
 
-		    case IMODE_OUTPUT:
-			    sb20_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
-						    devc->trg_intrflag);
+			case IMODE_OUTPUT:
+				sb20_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
+						devc->trg_intrflag);
 			    break;
-		    }
-	  }
-
+		}
+	}
 	devc->trigger_bits = bits;
 }
 
@@ -395,32 +399,26 @@
  * SB2.01 specific speed setup
  */
 
-static int
-sb201_audio_set_speed(int dev, int speed)
+static int sb201_audio_set_speed(int dev, int speed)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
-	int             tmp;
-	int             s = speed * devc->channels;
+	sb_devc *devc = audio_devs[dev]->devc;
+	int tmp;
+	int s = speed * devc->channels;
 
 	if (speed > 0)
-	  {
-		  if (speed < 4000)
-			  speed = 4000;
-
-		  if (speed > 44100)
-			  speed = 44100;
-
-		  if (devc->opened & OPEN_READ && speed > 15000)
-			  speed = 15000;
-
-		  devc->tconst = ((65536 - ((256000000 + s / 2) /
-					    s)) >> 8) & 0xff;
-
-		  tmp = 256 - devc->tconst;
-		  speed = ((1000000 + tmp / 2) / tmp) / devc->channels;
+	{
+		if (speed < 4000)
+			speed = 4000;
+		if (speed > 44100)
+			speed = 44100;
+		if (devc->opened & OPEN_READ && speed > 15000)
+			speed = 15000;
+		devc->tconst = ((65536 - ((256000000 + s / 2) / s)) >> 8) & 0xff;
+		tmp = 256 - devc->tconst;
+		speed = ((1000000 + tmp / 2) / tmp) / devc->channels;
 
-		  devc->speed = speed;
-	  }
+		devc->speed = speed;
+	}
 	return devc->speed;
 }
 
@@ -428,17 +426,15 @@
  * SB Pro specific routines
  */
 
-static int
-sbpro_audio_prepare_for_input(int dev, int bsize, int bcount)
+static int sbpro_audio_prepare_for_input(int dev, int bsize, int bcount)
 {				/* For SB Pro and Jazz16 */
-	sb_devc        *devc = audio_devs[dev]->devc;
-	unsigned long   flags;
-	unsigned char   bits = 0;
+	sb_devc *devc = audio_devs[dev]->devc;
+	unsigned long flags;
+	unsigned char bits = 0;
 
 	if (devc->dma16 >= 0 && devc->dma16 != devc->dma8)
-		audio_devs[dev]->dmap_out->dma =
-		    audio_devs[dev]->dmap_in->dma =
-		    devc->bits == 16 ? devc->dma16 : devc->dma8;
+		audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma =
+			devc->bits == 16 ? devc->dma16 : devc->dma8;
 
 	if (devc->model == MDL_JAZZ || devc->model == MDL_SMW)
 		if (devc->bits == AFMT_S16_LE)
@@ -459,18 +455,15 @@
 	return 0;
 }
 
-static int
-sbpro_audio_prepare_for_output(int dev, int bsize, int bcount)
+static int sbpro_audio_prepare_for_output(int dev, int bsize, int bcount)
 {				/* For SB Pro and Jazz16 */
-	sb_devc        *devc = audio_devs[dev]->devc;
-	unsigned long   flags;
-	unsigned char   tmp;
-	unsigned char   bits = 0;
+	sb_devc *devc = audio_devs[dev]->devc;
+	unsigned long flags;
+	unsigned char tmp;
+	unsigned char bits = 0;
 
 	if (devc->dma16 >= 0 && devc->dma16 != devc->dma8)
-		audio_devs[dev]->dmap_out->dma =
-		    audio_devs[dev]->dmap_in->dma =
-		    devc->bits == 16 ? devc->dma16 : devc->dma8;
+		audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma = devc->bits == 16 ? devc->dma16 : devc->dma8;
 	if (devc->model == MDL_SBPRO)
 		sb_mixer_set_stereo(devc, devc->channels == 2);
 
@@ -481,92 +474,83 @@
 	sb_dsp_command(devc, DSP_CMD_SPKON);
 
 	if (devc->model == MDL_JAZZ || devc->model == MDL_SMW)
-	  {
-		  if (devc->bits == AFMT_S16_LE)
-			  bits = 0x04;	/* 16 bit mode */
-
-		  if (devc->channels == 1)
-			  sb_dsp_command(devc, 0xa0 | bits);	/* Mono output */
-		  else
-			  sb_dsp_command(devc, 0xa8 | bits);	/* Stereo output */
-	} else
-	  {
-		  tmp = sb_getmixer(devc, 0x0e);
-		  if (devc->channels == 1)
-			  tmp &= ~0x02;
-		  else
-			  tmp |= 0x02;
-		  sb_setmixer(devc, 0x0e, tmp);
-	  }
+	{
+		if (devc->bits == AFMT_S16_LE)
+			bits = 0x04;	/* 16 bit mode */
+
+		if (devc->channels == 1)
+			sb_dsp_command(devc, 0xa0 | bits);	/* Mono output */
+		else
+			sb_dsp_command(devc, 0xa8 | bits);	/* Stereo output */
+	}
+	else
+	{
+		tmp = sb_getmixer(devc, 0x0e);
+		if (devc->channels == 1)
+			tmp &= ~0x02;
+		else
+			tmp |= 0x02;
+		sb_setmixer(devc, 0x0e, tmp);
+	}
 	restore_flags(flags);
 	devc->trigger_bits = 0;
 	return 0;
 }
 
-static int
-sbpro_audio_set_speed(int dev, int speed)
+static int sbpro_audio_set_speed(int dev, int speed)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	if (speed > 0)
-	  {
-		  if (speed < 4000)
-			  speed = 4000;
-
-		  if (speed > 44100)
-			  speed = 44100;
-
-		  if (devc->channels > 1 && speed > 22050)
-			  speed = 22050;
-
-		  sb201_audio_set_speed(dev, speed);
-	  }
+	{
+		if (speed < 4000)
+			speed = 4000;
+		if (speed > 44100)
+			speed = 44100;
+		if (devc->channels > 1 && speed > 22050)
+			speed = 22050;
+		sb201_audio_set_speed(dev, speed);
+	}
 	return devc->speed;
 }
 
-static short
-sbpro_audio_set_channels(int dev, short channels)
+static short sbpro_audio_set_channels(int dev, short channels)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	if (channels == 1 || channels == 2)
+	{
 		if (channels != devc->channels)
-		  {
-			  devc->channels = channels;
-			  if (devc->model == MDL_SBPRO && devc->channels == 2)
-			    {
-				    if (devc->speed > 22050)
-					    printk("OSS: Application error. Wrong ioctl call order.\n");
-				    sbpro_audio_set_speed(dev, devc->speed);
-			    }
-		  }
+		{
+			devc->channels = channels;
+			if (devc->model == MDL_SBPRO && devc->channels == 2)
+				sbpro_audio_set_speed(dev, devc->speed);
+		}
+	}
 	return devc->channels;
 }
 
-static int
-jazz16_audio_set_speed(int dev, int speed)
+static int jazz16_audio_set_speed(int dev, int speed)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	if (speed > 0)
-	  {
-		  int             tmp;
-		  int             s = speed * devc->channels;
-
-		  if (speed < 5000)
-			  speed = 4000;
+	{
+		int tmp;
+		int s = speed * devc->channels;
 
-		  if (speed > 44100)
-			  speed = 44100;
+		if (speed < 5000)
+			speed = 5000;
+		if (speed > 44100)
+			speed = 44100;
 
-		  devc->tconst = ((65536 - ((256000000 + s / 2) /
-					    s)) >> 8) & 0xff;
+		devc->tconst = ((65536 - ((256000000 + s / 2) / s)) >> 8) & 0xff;
 
-		  tmp = 256 - devc->tconst;
-		  speed = ((1000000 + tmp / 2) / tmp) / devc->channels;
+		tmp = 256 - devc->tconst;
+		speed = ((1000000 + tmp / 2) / tmp) / devc->channels;
 
-		  devc->speed = speed;
-	  }
+		devc->speed = speed;
+	}
 	return devc->speed;
 }
 
@@ -574,124 +558,123 @@
  * ESS specific routines
  */
 
-static int
-ess_audio_set_speed(int dev, int speed)
+static int ess_audio_set_speed(int dev, int speed)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
-	int             divider;
+	sb_devc *devc = audio_devs[dev]->devc;
+	int divider;
 
 	if (speed > 0)
-	  {
-		  if (speed < 5000)
-			  speed = 4000;
-
-		  if (speed > 48000)
-			  speed = 48000;
-
-		  if (speed > 22000)
-		    {
-			    divider = (795500 + speed / 2) / speed;
-			    speed = (795500 + divider / 2) / divider;
-		  } else
-		    {
-			    divider = (397700 + speed / 2) / speed;
-			    speed = (397700 + divider / 2) / divider;
-		    }
+	{
+		if (speed < 5000)
+			speed = 5000;
+		if (speed > 48000)
+			speed = 48000;
 
-		  devc->speed = speed;
-	  }
+		if (speed > 22000)
+		{
+			divider = (795500 + speed / 2) / speed;
+			speed = (795500 + divider / 2) / divider;
+		}
+		else
+		{
+			divider = (397700 + speed / 2) / speed;
+			speed = (397700 + divider / 2) / divider;
+		}
+		devc->speed = speed;
+	}
 	return devc->speed;
 }
 
-static void
-ess_speed(sb_devc * devc)
+static void ess_speed(sb_devc * devc)
 {
-	int             divider;
-	unsigned char   bits = 0;
-	int             speed = devc->speed;
+	int divider;
+	unsigned char bits = 0;
+	int speed = devc->speed;
 
 	if (speed < 4000)
 		speed = 4000;
 	else if (speed > 48000)
 		speed = 48000;
-
+	
 	if (speed > 22000)
-	  {
-		  bits = 0x80;
-		  divider = 256 - (795500 + speed / 2) / speed;
-	} else
-	  {
-		  divider = 128 - (397700 + speed / 2) / speed;
-	  }
+	{
+		bits = 0x80;
+		divider = 256 - (795500 + speed / 2) / speed;
+	}
+	else
+	{
+		divider = 128 - (397700 + speed / 2) / speed;
+	}
 
 	bits |= (unsigned char) divider;
 	ess_write(devc, 0xa1, bits);
 
-/*
- * Set filter divider register
- */
+	/*
+	 * Set filter divider register
+	 */
 
 	speed = (speed * 9) / 20;	/* Set filter roll-off to 90% of speed/2 */
 	divider = 256 - 7160000 / (speed * 82);
 	ess_write(devc, 0xa2, divider);
-
 	return;
 }
 
-static int
-ess_audio_prepare_for_input(int dev, int bsize, int bcount)
+static int ess_audio_prepare_for_input(int dev, int bsize, int bcount)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
-
+	sb_devc *devc = audio_devs[dev]->devc;
 	ess_speed(devc);
 	sb_dsp_command(devc, DSP_CMD_SPKOFF);
 
 	ess_write(devc, 0xb8, 0x0e);	/* Auto init DMA mode */
-	ess_write(devc, 0xa8, (ess_read(devc, 0xa8) & ~0x03) |
-		  (3 - devc->channels));	/* Mono/stereo */
+	ess_write(devc, 0xa8, (ess_read(devc, 0xa8) & ~0x03) | (3 - devc->channels));	/* Mono/stereo */
 	ess_write(devc, 0xb9, 2);	/* Demand mode (4 bytes/DMA request) */
 
 	if (devc->channels == 1)
-	  {
-		  if (devc->bits == AFMT_U8)
-		    {		/* 8 bit mono */
-			    ess_write(devc, 0xb7, 0x51);
-			    ess_write(devc, 0xb7, 0xd0);
-		  } else
-		    {		/* 16 bit mono */
-			    ess_write(devc, 0xb7, 0x71);
-			    ess_write(devc, 0xb7, 0xf4);
-		    }
-	} else
-	  {			/* Stereo */
-		  if (devc->bits == AFMT_U8)
-		    {		/* 8 bit stereo */
-			    ess_write(devc, 0xb7, 0x51);
-			    ess_write(devc, 0xb7, 0x98);
-		  } else
-		    {		/* 16 bit stereo */
-			    ess_write(devc, 0xb7, 0x71);
-			    ess_write(devc, 0xb7, 0xbc);
-		    }
-	  }
-
+	{
+		if (devc->bits == AFMT_U8)
+		{	
+			/* 8 bit mono */
+			ess_write(devc, 0xb7, 0x51);
+			ess_write(devc, 0xb7, 0xd0);
+		}
+		else
+		{
+			/* 16 bit mono */
+			ess_write(devc, 0xb7, 0x71);
+			ess_write(devc, 0xb7, 0xf4);
+		}
+	}
+	else
+	{	
+		/* Stereo */
+		if (devc->bits == AFMT_U8)
+		{
+			/* 8 bit stereo */
+			ess_write(devc, 0xb7, 0x51);
+			ess_write(devc, 0xb7, 0x98);
+		}
+		else
+		{	
+			/* 16 bit stereo */
+			ess_write(devc, 0xb7, 0x71);
+			ess_write(devc, 0xb7, 0xbc);
+		}
+	}
 	ess_write(devc, 0xb1, (ess_read(devc, 0xb1) & 0x0f) | 0x50);
 	ess_write(devc, 0xb2, (ess_read(devc, 0xb2) & 0x0f) | 0x50);
-
 	devc->trigger_bits = 0;
 	return 0;
 }
 
 static int ess_audio_prepare_for_output(int dev, int bsize, int bcount)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	sb_dsp_reset(devc);
 	ess_speed(devc);
 
 	ess_write(devc, 0xb8, 4);	/* Auto init DMA mode */
-	ess_write(devc, 0xa8, (ess_read(devc, 0xa8) & ~0x03) |
-		  (3 - devc->channels));	/* Mono/stereo */
+	ess_write(devc, 0xa8, (ess_read(devc, 0xa8) & ~0x03) | (3 - devc->channels));	/* Mono/stereo */
 	ess_write(devc, 0xb9, 2);	/* Demand mode (4 bytes/request) */
 
 	if (devc->channels == 1)
@@ -701,7 +684,8 @@
 			ess_write(devc, 0xb6, 0x80);
 			ess_write(devc, 0xb7, 0x51);
 			ess_write(devc, 0xb7, 0xd0);
-		  } else
+		}
+		else
 		{	/* 16 bit mono */
 			ess_write(devc, 0xb6, 0x00);
 			ess_write(devc, 0xb7, 0x71);
@@ -733,11 +717,11 @@
 }
 
 static void ess_audio_output_block(int dev, unsigned long buf, int nr_bytes,
-		       int intrflag)
+			int intrflag)
 {
-	int             count = nr_bytes;
-	sb_devc        *devc = audio_devs[dev]->devc;
-	short           c = -nr_bytes;
+	int count = nr_bytes;
+	sb_devc *devc = audio_devs[dev]->devc;
+	short c = -nr_bytes;
 
 	/* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
 
@@ -756,9 +740,9 @@
 
 static void ess_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag)
 {
-	int             count = nr_bytes;
-	sb_devc        *devc = audio_devs[dev]->devc;
-	short           c = -nr_bytes;
+	int count = nr_bytes;
+	sb_devc *devc = audio_devs[dev]->devc;
+	short c = -nr_bytes;
 
 	/*
 	 * Start a DMA input to the buffer pointed by dmaqtail
@@ -781,7 +765,7 @@
 
 static void ess_audio_trigger(int dev, int bits)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	bits &= devc->irq_mode;
 
@@ -812,7 +796,7 @@
 
 static int sb16_audio_set_speed(int dev, int speed)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	if (speed > 0)
 	{
@@ -829,7 +813,7 @@
 
 static unsigned int sb16_audio_set_bits(int dev, unsigned int bits)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	if (bits != 0)
 	{
@@ -844,7 +828,7 @@
 
 static int sb16_audio_prepare_for_input(int dev, int bsize, int bcount)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
+	sb_devc *devc = audio_devs[dev]->devc;
 
 	audio_devs[dev]->dmap_out->dma =
 	    audio_devs[dev]->dmap_in->dma =
@@ -856,11 +840,10 @@
 
 static int sb16_audio_prepare_for_output(int dev, int bsize, int bcount)
 {
-	sb_devc        *devc = audio_devs[dev]->devc;
+	sb_devc *devc = audio_devs[dev]->devc;
 
-	audio_devs[dev]->dmap_out->dma =
-	    audio_devs[dev]->dmap_in->dma =
-	    devc->bits == AFMT_S16_LE ? devc->dma16 : devc->dma8;
+	audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma =
+			devc->bits == AFMT_S16_LE ? devc->dma16 : devc->dma8;
 
 	devc->trigger_bits = 0;
 	return 0;
@@ -1098,8 +1081,8 @@
 
 void sb_audio_init(sb_devc * devc, char *name)
 {
-	int             audio_flags = 0;
-	int             format_mask = AFMT_U8;
+	int audio_flags = 0;
+	int format_mask = AFMT_U8;
 
 	struct audio_driver *driver = &sb1_audio_driver;
 
@@ -1151,14 +1134,9 @@
 	}
 
 	if ((devc->my_dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION,
-						name,
-						driver,
-						sizeof(struct audio_driver),
-						audio_flags,
-						format_mask,
-						devc,
-						devc->dma8,
-						devc->dma8)) < 0)
+				name,driver, sizeof(struct audio_driver),
+				audio_flags, format_mask, devc,
+				devc->dma8, devc->dma8)) < 0)
 	{
 		  printk(KERN_ERR "sb: unable to install audio.\n");
 		  return;

FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen, slshen@lbl.gov