[PATCH] PA-RISC sound updates

PA-RISC sound updates:

 - Do a DAC/ADC reset for sampling rate changes in ad1889 (Randolph Chung)
 - Set the ad1889 interrupt configuration properly (Randolph Chung)
 - Fix dependency for the OSS Harmony driver (Thibaut Varene)
 - Forward port Stuart Brady's 2.4 Harmony driver patches (Thibaut Varene)
   - Fix sample skipping (Stuart Brady)
   - Prevent harmony_silence being called wrongly (Stuart Brady)
   - Fix crash caused by buf_to_fill becoming -1 (Stuart Brady)
   - Improve naming of mixer channels (Stuart Brady)
   - Implement SNDCTL_DSP_CHANNELS ioctl (Stuart Brady)
   - Improve toggling the recording source (Stuart Brady)
   - Sanity check MIXER_WRITE volume levels (Stuart Brady)
   - Fix MIXER_READ right_level return (Stuart Brady)
   - Reject AFMT_S16_LE format (Stuart Brady)
 - Fail OSS Harmony initialisation if no irq (Helge Deller)
 - Fix typos in ALSA Harmony (Andy Walker, Grant Grundler, Stuart Brady)

sound/oss/Kconfig

@@ -162,7 +162,10 @@ config SOUND_ICH
 
 config SOUND_HARMONY
 	tristate "PA Harmony audio driver"
-	depends on GSC_LASI && SOUND
+	depends on GSC_LASI && SOUND_PRIME!=n
+	help
+	  Say 'Y' or 'M' to include support for Harmony soundchip
+	  on HP 712, 715/new and many other GSC based machines.
 
 config SOUND_SONICVIBES
 	tristate "S3 SonicVibes"

sound/oss/ad1889.c

 /*
- *  Copyright 2001 Randolph Chung <tausq@debian.org>
+ *  Copyright 2001-2004 Randolph Chung <tausq@debian.org>
  *
  *  Analog Devices 1889 PCI audio driver (AD1819 AC97-compatible codec)
  *
@@ -61,6 +61,7 @@
 #define AD1889_WRITEL(dev,reg,val) writel((val), dev->regbase + reg)
 
 //now 100ms
+/* #define WAIT_10MS()	schedule_timeout(HZ/10) */
 #define WAIT_10MS()	do { int __i; for (__i = 0; __i < 100; __i++) udelay(1000); } while(0)
 
 /* currently only support a single device */
@@ -69,25 +70,43 @@ static ad1889_dev_t *ad1889_dev = NULL;
 /************************* helper routines ***************************** */
 static inline void ad1889_set_wav_rate(ad1889_dev_t *dev, int rate)
 {
+	struct ac97_codec *ac97_codec = dev->ac97_codec;
+
+	DBG("Setting WAV rate to %d\n", rate);
 	dev->state[AD_WAV_STATE].dmabuf.rate = rate;
 	AD1889_WRITEW(dev, AD_DSWAS, rate);
+
+	/* Cycle the DAC to enable the new rate */
+	ac97_codec->codec_write(dev->ac97_codec, AC97_POWER_CONTROL, 0x0200);
+	WAIT_10MS();
+	ac97_codec->codec_write(dev->ac97_codec, AC97_POWER_CONTROL, 0);
 }
 
 static inline void ad1889_set_adc_rate(ad1889_dev_t *dev, int rate)
 {
+	struct ac97_codec *ac97_codec = dev->ac97_codec;
+
+	DBG("Setting ADC rate to %d\n", rate);
 	dev->state[AD_ADC_STATE].dmabuf.rate = rate;
 	AD1889_WRITEW(dev, AD_DSRES, rate);
+
+	/* Cycle the ADC to enable the new rate */
+	ac97_codec->codec_write(dev->ac97_codec, AC97_POWER_CONTROL, 0x0100);
+	WAIT_10MS();
+	ac97_codec->codec_write(dev->ac97_codec, AC97_POWER_CONTROL, 0);
 }
 
 static inline void ad1889_set_wav_fmt(ad1889_dev_t *dev, int fmt)
 {
 	u16 tmp;
 
+	DBG("Setting WAV format to 0x%x\n", fmt);
+
 	tmp = AD1889_READW(ad1889_dev, AD_DSWSMC);
-	if (fmt == AFMT_S16_LE) {
+	if (fmt & AFMT_S16_LE) {
 		//tmp |= 0x0100; /* set WA16 */
 		tmp |= 0x0300; /* set WA16 stereo */
-	} else if (fmt == AFMT_U8) {
+	} else if (fmt & AFMT_U8) {
 		tmp &= ~0x0100; /* clear WA16 */
 	} 
 	AD1889_WRITEW(ad1889_dev, AD_DSWSMC, tmp);
@@ -97,10 +116,12 @@ static inline void ad1889_set_adc_fmt(ad1889_dev_t *dev, int fmt)
 {
 	u16 tmp;
 
+	DBG("Setting ADC format to 0x%x\n", fmt);
+
 	tmp = AD1889_READW(ad1889_dev, AD_DSRAMC);
-	if (fmt == AFMT_S16_LE) {
+	if (fmt & AFMT_S16_LE) {
 		tmp |= 0x0100; /* set WA16 */
-	} else if (fmt == AFMT_U8) {
+	} else if (fmt & AFMT_U8) {
 		tmp &= ~0x0100; /* clear WA16 */
 	} 
 	AD1889_WRITEW(ad1889_dev, AD_DSRAMC, tmp);
@@ -133,6 +154,9 @@ static void ad1889_start_wav(ad1889_state_t *state)
 	dmabuf->dma_len = cnt;
 	dmabuf->ready = 1;
 
+	DBG("Starting playback at 0x%p for %ld bytes\n", dmabuf->rawbuf +
+	    dmabuf->rd_ptr, dmabuf->dma_len);
+
         /* load up the current register set */
 	AD1889_WRITEL(ad1889_dev, AD_DMAWAVCC, cnt);
 	AD1889_WRITEL(ad1889_dev, AD_DMAWAVICC, cnt);
@@ -243,7 +267,7 @@ static ad1889_dev_t *ad1889_alloc_dev(struct pci_dev *pci)
 		dmabuf->dma_handle = 0;
 		dmabuf->rd_ptr = dmabuf->wr_ptr = dmabuf->dma_len = 0UL;
 		dmabuf->ready = 0;
-		dmabuf->rate = 44100;
+		dmabuf->rate = 48000;
 	}
 	return dev;
 
@@ -472,7 +496,6 @@ static ssize_t ad1889_write(struct file *file, const char __user *buffer, size_t
 		long cnt = count;
 		unsigned long flags;
 
-
 		for (;;) {
 			long used_bytes;
 			long timeout;	/* max time for DMA in jiffies */
@@ -498,17 +521,11 @@ static ssize_t ad1889_write(struct file *file, const char __user *buffer, size_t
 			}
 
 			set_current_state(TASK_INTERRUPTIBLE);
-			if (!schedule_timeout(timeout + 1))
-				printk(KERN_WARNING "AD1889 timeout(%ld) r/w %lx/%lx len %lx\n",
-				    timeout+1,
-				    dmabuf->rd_ptr, dmabuf->wr_ptr,
-				    dmabuf->dma_len);
-
+			schedule_timeout(timeout + 1);
 			if (signal_pending(current)) {
 				ret = -ERESTARTSYS;
 				goto err2;
 			}
-
 		}
 
 		/* watch out for wrapping around static buffer */
@@ -616,6 +633,8 @@ static int ad1889_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 	audio_buf_info abinfo;
 	int __user *p = (int __user *)arg;
 
+	DBG("ad1889_ioctl cmd 0x%x arg %lu\n", cmd, arg);
+
 	switch (cmd)
 	{
 	case OSS_GETVERSION:
@@ -674,11 +693,15 @@ static int ad1889_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 		if (get_user(val, p))
 			return -EFAULT;
 
-		if (file->f_mode & FMODE_READ) 
-			ad1889_set_adc_fmt(dev, val);
+		if (val == 0) {
+			if (file->f_mode & FMODE_READ) 
+				ad1889_set_adc_fmt(dev, val);
 
-		if (file->f_mode & FMODE_WRITE) 
-			ad1889_set_wav_fmt(dev, val);
+			if (file->f_mode & FMODE_WRITE) 
+				ad1889_set_wav_fmt(dev, val);
+		} else {
+			val = AFMT_S16_LE | AFMT_U8;
+		}
 
 		return put_user(val, p);
 
@@ -758,7 +781,7 @@ static int ad1889_open(struct inode *inode, struct file *file)
 	
 	file->private_data = ad1889_dev;
 
-	ad1889_set_wav_rate(ad1889_dev, 44100);
+	ad1889_set_wav_rate(ad1889_dev, 48000);
 	ad1889_set_wav_fmt(ad1889_dev, AFMT_S16_LE);
 	AD1889_WRITEW(ad1889_dev, AD_DSWADA, 0x0404); /* attenuation */
 	return nonseekable_open(inode, file);
@@ -938,7 +961,6 @@ static irqreturn_t ad1889_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 			ad1889_stop_wav(&dev->state[AD_WAV_STATE]);	/* clean up */
 			ad1889_start_wav(&dev->state[AD_WAV_STATE]);	/* start new */
 		}
-
 	}
 
 	if ((stat & 0x2) && dev->state[AD_ADC_STATE].dmabuf.ready) { /* ADCI */
@@ -952,18 +974,19 @@ static irqreturn_t ad1889_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 
 static void ad1889_initcfg(ad1889_dev_t *dev)
 {
-	u16 tmp;
+	u16 tmp16;
+	u32 tmp32;
 
 	/* make sure the interrupt bits are setup the way we want */
-	tmp = AD1889_READW(dev, AD_DMAWAVCTRL);
-	tmp &= ~0x00ff; /* flat dma, no sg, mask out the intr bits */
-	tmp |= 0x0004;  /* intr on count, loop */
-	AD1889_WRITEW(dev, AD_DMAWAVCTRL, tmp);
+	tmp32 = AD1889_READL(dev, AD_DMAWAVCTRL);
+	tmp32 &= ~0xff; /* flat dma, no sg, mask out the intr bits */
+	tmp32 |= 0x6;  /* intr on count, loop */
+	AD1889_WRITEL(dev, AD_DMAWAVCTRL, tmp32);
 
 	/* unmute... */
-	tmp = AD1889_READW(dev, AD_DSWADA);
-	tmp &= ~0x8080;
-	AD1889_WRITEW(dev, AD_DSWADA, tmp);
+	tmp16 = AD1889_READW(dev, AD_DSWADA);
+	tmp16 &= ~0x8080;
+	AD1889_WRITEW(dev, AD_DSWADA, tmp16);
 }
 
 static int __devinit ad1889_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)

sound/oss/ad1889.h

@@ -34,9 +34,9 @@
 #define AD_DMAWAVICC	0x98	/* WAV interrupt current count */
 #define AD_DMAWAVIBC	0x9c	/* WAV interrupt base count */
 #define AD_DMARESCTRL	0xa0	/* RES PCI control/status */
-#define AD_DMAADCCTRL	0xa8	/* RES PCI control/status */
-#define AD_DMASYNCTRL	0xb0	/* RES PCI control/status */
-#define AD_DMAWAVCTRL	0xb8	/* RES PCI control/status */
+#define AD_DMAADCCTRL	0xa8	/* ADC PCI control/status */
+#define AD_DMASYNCTRL	0xb0	/* SYN PCI control/status */
+#define AD_DMAWAVCTRL	0xb8	/* WAV PCI control/status */
 #define AD_DMADISR	0xc0	/* PCI DMA intr status */
 #define AD_DMACHSS	0xc4	/* PCI DMA channel stop status */
 

sound/oss/harmony.c

@@ -12,6 +12,7 @@
 	Copyright 2000-2003 (c) Helge Deller <deller@gmx.de>
 	Copyright 2001 (c) Matthieu Delahaye <delahaym@esiee.fr>
 	Copyright 2001 (c) Jean-Christophe Vaugeois <vaugeoij@esiee.fr>
+	Copyright 2004 (c) Stuart Brady <sdbrady@ntlworld.com>
 
 				
 TODO:
@@ -124,9 +125,17 @@
 #define GAIN_RO_MASK    ( 0x3f << GAIN_RO_SHIFT) 
 
 
-#define MAX_OUTPUT_LEVEL (GAIN_RO_MASK >> GAIN_RO_SHIFT)
-#define MAX_INPUT_LEVEL  (GAIN_RI_MASK >> GAIN_RI_SHIFT)
-#define MAX_VOLUME_LEVEL (GAIN_MA_MASK >> GAIN_MA_SHIFT)
+#define MAX_OUTPUT_LEVEL  (GAIN_RO_MASK >> GAIN_RO_SHIFT)
+#define MAX_INPUT_LEVEL   (GAIN_RI_MASK >> GAIN_RI_SHIFT)
+#define MAX_MONITOR_LEVEL (GAIN_MA_MASK >> GAIN_MA_SHIFT)
+
+#define MIXER_INTERNAL   SOUND_MIXER_LINE1
+#define MIXER_LINEOUT    SOUND_MIXER_LINE2
+#define MIXER_HEADPHONES SOUND_MIXER_LINE3
+
+#define MASK_INTERNAL   SOUND_MASK_LINE1
+#define MASK_LINEOUT    SOUND_MASK_LINE2
+#define MASK_HEADPHONES SOUND_MASK_LINE3
 
 /*
  * Channels Mask in mixer register
@@ -543,6 +552,7 @@ static ssize_t harmony_audio_write(struct file *file,
 	int count = 0;
 	int frame_size;
 	int buf_to_fill;
+	int fresh_buffer;
 
 	if (!harmony.format_initialized) {
 		if (harmony_format_auto_detect(buffer, total_count))
@@ -564,12 +574,16 @@ static ssize_t harmony_audio_write(struct file *file,
 		
 		
 		buf_to_fill = (harmony.first_filled_play+harmony.nb_filled_play); 
-		if (harmony.play_offset)
+		if (harmony.play_offset) {
 			buf_to_fill--;
+			buf_to_fill += MAX_BUFS;
+		}
 		buf_to_fill %= MAX_BUFS;
-
+		
+		fresh_buffer = (harmony.play_offset == 0);
+		
 		/* Figure out the size of the frame */
-		if ((total_count-count) > HARMONY_BUF_SIZE - harmony.play_offset) {
+		if ((total_count-count) >= HARMONY_BUF_SIZE - harmony.play_offset) {
 			frame_size = HARMONY_BUF_SIZE - harmony.play_offset;
 		} else {
 			frame_size = total_count - count;
@@ -587,7 +601,7 @@ static ssize_t harmony_audio_write(struct file *file,
 		CHECK_WBACK_INV_OFFSET(played_buf, (HARMONY_BUF_SIZE*buf_to_fill + harmony.play_offset), 
 				frame_size);
 	
-		if (!harmony.play_offset)
+		if (fresh_buffer)
 			harmony.nb_filled_play++;
 		
 		count += frame_size;
@@ -650,18 +664,17 @@ static int harmony_audio_ioctl(struct inode *inode,
 			switch (ival) {
 			case AFMT_MU_LAW:	new_format = HARMONY_DF_8BIT_ULAW; break;
 			case AFMT_A_LAW:	new_format = HARMONY_DF_8BIT_ALAW; break;
-			case AFMT_S16_LE:	/* fall through, but not really supported */
-			case AFMT_S16_BE:	new_format = HARMONY_DF_16BIT_LINEAR;
-						ival = AFMT_S16_BE;
-						break; 
+			case AFMT_S16_BE:	new_format = HARMONY_DF_16BIT_LINEAR; break;
 			default: {
 				DPRINTK(KERN_WARNING PFX 
 					"unsupported sound format 0x%04x requested.\n",
 					ival);
-				return -EINVAL;
+				ival = AFMT_S16_BE;
+				return put_user(ival, (int *) arg);
 			}
 			}
 			harmony_set_format(new_format);
+			return 0;
 		} else {
 			switch (harmony.data_format) {
 			case HARMONY_DF_8BIT_ULAW:	ival = AFMT_MU_LAW; break;
@@ -669,8 +682,8 @@ static int harmony_audio_ioctl(struct inode *inode,
 			case HARMONY_DF_16BIT_LINEAR:	ival = AFMT_U16_BE; break;
 			default: ival = 0;
 			}
+			return put_user(ival, (int *) arg);
 		}
-		return put_user(ival, (int *) arg);
 
 	case SOUND_PCM_READ_RATE:
 		ival = harmony.dac_rate;
@@ -689,7 +702,17 @@ static int harmony_audio_ioctl(struct inode *inode,
 		if (ival != 0 && ival != 1)
 			return -EINVAL;
 		harmony_set_stereo(ival);
-		return put_user(ival, (int *) arg);
+ 		return 0;
+ 
+ 	case SNDCTL_DSP_CHANNELS:
+ 		if (get_user(ival, (int *) arg))
+ 			return -EFAULT;
+ 		if (ival != 1 && ival != 2) {
+ 			ival = harmony.stereo_select == HARMONY_SS_MONO ? 1 : 2;
+ 			return put_user(ival, (int *) arg);
+ 		}
+ 		harmony_set_stereo(ival-1);
+ 		return 0;
 
 	case SNDCTL_DSP_GETBLKSIZE:
 		ival = HARMONY_BUF_SIZE;
@@ -887,7 +910,7 @@ static int harmony_mixer_get_level(int channel)
 	int right_level;
 
 	switch (channel) {
-		case SOUND_MIXER_OGAIN:
+		case SOUND_MIXER_VOLUME:
 			left_level  = (harmony.current_gain & GAIN_LO_MASK) >> GAIN_LO_SHIFT;
 			right_level = (harmony.current_gain & GAIN_RO_MASK) >> GAIN_RO_SHIFT;
 			left_level  = to_oss_level(MAX_OUTPUT_LEVEL - left_level, MAX_OUTPUT_LEVEL);
@@ -901,10 +924,10 @@ static int harmony_mixer_get_level(int channel)
 			right_level= to_oss_level(right_level, MAX_INPUT_LEVEL);
 			return (right_level << 8)+left_level;
 			
-		case SOUND_MIXER_VOLUME:
+		case SOUND_MIXER_MONITOR:
 			left_level = (harmony.current_gain & GAIN_MA_MASK) >> GAIN_MA_SHIFT;
-			left_level = to_oss_level(MAX_VOLUME_LEVEL-left_level, MAX_VOLUME_LEVEL);
-			return left_level;
+			left_level = to_oss_level(MAX_MONITOR_LEVEL-left_level, MAX_MONITOR_LEVEL);
+			return (left_level << 8)+left_level;
 	}
 	return -EINVAL;
 }
@@ -926,9 +949,11 @@ static int harmony_mixer_set_level(int channel, int value)
 
 	right_level = (value & 0x0000ff00) >> 8;
 	left_level = value & 0x000000ff;
+	if (right_level > 100) right_level = 100;
+	if (left_level > 100) left_level = 100;
   
 	switch (channel) {
-		case SOUND_MIXER_OGAIN:
+		case SOUND_MIXER_VOLUME:
 			right_level = to_harmony_level(100-right_level, MAX_OUTPUT_LEVEL);
 			left_level  = to_harmony_level(100-left_level, MAX_OUTPUT_LEVEL);
 			new_right_level = to_oss_level(MAX_OUTPUT_LEVEL - right_level, MAX_OUTPUT_LEVEL);
@@ -948,12 +973,12 @@ static int harmony_mixer_set_level(int channel, int value)
 			harmony_mixer_set_gain();
 			return (new_right_level << 8) + new_left_level;
 	
-		case SOUND_MIXER_VOLUME:
-			left_level = to_harmony_level(100-left_level, MAX_VOLUME_LEVEL);
-			new_left_level = to_oss_level(MAX_VOLUME_LEVEL-left_level, MAX_VOLUME_LEVEL);
-			harmony.current_gain = (harmony.current_gain & ~GAIN_MA_MASK)| (left_level << GAIN_MA_SHIFT);
+		case SOUND_MIXER_MONITOR:
+			left_level = to_harmony_level(100-left_level, MAX_MONITOR_LEVEL);
+			new_left_level = to_oss_level(MAX_MONITOR_LEVEL-left_level, MAX_MONITOR_LEVEL);
+			harmony.current_gain = (harmony.current_gain & ~GAIN_MA_MASK) | (left_level << GAIN_MA_SHIFT);
 			harmony_mixer_set_gain();
-			return new_left_level;
+			return (new_left_level << 8) + new_left_level;
 	}
 
 	return -EINVAL;
@@ -986,11 +1011,15 @@ static int harmony_mixer_set_recmask(int recmask)
 {
 	int new_input_line;
 	int new_input_mask;
-
-	if ((recmask & SOUND_MASK_LINE)) {
+	int current_input_line;
+	
+	current_input_line = (harmony.current_gain & GAIN_IS_MASK)
+				    >> GAIN_IS_SHIFT;
+	if ((current_input_line && ((recmask & SOUND_MASK_LINE) || !(recmask & SOUND_MASK_MIC))) ||
+		(!current_input_line && ((recmask & SOUND_MASK_LINE) && !(recmask & SOUND_MASK_MIC)))) {
 		new_input_line = 0;
 		new_input_mask = SOUND_MASK_LINE;
-	} else  {
+	} else {
 		new_input_line = 1;
 		new_input_mask = SOUND_MASK_MIC;
 	}
@@ -1009,9 +1038,9 @@ static int harmony_mixer_get_outmask(void)
 {
 	int outmask = 0;
 	
-	if (harmony.current_gain & GAIN_HE_MASK) outmask |=SOUND_MASK_PHONEOUT;
-	if (harmony.current_gain & GAIN_LE_MASK) outmask |=SOUND_MASK_LINE;
-	if (harmony.current_gain & GAIN_SE_MASK) outmask |=SOUND_MASK_SPEAKER;
+	if (harmony.current_gain & GAIN_SE_MASK) outmask |= MASK_INTERNAL;
+	if (harmony.current_gain & GAIN_LE_MASK) outmask |= MASK_LINEOUT;
+	if (harmony.current_gain & GAIN_HE_MASK) outmask |= MASK_HEADPHONES;
 	
 	return outmask;
 }
@@ -1019,24 +1048,24 @@ static int harmony_mixer_get_outmask(void)
 
 static int harmony_mixer_set_outmask(int outmask)
 {
-	if (outmask & SOUND_MASK_PHONEOUT) 
-		harmony.current_gain |= GAIN_HE_MASK; 
+	if (outmask & MASK_INTERNAL) 
+		harmony.current_gain |= GAIN_SE_MASK;
 	else 
-		harmony.current_gain &= ~GAIN_HE_MASK;
+		harmony.current_gain &= ~GAIN_SE_MASK;
 	
-	if (outmask & SOUND_MASK_LINE) 
+	if (outmask & MASK_LINEOUT) 
 		harmony.current_gain |= GAIN_LE_MASK;
 	else 
 		harmony.current_gain &= ~GAIN_LE_MASK;
 	
-	if (outmask & SOUND_MASK_SPEAKER) 
-		harmony.current_gain |= GAIN_SE_MASK;
+	if (outmask & MASK_HEADPHONES) 
+		harmony.current_gain |= GAIN_HE_MASK; 
 	else 
-		harmony.current_gain &= ~GAIN_SE_MASK;
+		harmony.current_gain &= ~GAIN_HE_MASK;
 	
 	harmony_mixer_set_gain();
 
-	return (outmask & (SOUND_MASK_PHONEOUT | SOUND_MASK_LINE | SOUND_MASK_SPEAKER));
+	return (outmask & (MASK_INTERNAL | MASK_LINEOUT | MASK_HEADPHONES));
 }
 
 /*
@@ -1074,19 +1103,19 @@ static int harmony_mixer_ioctl(struct inode * inode, struct file * file,
 		ret = SOUND_CAP_EXCL_INPUT;
 		break;
 	case MIXER_READ(SOUND_MIXER_STEREODEVS):
-		ret = SOUND_MASK_IGAIN | SOUND_MASK_OGAIN;
+		ret = SOUND_MASK_VOLUME | SOUND_MASK_IGAIN;
 		break;
 		
 	case MIXER_READ(SOUND_MIXER_RECMASK):
 		ret = SOUND_MASK_MIC | SOUND_MASK_LINE;
 		break;
 	case MIXER_READ(SOUND_MIXER_DEVMASK):
-		ret = SOUND_MASK_OGAIN | SOUND_MASK_IGAIN |
-			SOUND_MASK_VOLUME;
+		ret = SOUND_MASK_VOLUME | SOUND_MASK_IGAIN |
+			SOUND_MASK_MONITOR;
 		break;
 	case MIXER_READ(SOUND_MIXER_OUTMASK):
-		ret = SOUND_MASK_SPEAKER | SOUND_MASK_LINE |
-			SOUND_MASK_PHONEOUT;
+		ret = MASK_INTERNAL | MASK_LINEOUT |
+			MASK_HEADPHONES;
 		break;
 		
 	case MIXER_WRITE(SOUND_MIXER_RECSRC):
@@ -1103,15 +1132,15 @@ static int harmony_mixer_ioctl(struct inode * inode, struct file * file,
 		ret = harmony_mixer_get_outmask();
 		break;
 	
-	case MIXER_WRITE(SOUND_MIXER_OGAIN):
-	case MIXER_WRITE(SOUND_MIXER_IGAIN):
 	case MIXER_WRITE(SOUND_MIXER_VOLUME):
+	case MIXER_WRITE(SOUND_MIXER_IGAIN):
+	case MIXER_WRITE(SOUND_MIXER_MONITOR):
 		ret = harmony_mixer_set_level(cmd & 0xff, val);
 		break;
 
-	case MIXER_READ(SOUND_MIXER_OGAIN):
-	case MIXER_READ(SOUND_MIXER_IGAIN):
 	case MIXER_READ(SOUND_MIXER_VOLUME):
+	case MIXER_READ(SOUND_MIXER_IGAIN):
+	case MIXER_READ(SOUND_MIXER_MONITOR):
 		ret = harmony_mixer_get_level(cmd & 0xff);
 		break;
 
@@ -1201,16 +1230,15 @@ harmony_driver_probe(struct parisc_device *dev)
 		return -EBUSY;
 	}
 
-	harmony.dev = dev;
-
-	/* Set the HPA of harmony */
-	harmony.hpa = (struct harmony_hpa *)dev->hpa;
-
-	if (!harmony.dev->irq) {
+	if (!dev->irq) {
 		printk(KERN_ERR PFX "no irq found\n");
 		return -ENODEV;
 	}
 
+	/* Set the HPA of harmony */
+	harmony.hpa = (struct harmony_hpa *)dev->hpa;
+	harmony.dev = dev;
+
 	/* Grab the ID and revision from the device */
 	id = gsc_readb(&harmony.hpa->id);
 	if ((id | 1) != 0x15) {

sound/parisc/harmony.c

@@ -6,7 +6,7 @@
  *
  *	Harmony is found in HP 712s, 715/new and many other GSC based machines.
  *	On older 715 machines you'll find the technically identical chip 
- *	called 'Vivace'. Both Harmony and Vicace are supported by this driver.
+ *	called 'Vivace'. Both Harmony and Vivace are supported by this driver.
  *
  *  this ALSA driver is based on OSS driver by:
  *	Copyright 2000 (c) Linuxcare Canada, Alex deVries <alex@linuxcare.com>
@@ -43,7 +43,7 @@
  * to be recorded is put in RNXTADD. There is 2 read-only registers, PCURADD and 
  * RCURADD that provides adress of current page.
  * 
- * Harmony has no way to controll full duplex or half duplex mode. It means
+ * Harmony has no way to control full duplex or half duplex mode. It means
  * that we always need to provide adresses of playback and capture data, even
  * when this is not needed. That's why we statically alloc one graveyard
  * buffer (to put recorded data in play-only mode) and a silence buffer.
@@ -556,7 +556,7 @@ static int snd_card_harmony_playback_prepare(snd_pcm_substream_t * substream)
 	harmony->sample_rate = snd_card_harmony_rate_bits(runtime->rate);
 
 	/* data format */
-	harmony->data_format = snd_harmony_set_data_format(haromny, runtime->format);
+	harmony->data_format = snd_harmony_set_data_format(harmony, runtime->format);
 
 	/* number of channels */
 	if (runtime->channels == 2)
@@ -587,7 +587,7 @@ static int snd_card_harmony_capture_prepare(snd_pcm_substream_t * substream)
 	harmony->sample_rate = snd_card_harmony_rate_bits(runtime->rate);
 	
 	/* data format */
-	harmony->data_format = snd_harmony_set_data_format(haromny, runtime->format);
+	harmony->data_format = snd_harmony_set_data_format(harmony, runtime->format);
 	
 	/* number of channels */
 	if (runtime->channels == 1)