]> git.karo-electronics.de Git - mv-sheeva.git/blobdiff - sound/isa/ad1848/ad1848_lib.c
projects / mv-sheeva.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
ALSA: wss_lib: use CS4231P instead of AD1848P (kill the AD1848P)
[mv-sheeva.git] / sound / isa / ad1848 / ad1848_lib.c
diff --git a/sound/isa/ad1848/ad1848_lib.c b/sound/isa/ad1848/ad1848_lib.c
index 4f7aaf4e098933bdec71d81507ec618d1514b960..07756fa369472b5405df32d783a0fcb4c409f498 100644 (file)
--- 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);
 
Linux for Marvell Sheeva based platforms