Logo Search packages:      
Sourcecode: linux version File versions  Download package

waveartist.c

/*
 * linux/sound/oss/waveartist.c
 *
 * The low level driver for the RWA010 Rockwell Wave Artist
 * codec chip used in the Rebel.com NetWinder.
 *
 * Cleaned up and integrated into 2.1 by Russell King (rmk@arm.linux.org.uk)
 * and Pat Beirne (patb@corel.ca)
 *
 *
 * Copyright (C) by Rebel.com 1998-1999
 *
 * RWA010 specs received under NDA from Rockwell
 *
 * 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:
 * 11-10-2000     Bartlomiej Zolnierkiewicz <bkz@linux-ide.org>
 *          Added __init to waveartist_init()
 */

/* Debugging */
#define DEBUG_CMD 1
#define DEBUG_OUT 2
#define DEBUG_IN  4
#define DEBUG_INTR      8
#define DEBUG_MIXER     16
#define DEBUG_TRIGGER   32

#define debug_flg (0)

#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/spinlock.h>
#include <linux/bitops.h>

#include <asm/system.h>

#include "sound_config.h"
#include "waveartist.h"

#ifdef CONFIG_ARM
#include <asm/hardware.h>
#include <asm/mach-types.h>
#endif

#ifndef NO_DMA
#define NO_DMA    255
#endif

#define SUPPORTED_MIXER_DEVICES           (SOUND_MASK_SYNTH      |\
                               SOUND_MASK_PCM        |\
                               SOUND_MASK_LINE       |\
                               SOUND_MASK_MIC        |\
                               SOUND_MASK_LINE1      |\
                               SOUND_MASK_RECLEV     |\
                               SOUND_MASK_VOLUME     |\
                               SOUND_MASK_IMIX)

static unsigned short levels[SOUND_MIXER_NRDEVICES] = {
      0x5555,           /* Master Volume   */
      0x0000,           /* Bass                  */
      0x0000,           /* Treble          */
      0x2323,           /* Synth (FM)            */
      0x4b4b,           /* PCM                   */
      0x6464,           /* PC Speaker            */
      0x0000,           /* Ext Line        */
      0x0000,           /* Mic                   */
      0x0000,           /* CD              */
      0x6464,           /* Recording monitor     */
      0x0000,           /* SB PCM (ALT PCM)      */
      0x0000,           /* Recording level       */
      0x6464,           /* Input gain            */
      0x6464,           /* Output gain           */
      0x0000,           /* Line1 (Aux1)          */
      0x0000,           /* Line2 (Aux2)          */
      0x0000,           /* Line3 (Aux3)          */
      0x0000,           /* Digital1        */
      0x0000,           /* Digital2        */
      0x0000,           /* Digital3        */
      0x0000,           /* Phone In        */
      0x6464,           /* Phone Out             */
      0x0000,           /* Video           */
      0x0000,           /* Radio           */
      0x0000            /* Monitor         */
};

typedef struct {
      struct address_info  hw;      /* hardware */
      char        *chip_name;

      int         xfer_count;
      int         audio_mode;
      int         open_mode;
      int         audio_flags;
      int         record_dev;
      int         playback_dev;
      int         dev_no;

      /* Mixer parameters */
      const struct waveartist_mixer_info *mix;

      unsigned short    *levels;       /* cache of volume settings   */
      int         recmask;       /* currently enabled recording device! */

#ifdef CONFIG_ARCH_NETWINDER
      signed int  slider_vol;    /* hardware slider volume     */
      unsigned int      handset_detect    :1;
      unsigned int      telephone_detect:1;
      unsigned int      no_autoselect     :1;/* handset/telephone autoselects a path */
      unsigned int      spkr_mute_state   :1;/* set by ioctl or autoselect */
      unsigned int      line_mute_state   :1;/* set by ioctl or autoselect */
      unsigned int      use_slider  :1;/* use slider setting for o/p vol */
#endif
} wavnc_info;

/*
 * This is the implementation specific mixer information.
 */
struct waveartist_mixer_info {
      unsigned int      supported_devs;      /* Supported devices */
      unsigned int      recording_devs;      /* Recordable devies */
      unsigned int      stereo_devs;         /* Stereo devices    */

      unsigned int      (*select_input)(wavnc_info *, unsigned int,
                              unsigned char *, unsigned char *);
      int         (*decode_mixer)(wavnc_info *, int,
                              unsigned char, unsigned char);
      int         (*get_mixer)(wavnc_info *, int);
};

typedef struct wavnc_port_info {
      int         open_mode;
      int         speed;
      int         channels;
      int         audio_format;
} wavnc_port_info;

static int        nr_waveartist_devs;
static wavnc_info adev_info[MAX_AUDIO_DEV];
static DEFINE_SPINLOCK(waveartist_lock);

#ifndef CONFIG_ARCH_NETWINDER
#define machine_is_netwinder() 0
#else
static struct timer_list vnc_timer;
static void vnc_configure_mixer(wavnc_info *devc, unsigned int input_mask);
static int vnc_private_ioctl(int dev, unsigned int cmd, int __user *arg);
static void vnc_slider_tick(unsigned long data);
#endif

static inline void
waveartist_set_ctlr(struct address_info *hw, unsigned char clear, unsigned char set)
{
      unsigned int ctlr_port = hw->io_base + CTLR;

      clear = ~clear & inb(ctlr_port);

      outb(clear | set, ctlr_port);
}

/* Toggle IRQ acknowledge line
 */
static inline void
waveartist_iack(wavnc_info *devc)
{
      unsigned int ctlr_port = devc->hw.io_base + CTLR;
      int old_ctlr;

      old_ctlr = inb(ctlr_port) & ~IRQ_ACK;

      outb(old_ctlr | IRQ_ACK, ctlr_port);
      outb(old_ctlr, ctlr_port);
}

static inline int
waveartist_sleep(int timeout_ms)
{
      unsigned int timeout = timeout_ms * 10 * HZ / 100;

      do {
            set_current_state(TASK_INTERRUPTIBLE);
            timeout = schedule_timeout(timeout);
      } while (timeout);

      return 0;
}

static int
waveartist_reset(wavnc_info *devc)
{
      struct address_info *hw = &devc->hw;
      unsigned int timeout, res = -1;

      waveartist_set_ctlr(hw, -1, RESET);
      waveartist_sleep(2);
      waveartist_set_ctlr(hw, RESET, 0);

      timeout = 500;
      do {
            mdelay(2);

            if (inb(hw->io_base + STATR) & CMD_RF) {
                  res = inw(hw->io_base + CMDR);
                  if (res == 0x55aa)
                        break;
            }
      } while (--timeout);

      if (timeout == 0) {
            printk(KERN_WARNING "WaveArtist: reset timeout ");
            if (res != (unsigned int)-1)
                  printk("(res=%04X)", res);
            printk("\n");
            return 1;
      }
      return 0;
}

/* Helper function to send and receive words
 * from WaveArtist.  It handles all the handshaking
 * and can send or receive multiple words.
 */
static int
waveartist_cmd(wavnc_info *devc,
            int nr_cmd, unsigned int *cmd,
            int nr_resp, unsigned int *resp)
{
      unsigned int io_base = devc->hw.io_base;
      unsigned int timed_out = 0;
      unsigned int i;

      if (debug_flg & DEBUG_CMD) {
            printk("waveartist_cmd: cmd=");

            for (i = 0; i < nr_cmd; i++)
                  printk("%04X ", cmd[i]);

            printk("\n");
      }

      if (inb(io_base + STATR) & CMD_RF) {
            int old_data;

            /* flush the port
             */

            old_data = inw(io_base + CMDR);

            if (debug_flg & DEBUG_CMD)
                  printk("flushed %04X...", old_data);

            udelay(10);
      }

      for (i = 0; !timed_out && i < nr_cmd; i++) {
            int count;

            for (count = 5000; count; count--)
                  if (inb(io_base + STATR) & CMD_WE)
                        break;

            if (!count)
                  timed_out = 1;
            else
                  outw(cmd[i], io_base + CMDR);
      }

      for (i = 0; !timed_out && i < nr_resp; i++) {
            int count;

            for (count = 5000; count; count--)
                  if (inb(io_base + STATR) & CMD_RF)
                        break;

            if (!count)
                  timed_out = 1;
            else
                  resp[i] = inw(io_base + CMDR);
      }

      if (debug_flg & DEBUG_CMD) {
            if (!timed_out) {
                  printk("waveartist_cmd: resp=");

                  for (i = 0; i < nr_resp; i++)
                        printk("%04X ", resp[i]);

                  printk("\n");
            } else
                  printk("waveartist_cmd: timed out\n");
      }

      return timed_out ? 1 : 0;
}

/*
 * Send one command word
 */
static inline int
waveartist_cmd1(wavnc_info *devc, unsigned int cmd)
{
      return waveartist_cmd(devc, 1, &cmd, 0, NULL);
}

/*
 * Send one command, receive one word
 */
static inline unsigned int
waveartist_cmd1_r(wavnc_info *devc, unsigned int cmd)
{
      unsigned int ret;

      waveartist_cmd(devc, 1, &cmd, 1, &ret);

      return ret;
}

/*
 * Send a double command, receive one
 * word (and throw it away)
 */
static inline int
waveartist_cmd2(wavnc_info *devc, unsigned int cmd, unsigned int arg)
{
      unsigned int vals[2];

      vals[0] = cmd;
      vals[1] = arg;

      return waveartist_cmd(devc, 2, vals, 1, vals);
}

/*
 * Send a triple command
 */
static inline int
waveartist_cmd3(wavnc_info *devc, unsigned int cmd,
            unsigned int arg1, unsigned int arg2)
{
      unsigned int vals[3];

      vals[0] = cmd;
      vals[1] = arg1;
      vals[2] = arg2;

      return waveartist_cmd(devc, 3, vals, 0, NULL);
}

static int
waveartist_getrev(wavnc_info *devc, char *rev)
{
      unsigned int temp[2];
      unsigned int cmd = WACMD_GETREV;

      waveartist_cmd(devc, 1, &cmd, 2, temp);

      rev[0] = temp[0] >> 8;
      rev[1] = temp[0] & 255;
      rev[2] = '\0';

      return temp[0];
}

static void waveartist_halt_output(int dev);
static void waveartist_halt_input(int dev);
static void waveartist_halt(int dev);
static void waveartist_trigger(int dev, int state);

static int
waveartist_open(int dev, int mode)
{
      wavnc_info  *devc;
      wavnc_port_info   *portc;
      unsigned long     flags;

      if (dev < 0 || dev >= num_audiodevs)
            return -ENXIO;

      devc  = (wavnc_info *) audio_devs[dev]->devc;
      portc = (wavnc_port_info *) audio_devs[dev]->portc;

      spin_lock_irqsave(&waveartist_lock, flags);
      if (portc->open_mode || (devc->open_mode & mode)) {
            spin_unlock_irqrestore(&waveartist_lock, flags);
            return -EBUSY;
      }

      devc->audio_mode  = 0;
      devc->open_mode  |= mode;
      portc->open_mode  = mode;
      waveartist_trigger(dev, 0);

      if (mode & OPEN_READ)
            devc->record_dev = dev;
      if (mode & OPEN_WRITE)
            devc->playback_dev = dev;
      spin_unlock_irqrestore(&waveartist_lock, flags);

      return 0;
}

static void
waveartist_close(int dev)
{
      wavnc_info  *devc = (wavnc_info *) audio_devs[dev]->devc;
      wavnc_port_info   *portc = (wavnc_port_info *) audio_devs[dev]->portc;
      unsigned long     flags;

      spin_lock_irqsave(&waveartist_lock, flags);

      waveartist_halt(dev);

      devc->audio_mode = 0;
      devc->open_mode &= ~portc->open_mode;
      portc->open_mode = 0;

      spin_unlock_irqrestore(&waveartist_lock, flags);
}

static void
waveartist_output_block(int dev, unsigned long buf, int __count, int intrflag)
{
      wavnc_port_info   *portc = (wavnc_port_info *) audio_devs[dev]->portc;
      wavnc_info  *devc = (wavnc_info *) audio_devs[dev]->devc;
      unsigned long     flags;
      unsigned int      count = __count; 

      if (debug_flg & DEBUG_OUT)
            printk("waveartist: output block, buf=0x%lx, count=0x%x...\n",
                  buf, count);
      /*
       * 16 bit data
       */
      if (portc->audio_format & (AFMT_S16_LE | AFMT_S16_BE))
            count >>= 1;

      if (portc->channels > 1)
            count >>= 1;

      count -= 1;

      if (devc->audio_mode & PCM_ENABLE_OUTPUT &&
          audio_devs[dev]->flags & DMA_AUTOMODE &&
          intrflag &&
          count == devc->xfer_count) {
            devc->audio_mode |= PCM_ENABLE_OUTPUT;
            return;     /*
                   * Auto DMA mode on. No need to react
                   */
      }

      spin_lock_irqsave(&waveartist_lock, flags);

      /*
       * set sample count
       */
      waveartist_cmd2(devc, WACMD_OUTPUTSIZE, count);

      devc->xfer_count = count;
      devc->audio_mode |= PCM_ENABLE_OUTPUT;

      spin_unlock_irqrestore(&waveartist_lock, flags);
}

static void
waveartist_start_input(int dev, unsigned long buf, int __count, int intrflag)
{
      wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
      wavnc_info  *devc = (wavnc_info *) audio_devs[dev]->devc;
      unsigned long     flags;
      unsigned int      count = __count;

      if (debug_flg & DEBUG_IN)
            printk("waveartist: start input, buf=0x%lx, count=0x%x...\n",
                  buf, count);

      if (portc->audio_format & (AFMT_S16_LE | AFMT_S16_BE))      /* 16 bit data */
            count >>= 1;

      if (portc->channels > 1)
            count >>= 1;

      count -= 1;

      if (devc->audio_mode & PCM_ENABLE_INPUT &&
          audio_devs[dev]->flags & DMA_AUTOMODE &&
          intrflag &&
          count == devc->xfer_count) {
            devc->audio_mode |= PCM_ENABLE_INPUT;
            return;     /*
                   * Auto DMA mode on. No need to react
                   */
      }

      spin_lock_irqsave(&waveartist_lock, flags);

      /*
       * set sample count
       */
      waveartist_cmd2(devc, WACMD_INPUTSIZE, count);

      devc->xfer_count = count;
      devc->audio_mode |= PCM_ENABLE_INPUT;

      spin_unlock_irqrestore(&waveartist_lock, flags);
}

static int
waveartist_ioctl(int dev, unsigned int cmd, void __user * arg)
{
      return -EINVAL;
}

static unsigned int
waveartist_get_speed(wavnc_port_info *portc)
{
      unsigned int speed;

      /*
       * program the speed, channels, bits
       */
      if (portc->speed == 8000)
            speed = 0x2E71;
      else if (portc->speed == 11025)
            speed = 0x4000;
      else if (portc->speed == 22050)
            speed = 0x8000;
      else if (portc->speed == 44100)
            speed = 0x0;
      else {
            /*
             * non-standard - just calculate
             */
            speed = portc->speed << 16;

            speed = (speed / 44100) & 65535;
      }

      return speed;
}

static unsigned int
waveartist_get_bits(wavnc_port_info *portc)
{
      unsigned int bits;

      if (portc->audio_format == AFMT_S16_LE)
            bits = 1;
      else if (portc->audio_format == AFMT_S8)
            bits = 0;
      else
            bits = 2;   //default AFMT_U8

      return bits;
}

static int
waveartist_prepare_for_input(int dev, int bsize, int bcount)
{
      unsigned long     flags;
      wavnc_info  *devc = (wavnc_info *) audio_devs[dev]->devc;
      wavnc_port_info   *portc = (wavnc_port_info *) audio_devs[dev]->portc;
      unsigned int      speed, bits;

      if (devc->audio_mode)
            return 0;

      speed = waveartist_get_speed(portc);
      bits  = waveartist_get_bits(portc);

      spin_lock_irqsave(&waveartist_lock, flags);

      if (waveartist_cmd2(devc, WACMD_INPUTFORMAT, bits))
            printk(KERN_WARNING "waveartist: error setting the "
                   "record format to %d\n", portc->audio_format);

      if (waveartist_cmd2(devc, WACMD_INPUTCHANNELS, portc->channels))
            printk(KERN_WARNING "waveartist: error setting record "
                   "to %d channels\n", portc->channels);

      /*
       * write cmd SetSampleSpeedTimeConstant
       */
      if (waveartist_cmd2(devc, WACMD_INPUTSPEED, speed))
            printk(KERN_WARNING "waveartist: error setting the record "
                   "speed to %dHz.\n", portc->speed);

      if (waveartist_cmd2(devc, WACMD_INPUTDMA, 1))
            printk(KERN_WARNING "waveartist: error setting the record "
                   "data path to 0x%X\n", 1);

      if (waveartist_cmd2(devc, WACMD_INPUTFORMAT, bits))
            printk(KERN_WARNING "waveartist: error setting the record "
                   "format to %d\n", portc->audio_format);

      devc->xfer_count = 0;
      spin_unlock_irqrestore(&waveartist_lock, flags);
      waveartist_halt_input(dev);

      if (debug_flg & DEBUG_INTR) {
            printk("WA CTLR reg: 0x%02X.\n",
                   inb(devc->hw.io_base + CTLR));
            printk("WA STAT reg: 0x%02X.\n",
                   inb(devc->hw.io_base + STATR));
            printk("WA IRQS reg: 0x%02X.\n",
                   inb(devc->hw.io_base + IRQSTAT));
      }

      return 0;
}

static int
waveartist_prepare_for_output(int dev, int bsize, int bcount)
{
      unsigned long     flags;
      wavnc_info  *devc = (wavnc_info *) audio_devs[dev]->devc;
      wavnc_port_info   *portc = (wavnc_port_info *) audio_devs[dev]->portc;
      unsigned int      speed, bits;

      /*
       * program the speed, channels, bits
       */
      speed = waveartist_get_speed(portc);
      bits  = waveartist_get_bits(portc);

      spin_lock_irqsave(&waveartist_lock, flags);

      if (waveartist_cmd2(devc, WACMD_OUTPUTSPEED, speed) &&
          waveartist_cmd2(devc, WACMD_OUTPUTSPEED, speed))
            printk(KERN_WARNING "waveartist: error setting the playback "
                   "speed to %dHz.\n", portc->speed);

      if (waveartist_cmd2(devc, WACMD_OUTPUTCHANNELS, portc->channels))
            printk(KERN_WARNING "waveartist: error setting the playback "
                   "to %d channels\n", portc->channels);

      if (waveartist_cmd2(devc, WACMD_OUTPUTDMA, 0))
            printk(KERN_WARNING "waveartist: error setting the playback "
                   "data path to 0x%X\n", 0);

      if (waveartist_cmd2(devc, WACMD_OUTPUTFORMAT, bits))
            printk(KERN_WARNING "waveartist: error setting the playback "
                   "format to %d\n", portc->audio_format);

      devc->xfer_count = 0;
      spin_unlock_irqrestore(&waveartist_lock, flags);
      waveartist_halt_output(dev);

      if (debug_flg & DEBUG_INTR) {
            printk("WA CTLR reg: 0x%02X.\n",inb(devc->hw.io_base + CTLR));
            printk("WA STAT reg: 0x%02X.\n",inb(devc->hw.io_base + STATR));
            printk("WA IRQS reg: 0x%02X.\n",inb(devc->hw.io_base + IRQSTAT));
      }

      return 0;
}

static void
waveartist_halt(int dev)
{
      wavnc_port_info   *portc = (wavnc_port_info *) audio_devs[dev]->portc;
      wavnc_info  *devc;

      if (portc->open_mode & OPEN_WRITE)
            waveartist_halt_output(dev);

      if (portc->open_mode & OPEN_READ)
            waveartist_halt_input(dev);

      devc = (wavnc_info *) audio_devs[dev]->devc;
      devc->audio_mode = 0;
}

static void
waveartist_halt_input(int dev)
{
      wavnc_info  *devc = (wavnc_info *) audio_devs[dev]->devc;
      unsigned long     flags;

      spin_lock_irqsave(&waveartist_lock, flags);

      /*
       * Stop capture
       */
      waveartist_cmd1(devc, WACMD_INPUTSTOP);

      devc->audio_mode &= ~PCM_ENABLE_INPUT;

      /*
       * Clear interrupt by toggling
       * the IRQ_ACK bit in CTRL
       */
      if (inb(devc->hw.io_base + STATR) & IRQ_REQ)
            waveartist_iack(devc);

//    devc->audio_mode &= ~PCM_ENABLE_INPUT;

      spin_unlock_irqrestore(&waveartist_lock, flags);
}

static void
waveartist_halt_output(int dev)
{
      wavnc_info  *devc = (wavnc_info *) audio_devs[dev]->devc;
      unsigned long     flags;

      spin_lock_irqsave(&waveartist_lock, flags);

      waveartist_cmd1(devc, WACMD_OUTPUTSTOP);

      devc->audio_mode &= ~PCM_ENABLE_OUTPUT;

      /*
       * Clear interrupt by toggling
       * the IRQ_ACK bit in CTRL
       */
      if (inb(devc->hw.io_base + STATR) & IRQ_REQ)
            waveartist_iack(devc);

//    devc->audio_mode &= ~PCM_ENABLE_OUTPUT;

      spin_unlock_irqrestore(&waveartist_lock, flags);
}

static void
waveartist_trigger(int dev, int state)
{
      wavnc_info  *devc = (wavnc_info *) audio_devs[dev]->devc;
      wavnc_port_info   *portc = (wavnc_port_info *) audio_devs[dev]->portc;
      unsigned long     flags;

      if (debug_flg & DEBUG_TRIGGER) {
            printk("wavnc: audio trigger ");
            if (state & PCM_ENABLE_INPUT)
                  printk("in ");
            if (state & PCM_ENABLE_OUTPUT)
                  printk("out");
            printk("\n");
      }

      spin_lock_irqsave(&waveartist_lock, flags);

      state &= devc->audio_mode;

      if (portc->open_mode & OPEN_READ &&
          state & PCM_ENABLE_INPUT)
            /*
             * enable ADC Data Transfer to PC
             */
            waveartist_cmd1(devc, WACMD_INPUTSTART);

      if (portc->open_mode & OPEN_WRITE &&
          state & PCM_ENABLE_OUTPUT)
            /*
             * enable DAC data transfer from PC
             */
            waveartist_cmd1(devc, WACMD_OUTPUTSTART);

      spin_unlock_irqrestore(&waveartist_lock, flags);
}

static int
waveartist_set_speed(int dev, int arg)
{
      wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;

      if (arg <= 0)
            return portc->speed;

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

      portc->speed = arg;
      return portc->speed;

}

static short
waveartist_set_channels(int dev, short arg)
{
      wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;

      if (arg != 1 && arg != 2)
            return portc->channels;

      portc->channels = arg;
      return arg;
}

static unsigned int
waveartist_set_bits(int dev, unsigned int arg)
{
      wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;

      if (arg == 0)
            return portc->audio_format;

      if ((arg != AFMT_U8) && (arg != AFMT_S16_LE) && (arg != AFMT_S8))
            arg = AFMT_U8;

      portc->audio_format = arg;

      return arg;
}

static struct audio_driver waveartist_audio_driver = {
      .owner                  = THIS_MODULE,
      .open             = waveartist_open,
      .close                  = waveartist_close,
      .output_block           = waveartist_output_block,
      .start_input            = waveartist_start_input,
      .ioctl                  = waveartist_ioctl,
      .prepare_for_input      = waveartist_prepare_for_input,
      .prepare_for_output     = waveartist_prepare_for_output,
      .halt_io          = waveartist_halt,
      .halt_input       = waveartist_halt_input,
      .halt_output            = waveartist_halt_output,
      .trigger          = waveartist_trigger,
      .set_speed        = waveartist_set_speed,
      .set_bits         = waveartist_set_bits,
      .set_channels           = waveartist_set_channels
};


static irqreturn_t
waveartist_intr(int irq, void *dev_id)
{
      wavnc_info *devc = (wavnc_info *)dev_id;
      int      irqstatus, status;

      spin_lock(&waveartist_lock);
      irqstatus = inb(devc->hw.io_base + IRQSTAT);
      status    = inb(devc->hw.io_base + STATR);

      if (debug_flg & DEBUG_INTR)
            printk("waveartist_intr: stat=%02x, irqstat=%02x\n",
                   status, irqstatus);

      if (status & IRQ_REQ)   /* Clear interrupt */
            waveartist_iack(devc);
      else
            printk(KERN_WARNING "waveartist: unexpected interrupt\n");

      if (irqstatus & 0x01) {
            int temp = 1;

            /* PCM buffer done
             */
            if ((status & DMA0) && (devc->audio_mode & PCM_ENABLE_OUTPUT)) {
                  DMAbuf_outputintr(devc->playback_dev, 1);
                  temp = 0;
            }
            if ((status & DMA1) && (devc->audio_mode & PCM_ENABLE_INPUT)) {
                  DMAbuf_inputintr(devc->record_dev);
                  temp = 0;
            }
            if (temp)   //default:
                  printk(KERN_WARNING "waveartist: Unknown interrupt\n");
      }
      if (irqstatus & 0x2)
            // We do not use SB mode natively...
            printk(KERN_WARNING "waveartist: Unexpected SB interrupt...\n");
      spin_unlock(&waveartist_lock);
      return IRQ_HANDLED;
}

/* -------------------------------------------------------------------------
 * Mixer stuff
 */
struct mix_ent {
      unsigned char     reg_l;
      unsigned char     reg_r;
      unsigned char     shift;
      unsigned char     max;
};

static const struct mix_ent mix_devs[SOUND_MIXER_NRDEVICES] = {
      { 2, 6, 1,  7 }, /* SOUND_MIXER_VOLUME   */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_BASS     */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_TREBLE   */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_SYNTH    */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_PCM      */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_SPEAKER  */
      { 0, 4, 6, 31 }, /* SOUND_MIXER_LINE     */
      { 2, 6, 4,  3 }, /* SOUND_MIXER_MIC      */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_CD       */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_IMIX     */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_ALTPCM   */
#if 0
      { 3, 7, 0, 10 }, /* SOUND_MIXER_RECLEV   */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_IGAIN    */
#else
      { 0, 0, 0,  0 }, /* SOUND_MIXER_RECLEV   */
      { 3, 7, 0,  7 }, /* SOUND_MIXER_IGAIN    */
#endif
      { 0, 0, 0,  0 }, /* SOUND_MIXER_OGAIN    */
      { 0, 4, 1, 31 }, /* SOUND_MIXER_LINE1    */
      { 1, 5, 6, 31 }, /* SOUND_MIXER_LINE2    */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_LINE3    */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_DIGITAL1 */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_DIGITAL2 */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_DIGITAL3 */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_PHONEIN  */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_PHONEOUT */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_VIDEO    */
      { 0, 0, 0,  0 }, /* SOUND_MIXER_RADIO    */
      { 0, 0, 0,  0 }  /* SOUND_MIXER_MONITOR  */
};

static void
waveartist_mixer_update(wavnc_info *devc, int whichDev)
{
      unsigned int lev_left, lev_right;

      lev_left  = devc->levels[whichDev] & 0xff;
      lev_right = devc->levels[whichDev] >> 8;

      if (lev_left > 100)
            lev_left = 100;
      if (lev_right > 100)
            lev_right = 100;

#define SCALE(lev,max)  ((lev) * (max) / 100)

      if (machine_is_netwinder() && whichDev == SOUND_MIXER_PHONEOUT)
            whichDev = SOUND_MIXER_VOLUME;

      if (mix_devs[whichDev].reg_l || mix_devs[whichDev].reg_r) {
            const struct mix_ent *mix = mix_devs + whichDev;
            unsigned int mask, left, right;

            mask = mix->max << mix->shift;
            lev_left  = SCALE(lev_left,  mix->max) << mix->shift;
            lev_right = SCALE(lev_right, mix->max) << mix->shift;

            /* read left setting */
            left  = waveartist_cmd1_r(devc, WACMD_GET_LEVEL |
                                     mix->reg_l << 8);

            /* read right setting */
            right = waveartist_cmd1_r(devc, WACMD_GET_LEVEL |
                                    mix->reg_r << 8);

            left  = (left  & ~mask) | (lev_left  & mask);
            right = (right & ~mask) | (lev_right & mask);

            /* write left,right back */
            waveartist_cmd3(devc, WACMD_SET_MIXER, left, right);
      } else {
            switch(whichDev) {
            case SOUND_MIXER_PCM:
                  waveartist_cmd3(devc, WACMD_SET_LEVEL,
                              SCALE(lev_left,  32767),
                              SCALE(lev_right, 32767));
                  break;

            case SOUND_MIXER_SYNTH:
                  waveartist_cmd3(devc, 0x0100 | WACMD_SET_LEVEL,
                              SCALE(lev_left,  32767),
                              SCALE(lev_right, 32767));
                  break;
            }
      }
}

/*
 * Set the ADC MUX to the specified values.  We do NOT do any
 * checking of the values passed, since we assume that the
 * relevant *_select_input function has done that for us.
 */
static void
waveartist_set_adc_mux(wavnc_info *devc, char left_dev, char right_dev)
{
      unsigned int reg_08, reg_09;

      reg_08 = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x0800);
      reg_09 = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x0900);

      reg_08 = (reg_08 & ~0x3f) | right_dev << 3 | left_dev;

      waveartist_cmd3(devc, WACMD_SET_MIXER, reg_08, reg_09);
}

/*
 * Decode a recording mask into a mixer selection as follows:
 *
 *     OSS Source WA Source   Actual source
 *  SOUND_MASK_IMIX     Mixer       Mixer output (same as AD1848)
 *  SOUND_MASK_LINE     Line        Line in
 *  SOUND_MASK_LINE1    Aux 1       Aux 1 in
 *  SOUND_MASK_LINE2    Aux 2       Aux 2 in
 *  SOUND_MASK_MIC      Mic         Microphone
 */
static unsigned int
waveartist_select_input(wavnc_info *devc, unsigned int recmask,
                  unsigned char *dev_l, unsigned char *dev_r)
{
      unsigned int recdev = ADC_MUX_NONE;

      if (recmask & SOUND_MASK_IMIX) {
            recmask = SOUND_MASK_IMIX;
            recdev = ADC_MUX_MIXER;
      } else if (recmask & SOUND_MASK_LINE2) {
            recmask = SOUND_MASK_LINE2;
            recdev = ADC_MUX_AUX2;
      } else if (recmask & SOUND_MASK_LINE1) {
            recmask = SOUND_MASK_LINE1;
            recdev = ADC_MUX_AUX1;
      } else if (recmask & SOUND_MASK_LINE) {
            recmask = SOUND_MASK_LINE;
            recdev = ADC_MUX_LINE;
      } else if (recmask & SOUND_MASK_MIC) {
            recmask = SOUND_MASK_MIC;
            recdev = ADC_MUX_MIC;
      }

      *dev_l = *dev_r = recdev;

      return recmask;
}

static int
waveartist_decode_mixer(wavnc_info *devc, int dev, unsigned char lev_l,
                  unsigned char lev_r)
{
      switch (dev) {
      case SOUND_MIXER_VOLUME:
      case SOUND_MIXER_SYNTH:
      case SOUND_MIXER_PCM:
      case SOUND_MIXER_LINE:
      case SOUND_MIXER_MIC:
      case SOUND_MIXER_IGAIN:
      case SOUND_MIXER_LINE1:
      case SOUND_MIXER_LINE2:
            devc->levels[dev] = lev_l | lev_r << 8;
            break;

      case SOUND_MIXER_IMIX:
            break;

      default:
            dev = -EINVAL;
            break;
      }

      return dev;
}

static int waveartist_get_mixer(wavnc_info *devc, int dev)
{
      return devc->levels[dev];
}

static const struct waveartist_mixer_info waveartist_mixer = {
      .supported_devs   = SUPPORTED_MIXER_DEVICES | SOUND_MASK_IGAIN,
      .recording_devs   = SOUND_MASK_LINE  | SOUND_MASK_MIC   |
                  SOUND_MASK_LINE1 | SOUND_MASK_LINE2 |
                  SOUND_MASK_IMIX,
      .stereo_devs      = (SUPPORTED_MIXER_DEVICES | SOUND_MASK_IGAIN) & ~
                  (SOUND_MASK_SPEAKER | SOUND_MASK_IMIX),
      .select_input     = waveartist_select_input,
      .decode_mixer     = waveartist_decode_mixer,
      .get_mixer  = waveartist_get_mixer,
};

static void
waveartist_set_recmask(wavnc_info *devc, unsigned int recmask)
{
      unsigned char dev_l, dev_r;

      recmask &= devc->mix->recording_devs;

      /*
       * If more than one recording device selected,
       * disable the device that is currently in use.
       */
      if (hweight32(recmask) > 1)
            recmask &= ~devc->recmask;

      /*
       * Translate the recording device mask into
       * the ADC multiplexer settings.
       */
      devc->recmask = devc->mix->select_input(devc, recmask,
                                    &dev_l, &dev_r);

      waveartist_set_adc_mux(devc, dev_l, dev_r);
}

static int
waveartist_set_mixer(wavnc_info *devc, int dev, unsigned int level)
{
      unsigned int lev_left  = level & 0x00ff;
      unsigned int lev_right = (level & 0xff00) >> 8;

      if (lev_left > 100)
            lev_left = 100;
      if (lev_right > 100)
            lev_right = 100;

      /*
       * Mono devices have their right volume forced to their
       * left volume.  (from ALSA driver OSS emulation).
       */
      if (!(devc->mix->stereo_devs & (1 << dev)))
            lev_right = lev_left;

      dev = devc->mix->decode_mixer(devc, dev, lev_left, lev_right);

      if (dev >= 0)
            waveartist_mixer_update(devc, dev);

      return dev < 0 ? dev : 0;
}

static int
waveartist_mixer_ioctl(int dev, unsigned int cmd, void __user * arg)
{
      wavnc_info *devc = (wavnc_info *)audio_devs[dev]->devc;
      int ret = 0, val, nr;

      /*
       * All SOUND_MIXER_* ioctls use type 'M'
       */
      if (((cmd >> 8) & 255) != 'M')
            return -ENOIOCTLCMD;

#ifdef CONFIG_ARCH_NETWINDER
      if (machine_is_netwinder()) {
            ret = vnc_private_ioctl(dev, cmd, arg);
            if (ret != -ENOIOCTLCMD)
                  return ret;
            else
                  ret = 0;
      }
#endif

      nr = cmd & 0xff;

      if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
            if (get_user(val, (int __user *)arg))
                  return -EFAULT;

            switch (nr) {
            case SOUND_MIXER_RECSRC:
                  waveartist_set_recmask(devc, val);
                  break;

            default:
                  ret = -EINVAL;
                  if (nr < SOUND_MIXER_NRDEVICES &&
                      devc->mix->supported_devs & (1 << nr))
                        ret = waveartist_set_mixer(devc, nr, val);
            }
      }

      if (ret == 0 && _SIOC_DIR(cmd) & _SIOC_READ) {
            ret = -EINVAL;

            switch (nr) {
            case SOUND_MIXER_RECSRC:
                  ret = devc->recmask;
                  break;

            case SOUND_MIXER_DEVMASK:
                  ret = devc->mix->supported_devs;
                  break;

            case SOUND_MIXER_STEREODEVS:
                  ret = devc->mix->stereo_devs;
                  break;

            case SOUND_MIXER_RECMASK:
                  ret = devc->mix->recording_devs;
                  break;

            case SOUND_MIXER_CAPS:
                  ret = SOUND_CAP_EXCL_INPUT;
                  break;

            default:
                  if (nr < SOUND_MIXER_NRDEVICES)
                        ret = devc->mix->get_mixer(devc, nr);
                  break;
            }

            if (ret >= 0)
                  ret = put_user(ret, (int __user *)arg) ? -EFAULT : 0;
      }

      return ret;
}

static struct mixer_operations waveartist_mixer_operations =
{
      .owner      = THIS_MODULE,
      .id   = "WaveArtist",
      .name = "WaveArtist",
      .ioctl      = waveartist_mixer_ioctl
};

static void
waveartist_mixer_reset(wavnc_info *devc)
{
      int i;

      if (debug_flg & DEBUG_MIXER)
            printk("%s: mixer_reset\n", devc->hw.name);

      /*
       * reset mixer cmd
       */
      waveartist_cmd1(devc, WACMD_RST_MIXER);

      /*
       * set input for ADC to come from 'quiet'
       * turn on default modes
       */
      waveartist_cmd3(devc, WACMD_SET_MIXER, 0x9800, 0xa836);

      /*
       * set mixer input select to none, RX filter gains 0 dB
       */
      waveartist_cmd3(devc, WACMD_SET_MIXER, 0x4c00, 0x8c00);

      /*
       * set bit 0 reg 2 to 1 - unmute MonoOut
       */
      waveartist_cmd3(devc, WACMD_SET_MIXER, 0x2801, 0x6800);

      /* set default input device = internal mic
       * current recording device = none
       */
      waveartist_set_recmask(devc, 0);

      for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
            waveartist_mixer_update(devc, i);
}

static int __init waveartist_init(wavnc_info *devc)
{
      wavnc_port_info *portc;
      char rev[3], dev_name[64];
      int my_dev;

      if (waveartist_reset(devc))
            return -ENODEV;

      sprintf(dev_name, "%s (%s", devc->hw.name, devc->chip_name);

      if (waveartist_getrev(devc, rev)) {
            strcat(dev_name, " rev. ");
            strcat(dev_name, rev);
      }
      strcat(dev_name, ")");

      conf_printf2(dev_name, devc->hw.io_base, devc->hw.irq,
                 devc->hw.dma, devc->hw.dma2);

      portc = kzalloc(sizeof(wavnc_port_info), GFP_KERNEL);
      if (portc == NULL)
            goto nomem;

      my_dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION, dev_name,
                  &waveartist_audio_driver, sizeof(struct audio_driver),
                  devc->audio_flags, AFMT_U8 | AFMT_S16_LE | AFMT_S8,
                  devc, devc->hw.dma, devc->hw.dma2);

      if (my_dev < 0)
            goto free;

      audio_devs[my_dev]->portc = portc;

      waveartist_mixer_reset(devc);

      /*
       * clear any pending interrupt
       */
      waveartist_iack(devc);

      if (request_irq(devc->hw.irq, waveartist_intr, 0, devc->hw.name, devc) < 0) {
            printk(KERN_ERR "%s: IRQ %d in use\n",
                  devc->hw.name, devc->hw.irq);
            goto uninstall;
      }

      if (sound_alloc_dma(devc->hw.dma, devc->hw.name)) {
            printk(KERN_ERR "%s: Can't allocate DMA%d\n",
                  devc->hw.name, devc->hw.dma);
            goto uninstall_irq;
      }

      if (devc->hw.dma != devc->hw.dma2 && devc->hw.dma2 != NO_DMA)
            if (sound_alloc_dma(devc->hw.dma2, devc->hw.name)) {
                  printk(KERN_ERR "%s: can't allocate DMA%d\n",
                        devc->hw.name, devc->hw.dma2);
                  goto uninstall_dma;
            }

      waveartist_set_ctlr(&devc->hw, 0, DMA1_IE | DMA0_IE);

      audio_devs[my_dev]->mixer_dev =
            sound_install_mixer(MIXER_DRIVER_VERSION,
                        dev_name,
                        &waveartist_mixer_operations,
                        sizeof(struct mixer_operations),
                        devc);

      return my_dev;

uninstall_dma:
      sound_free_dma(devc->hw.dma);

uninstall_irq:
      free_irq(devc->hw.irq, devc);

uninstall:
      sound_unload_audiodev(my_dev);

free:
      kfree(portc);

nomem:
      return -1;
}

static int __init probe_waveartist(struct address_info *hw_config)
{
      wavnc_info *devc = &adev_info[nr_waveartist_devs];

      if (nr_waveartist_devs >= MAX_AUDIO_DEV) {
            printk(KERN_WARNING "waveartist: too many audio devices\n");
            return 0;
      }

      if (!request_region(hw_config->io_base, 15, hw_config->name))  {
            printk(KERN_WARNING "WaveArtist: I/O port conflict\n");
            return 0;
      }

      if (hw_config->irq > 15 || hw_config->irq < 0) {
            release_region(hw_config->io_base, 15);
            printk(KERN_WARNING "WaveArtist: Bad IRQ %d\n",
                   hw_config->irq);
            return 0;
      }

      if (hw_config->dma != 3) {
            release_region(hw_config->io_base, 15);
            printk(KERN_WARNING "WaveArtist: Bad DMA %d\n",
                   hw_config->dma);
            return 0;
      }

      hw_config->name = "WaveArtist";
      devc->hw = *hw_config;
      devc->open_mode = 0;
      devc->chip_name = "RWA-010";

      return 1;
}

static void __init
attach_waveartist(struct address_info *hw, const struct waveartist_mixer_info *mix)
{
      wavnc_info *devc = &adev_info[nr_waveartist_devs];

      /*
       * NOTE! If irq < 0, there is another driver which has allocated the
       *   IRQ so that this driver doesn't need to allocate/deallocate it.
       *   The actually used IRQ is ABS(irq).
       */
      devc->hw = *hw;
      devc->hw.irq = (hw->irq > 0) ? hw->irq : 0;
      devc->open_mode = 0;
      devc->playback_dev = 0;
      devc->record_dev = 0;
      devc->audio_flags = DMA_AUTOMODE;
      devc->levels = levels;

      if (hw->dma != hw->dma2 && hw->dma2 != NO_DMA)
            devc->audio_flags |= DMA_DUPLEX;

      devc->mix = mix;
      devc->dev_no = waveartist_init(devc);

      if (devc->dev_no < 0)
            release_region(hw->io_base, 15);
      else {
#ifdef CONFIG_ARCH_NETWINDER
            if (machine_is_netwinder()) {
                  init_timer(&vnc_timer);
                  vnc_timer.function = vnc_slider_tick;
                  vnc_timer.expires  = jiffies;
                  vnc_timer.data     = nr_waveartist_devs;
                  add_timer(&vnc_timer);

                  vnc_configure_mixer(devc, 0);

                  devc->no_autoselect = 1;
            }
#endif
            nr_waveartist_devs += 1;
      }
}

static void __exit unload_waveartist(struct address_info *hw)
{
      wavnc_info *devc = NULL;
      int i;

      for (i = 0; i < nr_waveartist_devs; i++)
            if (hw->io_base == adev_info[i].hw.io_base) {
                  devc = adev_info + i;
                  break;
            }

      if (devc != NULL) {
            int mixer;

#ifdef CONFIG_ARCH_NETWINDER
            if (machine_is_netwinder())
                  del_timer(&vnc_timer);
#endif

            release_region(devc->hw.io_base, 15);

            waveartist_set_ctlr(&devc->hw, DMA1_IE|DMA0_IE, 0);

            if (devc->hw.irq >= 0)
                  free_irq(devc->hw.irq, devc);

            sound_free_dma(devc->hw.dma);

            if (devc->hw.dma != devc->hw.dma2 &&
                devc->hw.dma2 != NO_DMA)
                  sound_free_dma(devc->hw.dma2);

            mixer = audio_devs[devc->dev_no]->mixer_dev;

            if (mixer >= 0)
                  sound_unload_mixerdev(mixer);

            if (devc->dev_no >= 0)
                  sound_unload_audiodev(devc->dev_no);

            nr_waveartist_devs -= 1;

            for (; i < nr_waveartist_devs; i++)
                  adev_info[i] = adev_info[i + 1];
      } else
            printk(KERN_WARNING "waveartist: can't find device "
                   "to unload\n");
}

#ifdef CONFIG_ARCH_NETWINDER

/*
 * Rebel.com Netwinder specifics...
 */

#include <asm/hardware/dec21285.h>
 
#define     VNC_TIMER_PERIOD (HZ/4) //check slider 4 times/sec

#define     MIXER_PRIVATE3_RESET    0x53570000
#define     MIXER_PRIVATE3_READ     0x53570001
#define     MIXER_PRIVATE3_WRITE    0x53570002

#define     VNC_MUTE_INTERNAL_SPKR  0x01  //the sw mute on/off control bit
#define     VNC_MUTE_LINE_OUT 0x10
#define VNC_PHONE_DETECT      0x20
#define VNC_HANDSET_DETECT    0x40
#define VNC_DISABLE_AUTOSWITCH      0x80

extern spinlock_t gpio_lock;

static inline void
vnc_mute_spkr(wavnc_info *devc)
{
      unsigned long flags;

      spin_lock_irqsave(&gpio_lock, flags);
      cpld_modify(CPLD_UNMUTE, devc->spkr_mute_state ? 0 : CPLD_UNMUTE);
      spin_unlock_irqrestore(&gpio_lock, flags);
}

static void
vnc_mute_lout(wavnc_info *devc)
{
      unsigned int left, right;

      left  = waveartist_cmd1_r(devc, WACMD_GET_LEVEL);
      right = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x400);

      if (devc->line_mute_state) {
            left &= ~1;
            right &= ~1;
      } else {
            left |= 1;
            right |= 1;
      }
      waveartist_cmd3(devc, WACMD_SET_MIXER, left, right);
            
}

static int
vnc_volume_slider(wavnc_info *devc)
{
      static signed int old_slider_volume;
      unsigned long flags;
      signed int volume = 255;

      *CSR_TIMER1_LOAD = 0x00ffffff;

      spin_lock_irqsave(&waveartist_lock, flags);

      outb(0xFF, 0x201);
      *CSR_TIMER1_CNTL = TIMER_CNTL_ENABLE | TIMER_CNTL_DIV1;

      while (volume && (inb(0x201) & 0x01))
            volume--;

      *CSR_TIMER1_CNTL = 0;

      spin_unlock_irqrestore(&waveartist_lock,flags);
      
      volume = 0x00ffffff - *CSR_TIMER1_VALUE;


#ifndef REVERSE
      volume = 150 - (volume >> 5);
#else
      volume = (volume >> 6) - 25;
#endif

      if (volume < 0)
            volume = 0;

      if (volume > 100)
            volume = 100;

      /*
       * slider quite often reads +-8, so debounce this random noise
       */
      if (abs(volume - old_slider_volume) > 7) {
            old_slider_volume = volume;

            if (debug_flg & DEBUG_MIXER)
                  printk(KERN_DEBUG "Slider volume: %d.\n", volume);
      }

      return old_slider_volume;
}

/*
 * Decode a recording mask into a mixer selection on the NetWinder
 * as follows:
 *
 *     OSS Source WA Source   Actual source
 *  SOUND_MASK_IMIX     Mixer       Mixer output (same as AD1848)
 *  SOUND_MASK_LINE     Line        Line in
 *  SOUND_MASK_LINE1    Left Mic    Handset
 *  SOUND_MASK_PHONEIN  Left Aux    Telephone microphone
 *  SOUND_MASK_MIC      Right Mic   Builtin microphone
 */
static unsigned int
netwinder_select_input(wavnc_info *devc, unsigned int recmask,
                   unsigned char *dev_l, unsigned char *dev_r)
{
      unsigned int recdev_l = ADC_MUX_NONE, recdev_r = ADC_MUX_NONE;

      if (recmask & SOUND_MASK_IMIX) {
            recmask = SOUND_MASK_IMIX;
            recdev_l = ADC_MUX_MIXER;
            recdev_r = ADC_MUX_MIXER;
      } else if (recmask & SOUND_MASK_LINE) {
            recmask = SOUND_MASK_LINE;
            recdev_l = ADC_MUX_LINE;
            recdev_r = ADC_MUX_LINE;
      } else if (recmask & SOUND_MASK_LINE1) {
            recmask = SOUND_MASK_LINE1;
            waveartist_cmd1(devc, WACMD_SET_MONO); /* left */
            recdev_l = ADC_MUX_MIC;
            recdev_r = ADC_MUX_NONE;
      } else if (recmask & SOUND_MASK_PHONEIN) {
            recmask = SOUND_MASK_PHONEIN;
            waveartist_cmd1(devc, WACMD_SET_MONO); /* left */
            recdev_l = ADC_MUX_AUX1;
            recdev_r = ADC_MUX_NONE;
      } else if (recmask & SOUND_MASK_MIC) {
            recmask = SOUND_MASK_MIC;
            waveartist_cmd1(devc, WACMD_SET_MONO | 0x100);  /* right */
            recdev_l = ADC_MUX_NONE;
            recdev_r = ADC_MUX_MIC;
      }

      *dev_l = recdev_l;
      *dev_r = recdev_r;

      return recmask;
}

static int
netwinder_decode_mixer(wavnc_info *devc, int dev, unsigned char lev_l,
                   unsigned char lev_r)
{
      switch (dev) {
      case SOUND_MIXER_VOLUME:
      case SOUND_MIXER_SYNTH:
      case SOUND_MIXER_PCM:
      case SOUND_MIXER_LINE:
      case SOUND_MIXER_IGAIN:
            devc->levels[dev] = lev_l | lev_r << 8;
            break;

      case SOUND_MIXER_MIC:         /* right mic only */
            devc->levels[SOUND_MIXER_MIC] &= 0xff;
            devc->levels[SOUND_MIXER_MIC] |= lev_l << 8;
            break;

      case SOUND_MIXER_LINE1:       /* left mic only  */
            devc->levels[SOUND_MIXER_MIC] &= 0xff00;
            devc->levels[SOUND_MIXER_MIC] |= lev_l;
            dev = SOUND_MIXER_MIC;
            break;

      case SOUND_MIXER_PHONEIN:     /* left aux only  */
            devc->levels[SOUND_MIXER_LINE1] = lev_l;
            dev = SOUND_MIXER_LINE1;
            break;

      case SOUND_MIXER_IMIX:
      case SOUND_MIXER_PHONEOUT:
            break;

      default:
            dev = -EINVAL;
            break;
      }
      return dev;
}

static int netwinder_get_mixer(wavnc_info *devc, int dev)
{
      int levels;

      switch (dev) {
      case SOUND_MIXER_VOLUME:
      case SOUND_MIXER_SYNTH:
      case SOUND_MIXER_PCM:
      case SOUND_MIXER_LINE:
      case SOUND_MIXER_IGAIN:
            levels = devc->levels[dev];
            break;

      case SOUND_MIXER_MIC:         /* builtin mic: right mic only */
            levels = devc->levels[SOUND_MIXER_MIC] >> 8;
            levels |= levels << 8;
            break;

      case SOUND_MIXER_LINE1:       /* handset mic: left mic only */
            levels = devc->levels[SOUND_MIXER_MIC] & 0xff;
            levels |= levels << 8;
            break;

      case SOUND_MIXER_PHONEIN:     /* phone mic: left aux1 only */
            levels = devc->levels[SOUND_MIXER_LINE1] & 0xff;
            levels |= levels << 8;
            break;

      default:
            levels = 0;
      }

      return levels;
}

/*
 * Waveartist specific mixer information.
 */
static const struct waveartist_mixer_info netwinder_mixer = {
      .supported_devs   = SOUND_MASK_VOLUME  | SOUND_MASK_SYNTH   |
                  SOUND_MASK_PCM     | SOUND_MASK_SPEAKER |
                  SOUND_MASK_LINE    | SOUND_MASK_MIC     |
                  SOUND_MASK_IMIX    | SOUND_MASK_LINE1   |
                  SOUND_MASK_PHONEIN | SOUND_MASK_PHONEOUT|
                  SOUND_MASK_IGAIN,

      .recording_devs   = SOUND_MASK_LINE    | SOUND_MASK_MIC     |
                  SOUND_MASK_IMIX    | SOUND_MASK_LINE1   |
                  SOUND_MASK_PHONEIN,

      .stereo_devs      = SOUND_MASK_VOLUME  | SOUND_MASK_SYNTH   |
                  SOUND_MASK_PCM     | SOUND_MASK_LINE    |
                  SOUND_MASK_IMIX    | SOUND_MASK_IGAIN,

      .select_input     = netwinder_select_input,
      .decode_mixer     = netwinder_decode_mixer,
      .get_mixer  = netwinder_get_mixer,
};

static void
vnc_configure_mixer(wavnc_info *devc, unsigned int recmask)
{
      if (!devc->no_autoselect) {
            if (devc->handset_detect) {
                  recmask = SOUND_MASK_LINE1;
                  devc->spkr_mute_state = devc->line_mute_state = 1;
            } else if (devc->telephone_detect) {
                  recmask = SOUND_MASK_PHONEIN;
                  devc->spkr_mute_state = devc->line_mute_state = 1;
            } else {
                  /* unless someone has asked for LINE-IN,
                   * we default to MIC
                   */
                  if ((devc->recmask & SOUND_MASK_LINE) == 0)
                        devc->recmask = SOUND_MASK_MIC;
                  devc->spkr_mute_state = devc->line_mute_state = 0;
            }
            vnc_mute_spkr(devc);
            vnc_mute_lout(devc);

            if (recmask != devc->recmask)
                  waveartist_set_recmask(devc, recmask);
      }
}

static int
vnc_slider(wavnc_info *devc)
{
      signed int slider_volume;
      unsigned int temp, old_hs, old_td;

      /*
       * read the "buttons" state.
       *  Bit 4 = 0 means handset present
       *  Bit 5 = 1 means phone offhook
       */
      temp = inb(0x201);

      old_hs = devc->handset_detect;
      old_td = devc->telephone_detect;

      devc->handset_detect = !(temp & 0x10);
      devc->telephone_detect = !!(temp & 0x20);

      if (!devc->no_autoselect &&
          (old_hs != devc->handset_detect ||
           old_td != devc->telephone_detect))
            vnc_configure_mixer(devc, devc->recmask);

      slider_volume = vnc_volume_slider(devc);

      /*
       * If we're using software controlled volume, and
       * the slider moves by more than 20%, then we
       * switch back to slider controlled volume.
       */
      if (abs(devc->slider_vol - slider_volume) > 20)
            devc->use_slider = 1;

      /*
       * use only left channel
       */
      temp = levels[SOUND_MIXER_VOLUME] & 0xFF;

      if (slider_volume != temp && devc->use_slider) {
            devc->slider_vol = slider_volume;

            waveartist_set_mixer(devc, SOUND_MIXER_VOLUME,
                  slider_volume | slider_volume << 8);

            return 1;
      }

      return 0;
}

static void
vnc_slider_tick(unsigned long data)
{
      int next_timeout;

      if (vnc_slider(adev_info + data))
            next_timeout = 5; // mixer reported change
      else
            next_timeout = VNC_TIMER_PERIOD;

      mod_timer(&vnc_timer, jiffies + next_timeout);
}

static int
vnc_private_ioctl(int dev, unsigned int cmd, int __user * arg)
{
      wavnc_info *devc = (wavnc_info *)audio_devs[dev]->devc;
      int val;

      switch (cmd) {
      case SOUND_MIXER_PRIVATE1:
      {
            u_int prev_spkr_mute, prev_line_mute, prev_auto_state;
            int val;

            if (get_user(val, arg))
                  return -EFAULT;

            /* check if parameter is logical */
            if (val & ~(VNC_MUTE_INTERNAL_SPKR |
                      VNC_MUTE_LINE_OUT |
                      VNC_DISABLE_AUTOSWITCH))
                  return -EINVAL;

            prev_auto_state = devc->no_autoselect;
            prev_spkr_mute  = devc->spkr_mute_state;
            prev_line_mute  = devc->line_mute_state;

            devc->no_autoselect   = (val & VNC_DISABLE_AUTOSWITCH) ? 1 : 0;
            devc->spkr_mute_state = (val & VNC_MUTE_INTERNAL_SPKR) ? 1 : 0;
            devc->line_mute_state = (val & VNC_MUTE_LINE_OUT) ? 1 : 0;

            if (prev_spkr_mute != devc->spkr_mute_state)
                  vnc_mute_spkr(devc);

            if (prev_line_mute != devc->line_mute_state)
                  vnc_mute_lout(devc);

            if (prev_auto_state != devc->no_autoselect)
                  vnc_configure_mixer(devc, devc->recmask);

            return 0;
      }

      case SOUND_MIXER_PRIVATE2:
            if (get_user(val, arg))
                  return -EFAULT;

            switch (val) {
#define VNC_SOUND_PAUSE         0x53    //to pause the DSP
#define VNC_SOUND_RESUME        0x57    //to unpause the DSP
            case VNC_SOUND_PAUSE:
                  waveartist_cmd1(devc, 0x16);
                  break;

            case VNC_SOUND_RESUME:
                  waveartist_cmd1(devc, 0x18);
                  break;

            default:
                  return -EINVAL;
            }
            return 0;

      /* private ioctl to allow bulk access to waveartist */
      case SOUND_MIXER_PRIVATE3:
      {
            unsigned long     flags;
            int         mixer_reg[15], i, val;

            if (get_user(val, arg))
                  return -EFAULT;
            if (copy_from_user(mixer_reg, (void *)val, sizeof(mixer_reg)))
                  return -EFAULT;

            switch (mixer_reg[14]) {
            case MIXER_PRIVATE3_RESET:
                  waveartist_mixer_reset(devc);
                  break;

            case MIXER_PRIVATE3_WRITE:
                  waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[0], mixer_reg[4]);
                  waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[1], mixer_reg[5]);
                  waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[2], mixer_reg[6]);
                  waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[3], mixer_reg[7]);
                  waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[8], mixer_reg[9]);

                  waveartist_cmd3(devc, WACMD_SET_LEVEL, mixer_reg[10], mixer_reg[11]);
                  waveartist_cmd3(devc, WACMD_SET_LEVEL, mixer_reg[12], mixer_reg[13]);
                  break;

            case MIXER_PRIVATE3_READ:
                  spin_lock_irqsave(&waveartist_lock, flags);

                  for (i = 0x30; i < 14 << 8; i += 1 << 8)
                        waveartist_cmd(devc, 1, &i, 1, mixer_reg + (i >> 8));

                  spin_unlock_irqrestore(&waveartist_lock, flags);

                  if (copy_to_user((void *)val, mixer_reg, sizeof(mixer_reg)))
                        return -EFAULT;
                  break;

            default:
                  return -EINVAL;
            }
            return 0;
      }

      /* read back the state from PRIVATE1 */
      case SOUND_MIXER_PRIVATE4:
            val = (devc->spkr_mute_state  ? VNC_MUTE_INTERNAL_SPKR : 0) |
                  (devc->line_mute_state  ? VNC_MUTE_LINE_OUT      : 0) |
                  (devc->handset_detect   ? VNC_HANDSET_DETECT     : 0) |
                  (devc->telephone_detect ? VNC_PHONE_DETECT       : 0) |
                  (devc->no_autoselect    ? VNC_DISABLE_AUTOSWITCH : 0);

            return put_user(val, arg) ? -EFAULT : 0;
      }

      if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
            /*
             * special case for master volume: if we
             * received this call - switch from hw
             * volume control to a software volume
             * control, till the hw volume is modified
             * to signal that user wants to be back in
             * hardware...
             */
            if ((cmd & 0xff) == SOUND_MIXER_VOLUME)
                  devc->use_slider = 0;

            /* speaker output            */
            if ((cmd & 0xff) == SOUND_MIXER_SPEAKER) {
                  unsigned int val, l, r;

                  if (get_user(val, arg))
                        return -EFAULT;

                  l = val & 0x7f;
                  r = (val & 0x7f00) >> 8;
                  val = (l + r) / 2;
                  devc->levels[SOUND_MIXER_SPEAKER] = val | (val << 8);
                  devc->spkr_mute_state = (val <= 50);
                  vnc_mute_spkr(devc);
                  return 0;
            }
      }

      return -ENOIOCTLCMD;
}

#endif

static struct address_info cfg;

static int attached;

static int __initdata io = 0;
static int __initdata irq = 0;
static int __initdata dma = 0;
static int __initdata dma2 = 0;


static int __init init_waveartist(void)
{
      const struct waveartist_mixer_info *mix;

      if (!io && machine_is_netwinder()) {
            /*
             * The NetWinder WaveArtist is at a fixed address.
             * If the user does not supply an address, use the
             * well-known parameters.
             */
            io   = 0x250;
            irq  = 12;
            dma  = 3;
            dma2 = 7;
      }

      mix = &waveartist_mixer;
#ifdef CONFIG_ARCH_NETWINDER
      if (machine_is_netwinder())
            mix = &netwinder_mixer;
#endif

      cfg.io_base = io;
      cfg.irq = irq;
      cfg.dma = dma;
      cfg.dma2 = dma2;

      if (!probe_waveartist(&cfg))
            return -ENODEV;

      attach_waveartist(&cfg, mix);
      attached = 1;

      return 0;
}

static void __exit cleanup_waveartist(void)
{
      if (attached)
            unload_waveartist(&cfg);
}

module_init(init_waveartist);
module_exit(cleanup_waveartist);

#ifndef MODULE
static int __init setup_waveartist(char *str)
{
      /* io, irq, dma, dma2 */
      int ints[5];
      
      str = get_options(str, ARRAY_SIZE(ints), ints);
      
      io    = ints[1];
      irq   = ints[2];
      dma   = ints[3];
      dma2  = ints[4];

      return 1;
}
__setup("waveartist=", setup_waveartist);
#endif

MODULE_DESCRIPTION("Rockwell WaveArtist RWA-010 sound driver");
module_param(io, int, 0);           /* IO base */
module_param(irq, int, 0);          /* IRQ */
module_param(dma, int, 0);          /* DMA */
module_param(dma2, int, 0);         /* DMA2 */
MODULE_LICENSE("GPL");

Generated by  Doxygen 1.6.0   Back to index