URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [sound/] [waveartist.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

/*
 * linux/drivers/sound/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/config.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 spinlock_t       waveartist_lock = SPIN_LOCK_UNLOCKED;
 
#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, caddr_t 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, caddr_t 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 void
waveartist_intr(int irq, void *dev_id, struct pt_regs *regs)
{
        wavnc_info *devc = (wavnc_info *)dev_id;
        int        irqstatus, status;
 
        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");
}
 
/* -------------------------------------------------------------------------
 * 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, caddr_t 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 *)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 *)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 = (wavnc_port_info *)kmalloc(sizeof(wavnc_port_info), GFP_KERNEL);
        if (portc == NULL)
                goto nomem;
 
        memset(portc, 0, sizeof(wavnc_port_info));
 
        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 (check_region(hw_config->io_base, 15))  {
                printk(KERN_WARNING "WaveArtist: I/O port conflict\n");
                return 0;
        }
 
        if (hw_config->irq > 15 || hw_config->irq < 0) {
                printk(KERN_WARNING "WaveArtist: Bad IRQ %d\n",
                       hw_config->irq);
                return 0;
        }
 
        if (hw_config->dma != 3) {
                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;
 
        request_region(hw->io_base, 15, devc->hw.name);
 
        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;
 
        save_flags(flags);
        cli();
 
        outb(0xFF, 0x201);
        *CSR_TIMER1_CNTL = TIMER_CNTL_ENABLE | TIMER_CNTL_DIV1;
 
        while (volume && (inb(0x201) & 0x01))
                volume--;
 
        *CSR_TIMER1_CNTL = 0;
 
        restore_flags(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, caddr_t 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, (int *)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, (int *)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, (int *)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, (int *)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, (int *)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_PARM(io, "i");           /* IO base */
MODULE_PARM(irq, "i");          /* IRQ */
MODULE_PARM(dma, "i");          /* DMA */
MODULE_PARM(dma2, "i");         /* DMA2 */
MODULE_LICENSE("GPL");
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [sound/] [waveartist.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* linux/drivers/sound/waveartist.c`
3			`*`
4			`* The low level driver for the RWA010 Rockwell Wave Artist`
5			`* codec chip used in the Rebel.com NetWinder.`
6			`*`
7			`* Cleaned up and integrated into 2.1 by Russell King (rmk@arm.linux.org.uk)`
8			`* and Pat Beirne (patb@corel.ca)`
9			`*`
10			`*`
11			`* Copyright (C) by Rebel.com 1998-1999`
12			`*`
13			`* RWA010 specs received under NDA from Rockwell`
14			`*`
15			`* Copyright (C) by Hannu Savolainen 1993-1997`
16			`*`
17			`* OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)`
18			`* Version 2 (June 1991). See the "COPYING" file distributed with this software`
19			`* for more info.`
20			`*`
21			`* Changes:`
22			`* 11-10-2000 Bartlomiej Zolnierkiewicz <bkz@linux-ide.org>`
23			`* Added __init to waveartist_init()`
24			`*/`
25
26			`/* Debugging */`
27			`#define DEBUG_CMD 1`
28			`#define DEBUG_OUT 2`
29			`#define DEBUG_IN 4`
30			`#define DEBUG_INTR 8`
31			`#define DEBUG_MIXER 16`
32			`#define DEBUG_TRIGGER 32`
33
34			`#define debug_flg (0)`
35
36			`#include <linux/module.h>`
37			`#include <linux/init.h>`
38			`#include <linux/config.h>`
39			`#include <linux/sched.h>`
40			`#include <linux/interrupt.h>`