mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-05 15:16:39 +07:00
5a0e3ad6af
percpu.h is included by sched.h and module.h and thus ends up being included when building most .c files. percpu.h includes slab.h which in turn includes gfp.h making everything defined by the two files universally available and complicating inclusion dependencies. percpu.h -> slab.h dependency is about to be removed. Prepare for this change by updating users of gfp and slab facilities include those headers directly instead of assuming availability. As this conversion needs to touch large number of source files, the following script is used as the basis of conversion. http://userweb.kernel.org/~tj/misc/slabh-sweep.py The script does the followings. * Scan files for gfp and slab usages and update includes such that only the necessary includes are there. ie. if only gfp is used, gfp.h, if slab is used, slab.h. * When the script inserts a new include, it looks at the include blocks and try to put the new include such that its order conforms to its surrounding. It's put in the include block which contains core kernel includes, in the same order that the rest are ordered - alphabetical, Christmas tree, rev-Xmas-tree or at the end if there doesn't seem to be any matching order. * If the script can't find a place to put a new include (mostly because the file doesn't have fitting include block), it prints out an error message indicating which .h file needs to be added to the file. The conversion was done in the following steps. 1. The initial automatic conversion of all .c files updated slightly over 4000 files, deleting around 700 includes and adding ~480 gfp.h and ~3000 slab.h inclusions. The script emitted errors for ~400 files. 2. Each error was manually checked. Some didn't need the inclusion, some needed manual addition while adding it to implementation .h or embedding .c file was more appropriate for others. This step added inclusions to around 150 files. 3. The script was run again and the output was compared to the edits from #2 to make sure no file was left behind. 4. Several build tests were done and a couple of problems were fixed. e.g. lib/decompress_*.c used malloc/free() wrappers around slab APIs requiring slab.h to be added manually. 5. The script was run on all .h files but without automatically editing them as sprinkling gfp.h and slab.h inclusions around .h files could easily lead to inclusion dependency hell. Most gfp.h inclusion directives were ignored as stuff from gfp.h was usually wildly available and often used in preprocessor macros. Each slab.h inclusion directive was examined and added manually as necessary. 6. percpu.h was updated not to include slab.h. 7. Build test were done on the following configurations and failures were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my distributed build env didn't work with gcov compiles) and a few more options had to be turned off depending on archs to make things build (like ipr on powerpc/64 which failed due to missing writeq). * x86 and x86_64 UP and SMP allmodconfig and a custom test config. * powerpc and powerpc64 SMP allmodconfig * sparc and sparc64 SMP allmodconfig * ia64 SMP allmodconfig * s390 SMP allmodconfig * alpha SMP allmodconfig * um on x86_64 SMP allmodconfig 8. percpu.h modifications were reverted so that it could be applied as a separate patch and serve as bisection point. Given the fact that I had only a couple of failures from tests on step 6, I'm fairly confident about the coverage of this conversion patch. If there is a breakage, it's likely to be something in one of the arch headers which should be easily discoverable easily on most builds of the specific arch. Signed-off-by: Tejun Heo <tj@kernel.org> Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org> Cc: Ingo Molnar <mingo@redhat.com> Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2032 lines
46 KiB
C
2032 lines
46 KiB
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/slab.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 <mach/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 = 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
|
|
|
|
static inline void
|
|
vnc_mute_spkr(wavnc_info *devc)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&nw_gpio_lock, flags);
|
|
nw_cpld_modify(CPLD_UNMUTE, devc->spkr_mute_state ? 0 : CPLD_UNMUTE);
|
|
spin_unlock_irqrestore(&nw_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");
|