Release 4.7 sound/oss/waveartist.c

/*
 * linux/sound/oss/waveartist.c
 *
 * The low level driver for the RWA010 Rockwell Wave Artist
 * codec chip used in the Rebel.com NetWinder.
 *
 * Cleaned up and integrated into 2.1 by Russell King (rmk@arm.linux.org.uk)
 * and Pat Beirne (patb@corel.ca)
 *
 *
 * Copyright (C) by Rebel.com 1998-1999
 *
 * RWA010 specs received under NDA from Rockwell
 *
 * Copyright (C) by Hannu Savolainen 1993-1997
 *
 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
 * Version 2 (June 1991). See the "COPYING" file distributed with this software
 * for more info.
 *
 * Changes:
 * 11-10-2000   Bartlomiej Zolnierkiewicz <bkz@linux-ide.org>
 *              Added __init to waveartist_init()
 */

/* Debugging */

#define DEBUG_CMD	1

#define DEBUG_OUT	2

#define DEBUG_IN	4

#define DEBUG_INTR	8

#define DEBUG_MIXER	16

#define DEBUG_TRIGGER	32


#define debug_flg (0)

#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/spinlock.h>
#include <linux/bitops.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               */
};


struct wavnc_info {
	
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
};

/*
 * 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)(struct wavnc_info *, unsigned int,
					unsigned char *, unsigned char *);
	
int		(*decode_mixer)(struct wavnc_info *, int,
					unsigned char, unsigned char);
	
int		(*get_mixer)(struct wavnc_info *, int);
};


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


static int		nr_waveartist_devs;

static struct 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(struct 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
49
100.00%
2
100.00%
Total
49
100.00%
2
100.00%

/* Toggle IRQ acknowledge line
 */

static inline void

waveartist_iack(struct 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
52
98.11%
3
75.00%
himangi saraogi
himangi saraogi
1
1.89%
1
25.00%
Total
53
100.00%
4
100.00%


static inline int

waveartist_sleep(int timeout_ms)
{
	unsigned int timeout = msecs_to_jiffies(timeout_ms*100);
	return schedule_timeout_interruptible(timeout);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
21
77.78%
3
60.00%
vasiliy kulikov
vasiliy kulikov
5
18.52%
1
20.00%
linus torvalds
linus torvalds
1
3.70%
1
20.00%
Total
27
100.00%
5
100.00%


static int

waveartist_reset(struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
147
99.32%
4
80.00%
himangi saraogi
himangi saraogi
1
0.68%
1
20.00%
Total
148
100.00%
5
100.00%

/* 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(struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
324
99.69%
3
75.00%
himangi saraogi
himangi saraogi
1
0.31%
1
25.00%
Total
325
100.00%
4
100.00%

/*
 * Send one command word
 */

static inline int

waveartist_cmd1(struct wavnc_info *devc, unsigned int cmd)
{
	return waveartist_cmd(devc, 1, &cmd, 0, NULL);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
30
96.77%
3
75.00%
himangi saraogi
himangi saraogi
1
3.23%
1
25.00%
Total
31
100.00%
4
100.00%

/*
 * Send one command, receive one word
 */

static inline unsigned int

waveartist_cmd1_r(struct wavnc_info *devc, unsigned int cmd)
{
	unsigned int ret;

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

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
38
97.44%
2
66.67%
himangi saraogi
himangi saraogi
1
2.56%
1
33.33%
Total
39
100.00%
3
100.00%

/*
 * Send a double command, receive one
 * word (and throw it away)
 */

static inline int

waveartist_cmd2(struct 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
54
98.18%
1
50.00%
himangi saraogi
himangi saraogi
1
1.82%
1
50.00%
Total
55
100.00%
2
100.00%

/*
 * Send a triple command
 */

static inline int

waveartist_cmd3(struct 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
65
98.48%
1
50.00%
himangi saraogi
himangi saraogi
1
1.52%
1
50.00%
Total
66
100.00%
2
100.00%


static int

waveartist_getrev(struct 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];
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
78
98.73%
1
50.00%
himangi saraogi
himangi saraogi
1
1.27%
1
50.00%
Total
79
100.00%
2
100.00%

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)
{
	struct wavnc_info	*devc;
	struct wavnc_port_info	*portc;
	unsigned long	flags;

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

	devc  = (struct wavnc_info *) audio_devs[dev]->devc;
	portc = (struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
160
97.56%
3
75.00%
himangi saraogi
himangi saraogi
4
2.44%
1
25.00%
Total
164
100.00%
4
100.00%


static void

waveartist_close(int dev)
{
	struct wavnc_info	*devc = (struct wavnc_info *)
					audio_devs[dev]->devc;
	struct wavnc_port_info	*portc = (struct 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
85
95.51%
3
75.00%
himangi saraogi
himangi saraogi
4
4.49%
1
25.00%
Total
89
100.00%
4
100.00%


static void

waveartist_output_block(int dev, unsigned long buf, int __count, int intrflag)
{
	struct wavnc_port_info	*portc = (struct wavnc_port_info *)
					 audio_devs[dev]->portc;
	struct wavnc_info	*devc = (struct 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
180
97.83%
3
75.00%
himangi saraogi
himangi saraogi
4
2.17%
1
25.00%
Total
184
100.00%
4
100.00%


static void

waveartist_start_input(int dev, unsigned long buf, int __count, int intrflag)
{
	struct wavnc_port_info *portc = (struct wavnc_port_info *)
					audio_devs[dev]->portc;
	struct wavnc_info	*devc = (struct 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
180
97.83%
3
75.00%
himangi saraogi
himangi saraogi
4
2.17%
1
25.00%
Total
184
100.00%
4
100.00%


static int

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
19
86.36%
3
75.00%
al viro
al viro
3
13.64%
1
25.00%
Total
22
100.00%
4
100.00%


static unsigned int

waveartist_get_speed(struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
92
98.92%
3
75.00%
himangi saraogi
himangi saraogi
1
1.08%
1
25.00%
Total
93
100.00%
4
100.00%


static unsigned int

waveartist_get_bits(struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
49
98.00%
3
75.00%
himangi saraogi
himangi saraogi
1
2.00%
1
25.00%
Total
50
100.00%
4
100.00%


static int

waveartist_prepare_for_input(int dev, int bsize, int bcount)
{
	unsigned long	flags;
	struct wavnc_info	*devc = (struct wavnc_info *)
					audio_devs[dev]->devc;
	struct wavnc_port_info	*portc = (struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
275
98.57%
3
75.00%
himangi saraogi
himangi saraogi
4
1.43%
1
25.00%
Total
279
100.00%
4
100.00%


static int

waveartist_prepare_for_output(int dev, int bsize, int bcount)
{
	unsigned long	flags;
	struct wavnc_info	*devc = (struct wavnc_info *)
					audio_devs[dev]->devc;
	struct wavnc_port_info	*portc = (struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
253
98.44%
3
75.00%
himangi saraogi
himangi saraogi
4
1.56%
1
25.00%
Total
257
100.00%
4
100.00%


static void

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

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

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

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
73
94.81%
3
75.00%
himangi saraogi
himangi saraogi
4
5.19%
1
25.00%
Total
77
100.00%
4
100.00%


static void

waveartist_halt_input(int dev)
{
	struct wavnc_info	*devc = (struct 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
81
97.59%
3
75.00%
himangi saraogi
himangi saraogi
2
2.41%
1
25.00%
Total
83
100.00%
4
100.00%


static void

waveartist_halt_output(int dev)
{
	struct wavnc_info	*devc = (struct 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
80
97.56%
3
75.00%
himangi saraogi
himangi saraogi
2
2.44%
1
25.00%
Total
82
100.00%
4
100.00%


static void

waveartist_trigger(int dev, int state)
{
	struct wavnc_info	*devc = (struct wavnc_info *)
					audio_devs[dev]->devc;
	struct wavnc_port_info	*portc = (struct 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
148
97.37%
3
75.00%
himangi saraogi
himangi saraogi
4
2.63%
1
25.00%
Total
152
100.00%
4
100.00%


static int

waveartist_set_speed(int dev, int arg)
{
	struct wavnc_port_info *portc = (struct 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;

}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
69
97.18%
3
75.00%
himangi saraogi
himangi saraogi
2
2.82%
1
25.00%
Total
71
100.00%
4
100.00%


static short

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

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

	portc->channels = arg;
	return arg;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
51
96.23%
3
75.00%
himangi saraogi
himangi saraogi
2
3.77%
1
25.00%
Total
53
100.00%
4
100.00%


static unsigned int

waveartist_set_bits(int dev, unsigned int arg)
{
	struct wavnc_port_info *portc = (struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
73
97.33%
3
75.00%
himangi saraogi
himangi saraogi
2
2.67%
1
25.00%
Total
75
100.00%
4
100.00%


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)
{
	struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
181
91.41%
3
50.00%
peter waechtler
peter waechtler
12
6.06%
1
16.67%
andrew morton
andrew morton
4
2.02%
1
16.67%
himangi saraogi
himangi saraogi
1
0.51%
1
16.67%
Total
198
100.00%
6
100.00%

/* -------------------------------------------------------------------------
 * 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(struct 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;
		}
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
183
62.03%
1
20.00%
pre-git
pre-git
111
37.63%
3
60.00%
himangi saraogi
himangi saraogi
1
0.34%
1
20.00%
Total
295
100.00%
5
100.00%

/*
 * 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(struct 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
53
74.65%
1
20.00%
pre-git
pre-git
17
23.94%
3
60.00%
himangi saraogi
himangi saraogi
1
1.41%
1
20.00%
Total
71
100.00%
5
100.00%

/*
 * 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(struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
125
98.43%
1
33.33%
himangi saraogi
himangi saraogi
1
0.79%
1
33.33%
pre-git
pre-git
1
0.79%
1
33.33%
Total
127
100.00%
3
100.00%


static int

waveartist_decode_mixer(struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
74
92.50%
1
25.00%
pre-git
pre-git
5
6.25%
2
50.00%
himangi saraogi
himangi saraogi
1
1.25%
1
25.00%
Total
80
100.00%
4
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
19
86.36%
1
33.33%
pre-git
pre-git
2
9.09%
1
33.33%
himangi saraogi
himangi saraogi
1
4.55%
1
33.33%
Total
22
100.00%
3
100.00%


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(struct 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
38
49.35%
1
20.00%
pre-git
pre-git
38
49.35%
3
60.00%
himangi saraogi
himangi saraogi
1
1.30%
1
20.00%
Total
77
100.00%
5
100.00%


static int

waveartist_set_mixer(struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
86
72.27%
1
20.00%
pre-git
pre-git
32
26.89%
3
60.00%
himangi saraogi
himangi saraogi
1
0.84%
1
20.00%
Total
119
100.00%
5
100.00%


static int

waveartist_mixer_ioctl(int dev, unsigned int cmd, void __user * arg)
{
	struct wavnc_info *devc = (struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
252
79.50%
1
16.67%
pre-git
pre-git
58
18.30%
3
50.00%
al viro
al viro
5
1.58%
1
16.67%
himangi saraogi
himangi saraogi
2
0.63%
1
16.67%
Total
317
100.00%
6
100.00%


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


static void

waveartist_mixer_reset(struct 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
80
77.67%
3
60.00%
linus torvalds
linus torvalds
22
21.36%
1
20.00%
himangi saraogi
himangi saraogi
1
0.97%
1
20.00%
Total
103
100.00%
5
100.00%



static int __init waveartist_init(struct wavnc_info *devc)
{
	struct 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(struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
311
69.27%
1
12.50%
pre-git
pre-git
134
29.84%
5
62.50%
himangi saraogi
himangi saraogi
3
0.67%
1
12.50%
robert p. j. day
robert p. j. day
1
0.22%
1
12.50%
Total
449
100.00%
8
100.00%



static int __init probe_waveartist(struct address_info *hw_config)
{
	struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
97
58.79%
1
16.67%
pre-git
pre-git
43
26.06%
3
50.00%
al viro
al viro
24
14.55%
1
16.67%
himangi saraogi
himangi saraogi
1
0.61%
1
16.67%
Total
165
100.00%
6
100.00%


static void __init

attach_waveartist(struct address_info *hw, const struct waveartist_mixer_info *mix)
{
	struct 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()) {
			setup_timer(&vnc_timer, vnc_slider_tick,
				    nr_waveartist_devs);
			mod_timer(&vnc_timer, jiffies);

			vnc_configure_mixer(devc, 0);

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
149
78.01%
1
16.67%
pre-git
pre-git
34
17.80%
3
50.00%
muhammad falak r wani
muhammad falak r wani
7
3.66%
1
16.67%
himangi saraogi
himangi saraogi
1
0.52%
1
16.67%
Total
191
100.00%
6
100.00%



static void __exit unload_waveartist(struct address_info *hw)
{
	struct 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");
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
178
73.25%
1
16.67%
pre-git
pre-git
64
26.34%
4
66.67%
himangi saraogi
himangi saraogi
1
0.41%
1
16.67%
Total
243
100.00%
6
100.00%

#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(struct wavnc_info *devc)
{
	unsigned long flags;

	raw_spin_lock_irqsave(&nw_gpio_lock, flags);
	nw_cpld_modify(CPLD_UNMUTE, devc->spkr_mute_state ? 0 : CPLD_UNMUTE);
	raw_spin_unlock_irqrestore(&nw_gpio_lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
26
57.78%
1
14.29%
pre-git
pre-git
13
28.89%
3
42.86%
russell king
russell king
3
6.67%
1
14.29%
arnd bergmann
arnd bergmann
2
4.44%
1
14.29%
himangi saraogi
himangi saraogi
1
2.22%
1
14.29%
Total
45
100.00%
7
100.00%


static void

vnc_mute_lout(struct 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);
		
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
59
76.62%
1
20.00%
pre-git
pre-git
17
22.08%
3
60.00%
himangi saraogi
himangi saraogi
1
1.30%
1
20.00%
Total
77
100.00%
5
100.00%


static int

vnc_volume_slider(struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
134
78.36%
1
16.67%
pre-git
pre-git
28
16.37%
3
50.00%
peter waechtler
peter waechtler
8
4.68%
1
16.67%
himangi saraogi
himangi saraogi
1
0.58%
1
16.67%
Total
171
100.00%
6
100.00%

/*
 * 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(struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
127
70.95%
1
16.67%
pre-git
pre-git
51
28.49%
4
66.67%
himangi saraogi
himangi saraogi
1
0.56%
1
16.67%
Total
179
100.00%
6
100.00%


static int

netwinder_decode_mixer(struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
130
90.28%
1
25.00%
pre-git
pre-git
13
9.03%
2
50.00%
himangi saraogi
himangi saraogi
1
0.69%
1
25.00%
Total
144
100.00%
4
100.00%



static int netwinder_get_mixer(struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus torvalds
linus torvalds
94
77.05%
1
25.00%
pre-git
pre-git
27
22.13%
2
50.00%
himangi saraogi
himangi saraogi
1
0.82%
1
25.00%
Total
122
100.00%
4
100.00%

/*
 * 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(struct 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);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
109
86.51%
3
60.00%
linus torvalds
linus torvalds
16
12.70%
1
20.00%
himangi saraogi
himangi saraogi
1
0.79%
1
20.00%
Total
126
100.00%
5
100.00%


static int

vnc_slider(struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
163
95.88%
3
60.00%
linus torvalds
linus torvalds
6
3.53%
1
20.00%
himangi saraogi
himangi saraogi
1
0.59%
1
20.00%
Total
170
100.00%
5
100.00%


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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
42
100.00%
3
100.00%
Total
42
100.00%
3
100.00%


static int

vnc_private_ioctl(int dev, unsigned int cmd, int __user * arg)
{
	struct wavnc_info *devc = (struct 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
653
88.72%
3
50.00%
linus torvalds
linus torvalds
78
10.60%
1
16.67%
al viro
al viro
3
0.41%
1
16.67%
himangi saraogi
himangi saraogi
2
0.27%
1
16.67%
Total
736
100.00%
6
100.00%

#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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
86
75.44%
3
75.00%
linus torvalds
linus torvalds
28
24.56%
1
25.00%
Total
114
100.00%
4
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
19
100.00%
2
100.00%
Total
19
100.00%
2
100.00%


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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
62
98.41%
1
50.00%
linus torvalds
linus torvalds
1
1.59%
1
50.00%
Total
63
100.00%
2
100.00%

__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");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
5296
62.64%
10
35.71%
linus torvalds
linus torvalds
2905
34.36%
2
7.14%
himangi saraogi
himangi saraogi
87
1.03%
1
3.57%
alan cox
alan cox
62
0.73%
1
3.57%
al viro
al viro
38
0.45%
2
7.14%
peter waechtler
peter waechtler
20
0.24%
1
3.57%
rusty russell
rusty russell
16
0.19%
1
3.57%
muhammad falak r wani
muhammad falak r wani
7
0.08%
1
3.57%
vasiliy kulikov
vasiliy kulikov
5
0.06%
1
3.57%
russell king
russell king
4
0.05%
2
7.14%
thomas gleixner
thomas gleixner
4
0.05%
1
3.57%
andrew morton
andrew morton
4
0.05%
1
3.57%
tejun heo
tejun heo
3
0.04%
1
3.57%
arnd bergmann
arnd bergmann
2
0.02%
1
3.57%
uwe zeisberger
uwe zeisberger
1
0.01%
1
3.57%
robert p. j. day
robert p. j. day
1
0.01%
1
3.57%
Total
8455
100.00%
28
100.00%
  
Directory: sound/oss

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.