ALSA: wss_lib: use CS4231P instead of AD1848P (kill the AD1848P)

Use CS4231P instead of AD1848P (kill the AD1848P).

Signed-off-by: Krzysztof Helt <krzysztof.h1@wp.pl>
Reviewed-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Jaroslav Kysela <perex@perex.cz>

1 files changed, 55 insertions, 49 deletions

diff --git a/sound/isa/ad1848/ad1848_lib.c b/sound/isa/ad1848/ad1848_lib.c
index 4f7aaf4..07756fa 100644
--- a/sound/isa/ad1848/ad1848_lib.c
+++ b/sound/isa/ad1848/ad1848_lib.c
@@ -103,7 +103,7 @@ static void snd_ad1848_wait(struct snd_wss *chip)
 	int timeout;
 
 	for (timeout = 250; timeout > 0; timeout--) {
-		if ((inb(AD1848P(chip, REGSEL)) & AD1848_INIT) == 0)
+		if ((inb(chip->port + CS4231P(REGSEL)) & AD1848_INIT) == 0)
 			break;
 		udelay(100);
 	}
@@ -115,12 +115,12 @@ void snd_ad1848_out(struct snd_wss *chip,
 {
 	snd_ad1848_wait(chip);
 #ifdef CONFIG_SND_DEBUG
-	if (inb(AD1848P(chip, REGSEL)) & AD1848_INIT)
+	if (inb(chip->port + CS4231P(REGSEL)) & AD1848_INIT)
 		snd_printk(KERN_WARNING "auto calibration time out - "
 			   "reg = 0x%x, value = 0x%x\n", reg, value);
 #endif
-	outb(chip->mce_bit | reg, AD1848P(chip, REGSEL));
-	outb(chip->image[reg] = value, AD1848P(chip, REG));
+	outb(chip->mce_bit | reg, chip->port + CS4231P(REGSEL));
+	outb(chip->image[reg] = value, chip->port + CS4231P(REG));
 	mb();
 	snd_printdd("codec out - reg 0x%x = 0x%x\n",
 			chip->mce_bit | reg, value);
@@ -132,8 +132,8 @@ static void snd_ad1848_dout(struct snd_wss *chip,
 			    unsigned char reg, unsigned char value)
 {
 	snd_ad1848_wait(chip);
-	outb(chip->mce_bit | reg, AD1848P(chip, REGSEL));
-	outb(value, AD1848P(chip, REG));
+	outb(chip->mce_bit | reg, chip->port + CS4231P(REGSEL));
+	outb(value, chip->port + CS4231P(REG));
 	mb();
 }
 
@@ -141,37 +141,37 @@ static unsigned char snd_ad1848_in(struct snd_wss *chip, unsigned char reg)
 {
 	snd_ad1848_wait(chip);
 #ifdef CONFIG_SND_DEBUG
-	if (inb(AD1848P(chip, REGSEL)) & AD1848_INIT)
+	if (inb(chip->port + CS4231P(REGSEL)) & AD1848_INIT)
 		snd_printk(KERN_WARNING "auto calibration time out - "
 			   "reg = 0x%x\n", reg);
 #endif
-	outb(chip->mce_bit | reg, AD1848P(chip, REGSEL));
+	outb(chip->mce_bit | reg, chip->port + CS4231P(REGSEL));
 	mb();
-	return inb(AD1848P(chip, REG));
+	return inb(chip->port + CS4231P(REG));
 }
 
 #if 0
 
 static void snd_ad1848_debug(struct snd_wss *chip)
 {
-	printk("AD1848 REGS:      INDEX = 0x%02x  ", inb(AD1848P(chip, REGSEL)));
-	printk("                 STATUS = 0x%02x\n", inb(AD1848P(chip, STATUS)));
-	printk("  0x00: left input      = 0x%02x  ", snd_ad1848_in(chip, 0x00));
-	printk("  0x08: playback format = 0x%02x\n", snd_ad1848_in(chip, 0x08));
-	printk("  0x01: right input     = 0x%02x  ", snd_ad1848_in(chip, 0x01));
-	printk("  0x09: iface (CFIG 1)  = 0x%02x\n", snd_ad1848_in(chip, 0x09));
-	printk("  0x02: AUXA left       = 0x%02x  ", snd_ad1848_in(chip, 0x02));
-	printk("  0x0a: pin control     = 0x%02x\n", snd_ad1848_in(chip, 0x0a));
-	printk("  0x03: AUXA right      = 0x%02x  ", snd_ad1848_in(chip, 0x03));
-	printk("  0x0b: init & status   = 0x%02x\n", snd_ad1848_in(chip, 0x0b));
-	printk("  0x04: AUXB left       = 0x%02x  ", snd_ad1848_in(chip, 0x04));
-	printk("  0x0c: revision & mode = 0x%02x\n", snd_ad1848_in(chip, 0x0c));
-	printk("  0x05: AUXB right      = 0x%02x  ", snd_ad1848_in(chip, 0x05));
-	printk("  0x0d: loopback        = 0x%02x\n", snd_ad1848_in(chip, 0x0d));
-	printk("  0x06: left output     = 0x%02x  ", snd_ad1848_in(chip, 0x06));
-	printk("  0x0e: data upr count  = 0x%02x\n", snd_ad1848_in(chip, 0x0e));
-	printk("  0x07: right output    = 0x%02x  ", snd_ad1848_in(chip, 0x07));
-	printk("  0x0f: data lwr count  = 0x%02x\n", snd_ad1848_in(chip, 0x0f));
+	printk(KERN_DEBUG "AD1848 REGS:      INDEX = 0x%02x  ", inb(chip->port + CS4231P(REGSEL)));
+	printk(KERN_DEBUG "                 STATUS = 0x%02x\n", inb(chip->port + CS4231P(STATUS)));
+	printk(KERN_DEBUG "  0x00: left input      = 0x%02x  ", snd_ad1848_in(chip, 0x00));
+	printk(KERN_DEBUG "  0x08: playback format = 0x%02x\n", snd_ad1848_in(chip, 0x08));
+	printk(KERN_DEBUG "  0x01: right input     = 0x%02x  ", snd_ad1848_in(chip, 0x01));
+	printk(KERN_DEBUG "  0x09: iface (CFIG 1)  = 0x%02x\n", snd_ad1848_in(chip, 0x09));
+	printk(KERN_DEBUG "  0x02: AUXA left       = 0x%02x  ", snd_ad1848_in(chip, 0x02));
+	printk(KERN_DEBUG "  0x0a: pin control     = 0x%02x\n", snd_ad1848_in(chip, 0x0a));
+	printk(KERN_DEBUG "  0x03: AUXA right      = 0x%02x  ", snd_ad1848_in(chip, 0x03));
+	printk(KERN_DEBUG "  0x0b: init & status   = 0x%02x\n", snd_ad1848_in(chip, 0x0b));
+	printk(KERN_DEBUG "  0x04: AUXB left       = 0x%02x  ", snd_ad1848_in(chip, 0x04));
+	printk(KERN_DEBUG "  0x0c: revision & mode = 0x%02x\n", snd_ad1848_in(chip, 0x0c));
+	printk(KERN_DEBUG "  0x05: AUXB right      = 0x%02x  ", snd_ad1848_in(chip, 0x05));
+	printk(KERN_DEBUG "  0x0d: loopback        = 0x%02x\n", snd_ad1848_in(chip, 0x0d));
+	printk(KERN_DEBUG "  0x06: left output     = 0x%02x  ", snd_ad1848_in(chip, 0x06));
+	printk(KERN_DEBUG "  0x0e: data upr count  = 0x%02x\n", snd_ad1848_in(chip, 0x0e));
+	printk(KERN_DEBUG "  0x07: right output    = 0x%02x  ", snd_ad1848_in(chip, 0x07));
+	printk(KERN_DEBUG "  0x0f: data lwr count  = 0x%02x\n", snd_ad1848_in(chip, 0x0f));
 }
 
 #endif
@@ -187,16 +187,17 @@ static void snd_ad1848_mce_up(struct snd_wss *chip)
 
 	snd_ad1848_wait(chip);
 #ifdef CONFIG_SND_DEBUG
-	if (inb(AD1848P(chip, REGSEL)) & AD1848_INIT)
+	if (inb(chip->port + CS4231P(REGSEL)) & AD1848_INIT)
 		snd_printk(KERN_WARNING "mce_up - auto calibration time out (0)\n");
 #endif
 	spin_lock_irqsave(&chip->reg_lock, flags);
 	chip->mce_bit |= AD1848_MCE;
-	timeout = inb(AD1848P(chip, REGSEL));
+	timeout = inb(chip->port + CS4231P(REGSEL));
 	if (timeout == 0x80)
 		snd_printk(KERN_WARNING "mce_up [0x%lx]: serious init problem - codec still busy\n", chip->port);
 	if (!(timeout & AD1848_MCE))
-		outb(chip->mce_bit | (timeout & 0x1f), AD1848P(chip, REGSEL));
+		outb(chip->mce_bit | (timeout & 0x1f),
+		     chip->port + CS4231P(REGSEL));
 	spin_unlock_irqrestore(&chip->reg_lock, flags);
 }
 
@@ -207,21 +208,25 @@ static void snd_ad1848_mce_down(struct snd_wss *chip)
 
 	spin_lock_irqsave(&chip->reg_lock, flags);
 	for (timeout = 5; timeout > 0; timeout--)
-		inb(AD1848P(chip, REGSEL));
+		inb(chip->port + CS4231P(REGSEL));
 	/* end of cleanup sequence */
-	for (timeout = 12000; timeout > 0 && (inb(AD1848P(chip, REGSEL)) & AD1848_INIT); timeout--)
+	for (timeout = 12000;
+	     timeout > 0 && (inb(chip->port + CS4231P(REGSEL)) & AD1848_INIT);
+	     timeout--)
 		udelay(100);
 
 	snd_printdd("(1) timeout = %ld\n", timeout);
 
 #ifdef CONFIG_SND_DEBUG
-	if (inb(AD1848P(chip, REGSEL)) & AD1848_INIT)
-		snd_printk(KERN_WARNING "mce_down [0x%lx] - auto calibration time out (0)\n", AD1848P(chip, REGSEL));
+	if (inb(chip->port + CS4231P(REGSEL)) & AD1848_INIT)
+		snd_printk(KERN_WARNING
+			   "mce_down [0x%lx] - auto calibration time out (0)\n",
+			   chip->port + CS4231P(REGSEL));
 #endif
 
 	chip->mce_bit &= ~AD1848_MCE;
-	reg = inb(AD1848P(chip, REGSEL));
-	outb(chip->mce_bit | (reg & 0x1f), AD1848P(chip, REGSEL));
+	reg = inb(chip->port + CS4231P(REGSEL));
+	outb(chip->mce_bit | (reg & 0x1f), chip->port + CS4231P(REGSEL));
 	if (reg == 0x80)
 		snd_printk(KERN_WARNING "mce_down [0x%lx]: serious init problem - codec still busy\n", chip->port);
 	if ((reg & AD1848_MCE) == 0) {
@@ -252,7 +257,8 @@ static void snd_ad1848_mce_down(struct snd_wss *chip)
 			   "mce_down - auto calibration time out (2)\n");
 
 	snd_printdd("(4) jiffies = %lu\n", jiffies);
-	snd_printd("mce_down - exit = 0x%x\n", inb(AD1848P(chip, REGSEL)));
+	snd_printd("mce_down - exit = 0x%x\n",
+		   inb(chip->port + CS4231P(REGSEL)));
 }
 
 static unsigned int snd_ad1848_get_count(unsigned char format,
@@ -412,8 +418,8 @@ static int snd_ad1848_open(struct snd_wss *chip, unsigned int mode)
 
 	/* ok. now enable and ack CODEC IRQ */
 	spin_lock_irqsave(&chip->reg_lock, flags);
-	outb(0, AD1848P(chip, STATUS));	/* clear IRQ */
-	outb(0, AD1848P(chip, STATUS));	/* clear IRQ */
+	outb(0, chip->port + CS4231P(STATUS));	/* clear IRQ */
+	outb(0, chip->port + CS4231P(STATUS));	/* clear IRQ */
 	chip->image[AD1848_PIN_CTRL] |= AD1848_IRQ_ENABLE;
 	snd_ad1848_out(chip, AD1848_PIN_CTRL, chip->image[AD1848_PIN_CTRL]);
 	spin_unlock_irqrestore(&chip->reg_lock, flags);
@@ -431,8 +437,8 @@ static void snd_ad1848_close(struct snd_wss *chip)
 		return;
 	/* disable IRQ */
 	spin_lock_irqsave(&chip->reg_lock, flags);
-	outb(0, AD1848P(chip, STATUS));	/* clear IRQ */
-	outb(0, AD1848P(chip, STATUS));	/* clear IRQ */
+	outb(0, chip->port + CS4231P(STATUS));	/* clear IRQ */
+	outb(0, chip->port + CS4231P(STATUS));	/* clear IRQ */
 	chip->image[AD1848_PIN_CTRL] &= ~AD1848_IRQ_ENABLE;
 	snd_ad1848_out(chip, AD1848_PIN_CTRL, chip->image[AD1848_PIN_CTRL]);
 	spin_unlock_irqrestore(&chip->reg_lock, flags);
@@ -449,8 +455,8 @@ static void snd_ad1848_close(struct snd_wss *chip)
 
 	/* clear IRQ again */
 	spin_lock_irqsave(&chip->reg_lock, flags);
-	outb(0, AD1848P(chip, STATUS));	/* clear IRQ */
-	outb(0, AD1848P(chip, STATUS));	/* clear IRQ */
+	outb(0, chip->port + CS4231P(STATUS));	/* clear IRQ */
+	outb(0, chip->port + CS4231P(STATUS));	/* clear IRQ */
 	spin_unlock_irqrestore(&chip->reg_lock, flags);
 
 	chip->mode = 0;
@@ -572,7 +578,7 @@ static irqreturn_t snd_ad1848_interrupt(int irq, void *dev_id)
 		snd_pcm_period_elapsed(chip->playback_substream);
 	if ((chip->mode & WSS_MODE_RECORD) && chip->capture_substream)
 		snd_pcm_period_elapsed(chip->capture_substream);
-	outb(0, AD1848P(chip, STATUS));	/* clear global interrupt bit */
+	outb(0, chip->port + CS4231P(STATUS));	/* clear global interrupt bit */
 	return IRQ_HANDLED;
 }
 
@@ -638,8 +644,8 @@ static void snd_ad1848_resume(struct snd_wss *chip)
 		snd_ad1848_thinkpad_twiddle(chip, 1);
 
 	/* clear any pendings IRQ */
-	inb(AD1848P(chip, STATUS));
-	outb(0, AD1848P(chip, STATUS));
+	inb(chip->port + CS4231P(STATUS));
+	outb(0, chip->port + CS4231P(STATUS));
 	mb();
 
 	snd_ad1848_mce_down(chip);
@@ -662,7 +668,7 @@ static int snd_ad1848_probe(struct snd_wss *chip)
 	id = ad1847 = 0;
 	for (i = 0; i < 1000; i++) {
 		mb();
-		if (inb(AD1848P(chip, REGSEL)) & AD1848_INIT)
+		if (inb(chip->port + CS4231P(REGSEL)) & AD1848_INIT)
 			udelay(500);
 		else {
 			spin_lock_irqsave(&chip->reg_lock, flags);
@@ -707,8 +713,8 @@ static int snd_ad1848_probe(struct snd_wss *chip)
 		}
 	}
 	spin_lock_irqsave(&chip->reg_lock, flags);
-	inb(AD1848P(chip, STATUS));	/* clear any pendings IRQ */
-	outb(0, AD1848P(chip, STATUS));
+	inb(chip->port + CS4231P(STATUS));	/* clear any pendings IRQ */
+	outb(0, chip->port + CS4231P(STATUS));
 	mb();
 	spin_unlock_irqrestore(&chip->reg_lock, flags);