09417379be
Checking a pointer for NULL before calling kfree() on it is redundant, kfree() deals with NULL pointers just fine. This patch removes such checks from sound/ This patch also makes another, but closely related, change. It avoids casting pointers about to be kfree()'ed. Signed-off-by: Jesper Juhl <juhl-lkml@dif.dk> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
3832 lines
106 KiB
C
3832 lines
106 KiB
C
/*****************************************************************************
|
|
*
|
|
* ESS Maestro/Maestro-2/Maestro-2E driver for Linux 2.[23].x
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
* (c) Copyright 1999 Alan Cox <alan.cox@linux.org>
|
|
*
|
|
* Based heavily on SonicVibes.c:
|
|
* Copyright (C) 1998-1999 Thomas Sailer (sailer@ife.ee.ethz.ch)
|
|
*
|
|
* Heavily modified by Zach Brown <zab@zabbo.net> based on lunch
|
|
* with ESS engineers. Many thanks to Howard Kim for providing
|
|
* contacts and hardware. Honorable mention goes to Eric
|
|
* Brombaugh for all sorts of things. Best regards to the
|
|
* proprietors of Hack Central for fine lodging.
|
|
*
|
|
* Supported devices:
|
|
* /dev/dsp0-3 standard /dev/dsp device, (mostly) OSS compatible
|
|
* /dev/mixer standard /dev/mixer device, (mostly) OSS compatible
|
|
*
|
|
* Hardware Description
|
|
*
|
|
* A working Maestro setup contains the Maestro chip wired to a
|
|
* codec or 2. In the Maestro we have the APUs, the ASSP, and the
|
|
* Wavecache. The APUs can be though of as virtual audio routing
|
|
* channels. They can take data from a number of sources and perform
|
|
* basic encodings of the data. The wavecache is a storehouse for
|
|
* PCM data. Typically it deals with PCI and interracts with the
|
|
* APUs. The ASSP is a wacky DSP like device that ESS is loth
|
|
* to release docs on. Thankfully it isn't required on the Maestro
|
|
* until you start doing insane things like FM emulation and surround
|
|
* encoding. The codecs are almost always AC-97 compliant codecs,
|
|
* but it appears that early Maestros may have had PT101 (an ESS
|
|
* part?) wired to them. The only real difference in the Maestro
|
|
* families is external goop like docking capability, memory for
|
|
* the ASSP, and initialization differences.
|
|
*
|
|
* Driver Operation
|
|
*
|
|
* We only drive the APU/Wavecache as typical DACs and drive the
|
|
* mixers in the codecs. There are 64 APUs. We assign 6 to each
|
|
* /dev/dsp? device. 2 channels for output, and 4 channels for
|
|
* input.
|
|
*
|
|
* Each APU can do a number of things, but we only really use
|
|
* 3 basic functions. For playback we use them to convert PCM
|
|
* data fetched over PCI by the wavecahche into analog data that
|
|
* is handed to the codec. One APU for mono, and a pair for stereo.
|
|
* When in stereo, the combination of smarts in the APU and Wavecache
|
|
* decide which wavecache gets the left or right channel.
|
|
*
|
|
* For record we still use the old overly mono system. For each in
|
|
* coming channel the data comes in from the codec, through a 'input'
|
|
* APU, through another rate converter APU, and then into memory via
|
|
* the wavecache and PCI. If its stereo, we mash it back into LRLR in
|
|
* software. The pass between the 2 APUs is supposedly what requires us
|
|
* to have a 512 byte buffer sitting around in wavecache/memory.
|
|
*
|
|
* The wavecache makes our life even more fun. First off, it can
|
|
* only address the first 28 bits of PCI address space, making it
|
|
* useless on quite a few architectures. Secondly, its insane.
|
|
* It claims to fetch from 4 regions of PCI space, each 4 meg in length.
|
|
* But that doesn't really work. You can only use 1 region. So all our
|
|
* allocations have to be in 4meg of each other. Booo. Hiss.
|
|
* So we have a module parameter, dsps_order, that is the order of
|
|
* the number of dsps to provide. All their buffer space is allocated
|
|
* on open time. The sonicvibes OSS routines we inherited really want
|
|
* power of 2 buffers, so we have all those next to each other, then
|
|
* 512 byte regions for the recording wavecaches. This ends up
|
|
* wasting quite a bit of memory. The only fixes I can see would be
|
|
* getting a kernel allocator that could work in zones, or figuring out
|
|
* just how to coerce the WP into doing what we want.
|
|
*
|
|
* The indirection of the various registers means we have to spinlock
|
|
* nearly all register accesses. We have the main register indirection
|
|
* like the wave cache, maestro registers, etc. Then we have beasts
|
|
* like the APU interface that is indirect registers gotten at through
|
|
* the main maestro indirection. Ouch. We spinlock around the actual
|
|
* ports on a per card basis. This means spinlock activity at each IO
|
|
* operation, but the only IO operation clusters are in non critical
|
|
* paths and it makes the code far easier to follow. Interrupts are
|
|
* blocked while holding the locks because the int handler has to
|
|
* get at some of them :(. The mixer interface doesn't, however.
|
|
* We also have an OSS state lock that is thrown around in a few
|
|
* places.
|
|
*
|
|
* This driver has brute force APM suspend support. We catch suspend
|
|
* notifications and stop all work being done on the chip. Any people
|
|
* that try between this shutdown and the real suspend operation will
|
|
* be put to sleep. When we resume we restore our software state on
|
|
* the chip and wake up the people that were using it. The code thats
|
|
* being used now is quite dirty and assumes we're on a uni-processor
|
|
* machine. Much of it will need to be cleaned up for SMP ACPI or
|
|
* similar.
|
|
*
|
|
* We also pay attention to PCI power management now. The driver
|
|
* will power down units of the chip that it knows aren't needed.
|
|
* The WaveProcessor and company are only powered on when people
|
|
* have /dev/dsp*s open. On removal the driver will
|
|
* power down the maestro entirely. There could still be
|
|
* trouble with BIOSen that magically change power states
|
|
* themselves, but we'll see.
|
|
*
|
|
* History
|
|
* v0.15 - May 21 2001 - Marcus Meissner <mm@caldera.de>
|
|
* Ported to Linux 2.4 PCI API. Some clean ups, global devs list
|
|
* removed (now using pci device driver data).
|
|
* PM needs to be polished still. Bumped version.
|
|
* (still kind of v0.14) May 13 2001 - Ben Pfaff <pfaffben@msu.edu>
|
|
* Add support for 978 docking and basic hardware volume control
|
|
* (still kind of v0.14) Nov 23 - Alan Cox <alan@redhat.com>
|
|
* Add clocking= for people with seriously warped hardware
|
|
* (still v0.14) Nov 10 2000 - Bartlomiej Zolnierkiewicz <bkz@linux-ide.org>
|
|
* add __init to maestro_ac97_init() and maestro_install()
|
|
* (still based on v0.14) Mar 29 2000 - Zach Brown <zab@redhat.com>
|
|
* move to 2.3 power management interface, which
|
|
* required hacking some suspend/resume/check paths
|
|
* make static compilation work
|
|
* v0.14 - Jan 28 2000 - Zach Brown <zab@redhat.com>
|
|
* add PCI power management through ACPI regs.
|
|
* we now shut down on machine reboot/halt
|
|
* leave scary PCI config items alone (isa stuff, mostly)
|
|
* enable 1921s, it seems only mine was broke.
|
|
* fix swapped left/right pcm dac. har har.
|
|
* up bob freq, increase buffers, fix pointers at underflow
|
|
* silly compilation problems
|
|
* v0.13 - Nov 18 1999 - Zach Brown <zab@redhat.com>
|
|
* fix nec Versas? man would that be cool.
|
|
* v0.12 - Nov 12 1999 - Zach Brown <zab@redhat.com>
|
|
* brown bag volume max fix..
|
|
* v0.11 - Nov 11 1999 - Zach Brown <zab@redhat.com>
|
|
* use proper stereo apu decoding, mmap/write should work.
|
|
* make volume sliders more useful, tweak rate calculation.
|
|
* fix lame 8bit format reporting bug. duh. apm apu saving buglet also
|
|
* fix maestro 1 clock freq "bug", remove pt101 support
|
|
* v0.10 - Oct 28 1999 - Zach Brown <zab@redhat.com>
|
|
* aha, so, sometimes the WP writes a status word to offset 0
|
|
* from one of the PCMBARs. rearrange allocation accordingly..
|
|
* cheers again to Eric for being a good hacker in investigating this.
|
|
* Jeroen Hoogervorst submits 7500 fix out of nowhere. yay. :)
|
|
* v0.09 - Oct 23 1999 - Zach Brown <zab@redhat.com>
|
|
* added APM support.
|
|
* re-order something such that some 2Es now work. Magic!
|
|
* new codec reset routine. made some codecs come to life.
|
|
* fix clear_advance, sync some control with ESS.
|
|
* now write to all base regs to be paranoid.
|
|
* v0.08 - Oct 20 1999 - Zach Brown <zab@redhat.com>
|
|
* Fix initial buflen bug. I am so smart. also smp compiling..
|
|
* I owe Eric yet another beer: fixed recmask, igain,
|
|
* muting, and adc sync consistency. Go Team.
|
|
* v0.07 - Oct 4 1999 - Zach Brown <zab@redhat.com>
|
|
* tweak adc/dac, formating, and stuff to allow full duplex
|
|
* allocate dsps memory at open() so we can fit in the wavecache window
|
|
* fix wavecache braindamage. again. no more scribbling?
|
|
* fix ess 1921 codec bug on some laptops.
|
|
* fix dumb pci scanning bug
|
|
* started 2.3 cleanup, redid spinlocks, little cleanups
|
|
* v0.06 - Sep 20 1999 - Zach Brown <zab@redhat.com>
|
|
* fix wavecache thinkos. limit to 1 /dev/dsp.
|
|
* eric is wearing his thinking toque this week.
|
|
* spotted apu mode bugs and gain ramping problem
|
|
* don't touch weird mixer regs, make recmask optional
|
|
* fixed igain inversion, defaults for mixers, clean up rec_start
|
|
* make mono recording work.
|
|
* report subsystem stuff, please send reports.
|
|
* littles: parallel out, amp now
|
|
* v0.05 - Sep 17 1999 - Zach Brown <zab@redhat.com>
|
|
* merged and fixed up Eric's initial recording code
|
|
* munged format handling to catch misuse, needs rewrite.
|
|
* revert ring bus init, fixup shared int, add pci busmaster setting
|
|
* fix mixer oss interface, fix mic mute and recmask
|
|
* mask off unsupported mixers, reset with all 1s, modularize defaults
|
|
* make sure bob is running while we need it
|
|
* got rid of device limit, initial minimal apm hooks
|
|
* pull out dead code/includes, only allow multimedia/audio maestros
|
|
* v0.04 - Sep 01 1999 - Zach Brown <zab@redhat.com>
|
|
* copied memory leak fix from sonicvibes driver
|
|
* different ac97 reset, play with 2.0 ac97, simplify ring bus setup
|
|
* bob freq code, region sanity, jitter sync fix; all from Eric
|
|
*
|
|
* TODO
|
|
* fix bob frequency
|
|
* endianness
|
|
* do smart things with ac97 2.0 bits.
|
|
* dual codecs
|
|
* leave 54->61 open
|
|
*
|
|
* it also would be fun to have a mode that would not use pci dma at all
|
|
* but would copy into the wavecache on board memory and use that
|
|
* on architectures that don't like the maestro's pci dma ickiness.
|
|
*/
|
|
|
|
/*****************************************************************************/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/smp_lock.h>
|
|
#include <linux/string.h>
|
|
#include <linux/ctype.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/sound.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/soundcard.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/init.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/poll.h>
|
|
#include <linux/reboot.h>
|
|
#include <linux/bitops.h>
|
|
#include <linux/wait.h>
|
|
|
|
#include <asm/current.h>
|
|
#include <asm/dma.h>
|
|
#include <asm/io.h>
|
|
#include <asm/page.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <linux/pm.h>
|
|
static int maestro_pm_callback(struct pm_dev *dev, pm_request_t rqst, void *d);
|
|
|
|
#include "maestro.h"
|
|
|
|
static struct pci_driver maestro_pci_driver;
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
#define M_DEBUG 1
|
|
|
|
#ifdef M_DEBUG
|
|
static int debug;
|
|
#define M_printk(args...) {if (debug) printk(args);}
|
|
#else
|
|
#define M_printk(x)
|
|
#endif
|
|
|
|
/* we try to setup 2^(dsps_order) /dev/dsp devices */
|
|
static int dsps_order;
|
|
/* whether or not we mess around with power management */
|
|
static int use_pm=2; /* set to 1 for force */
|
|
/* clocking for broken hardware - a few laptops seem to use a 50Khz clock
|
|
ie insmod with clocking=50000 or so */
|
|
|
|
static int clocking=48000;
|
|
|
|
MODULE_AUTHOR("Zach Brown <zab@zabbo.net>, Alan Cox <alan@redhat.com>");
|
|
MODULE_DESCRIPTION("ESS Maestro Driver");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
#ifdef M_DEBUG
|
|
module_param(debug, bool, 0644);
|
|
#endif
|
|
module_param(dsps_order, int, 0);
|
|
module_param(use_pm, int, 0);
|
|
module_param(clocking, int, 0);
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
#define DRIVER_VERSION "0.15"
|
|
|
|
#ifndef PCI_VENDOR_ESS
|
|
#define PCI_VENDOR_ESS 0x125D
|
|
#define PCI_DEVICE_ID_ESS_ESS1968 0x1968 /* Maestro 2 */
|
|
#define PCI_DEVICE_ID_ESS_ESS1978 0x1978 /* Maestro 2E */
|
|
|
|
#define PCI_VENDOR_ESS_OLD 0x1285 /* Platform Tech,
|
|
the people the maestro
|
|
was bought from */
|
|
#define PCI_DEVICE_ID_ESS_ESS0100 0x0100 /* maestro 1 */
|
|
#endif /* PCI_VENDOR_ESS */
|
|
|
|
#define ESS_CHAN_HARD 0x100
|
|
|
|
/* NEC Versas ? */
|
|
#define NEC_VERSA_SUBID1 0x80581033
|
|
#define NEC_VERSA_SUBID2 0x803c1033
|
|
|
|
|
|
/* changed so that I could actually find all the
|
|
references and fix them up. it's a little more readable now. */
|
|
#define ESS_FMT_STEREO 0x01
|
|
#define ESS_FMT_16BIT 0x02
|
|
#define ESS_FMT_MASK 0x03
|
|
#define ESS_DAC_SHIFT 0
|
|
#define ESS_ADC_SHIFT 4
|
|
|
|
#define ESS_STATE_MAGIC 0x125D1968
|
|
#define ESS_CARD_MAGIC 0x19283746
|
|
|
|
#define DAC_RUNNING 1
|
|
#define ADC_RUNNING 2
|
|
|
|
#define MAX_DSP_ORDER 2
|
|
#define MAX_DSPS (1<<MAX_DSP_ORDER)
|
|
#define NR_DSPS (1<<dsps_order)
|
|
#define NR_IDRS 32
|
|
|
|
#define NR_APUS 64
|
|
#define NR_APU_REGS 16
|
|
|
|
/* acpi states */
|
|
enum {
|
|
ACPI_D0=0,
|
|
ACPI_D1,
|
|
ACPI_D2,
|
|
ACPI_D3
|
|
};
|
|
|
|
/* bits in the acpi masks */
|
|
#define ACPI_12MHZ ( 1 << 15)
|
|
#define ACPI_24MHZ ( 1 << 14)
|
|
#define ACPI_978 ( 1 << 13)
|
|
#define ACPI_SPDIF ( 1 << 12)
|
|
#define ACPI_GLUE ( 1 << 11)
|
|
#define ACPI__10 ( 1 << 10) /* reserved */
|
|
#define ACPI_PCIINT ( 1 << 9)
|
|
#define ACPI_HV ( 1 << 8) /* hardware volume */
|
|
#define ACPI_GPIO ( 1 << 7)
|
|
#define ACPI_ASSP ( 1 << 6)
|
|
#define ACPI_SB ( 1 << 5) /* sb emul */
|
|
#define ACPI_FM ( 1 << 4) /* fm emul */
|
|
#define ACPI_RB ( 1 << 3) /* ringbus / aclink */
|
|
#define ACPI_MIDI ( 1 << 2)
|
|
#define ACPI_GP ( 1 << 1) /* game port */
|
|
#define ACPI_WP ( 1 << 0) /* wave processor */
|
|
|
|
#define ACPI_ALL (0xffff)
|
|
#define ACPI_SLEEP (~(ACPI_SPDIF|ACPI_ASSP|ACPI_SB|ACPI_FM| \
|
|
ACPI_MIDI|ACPI_GP|ACPI_WP))
|
|
#define ACPI_NONE (ACPI__10)
|
|
|
|
/* these masks indicate which units we care about at
|
|
which states */
|
|
static u16 acpi_state_mask[] = {
|
|
[ACPI_D0] = ACPI_ALL,
|
|
[ACPI_D1] = ACPI_SLEEP,
|
|
[ACPI_D2] = ACPI_SLEEP,
|
|
[ACPI_D3] = ACPI_NONE
|
|
};
|
|
|
|
static char version[] __devinitdata =
|
|
KERN_INFO "maestro: version " DRIVER_VERSION " time " __TIME__ " " __DATE__ "\n";
|
|
|
|
|
|
|
|
static const unsigned sample_size[] = { 1, 2, 2, 4 };
|
|
static const unsigned sample_shift[] = { 0, 1, 1, 2 };
|
|
|
|
enum card_types_t {
|
|
TYPE_MAESTRO,
|
|
TYPE_MAESTRO2,
|
|
TYPE_MAESTRO2E
|
|
};
|
|
|
|
static const char *card_names[]={
|
|
[TYPE_MAESTRO] = "ESS Maestro",
|
|
[TYPE_MAESTRO2] = "ESS Maestro 2",
|
|
[TYPE_MAESTRO2E] = "ESS Maestro 2E"
|
|
};
|
|
|
|
static int clock_freq[]={
|
|
[TYPE_MAESTRO] = (49152000L / 1024L),
|
|
[TYPE_MAESTRO2] = (50000000L / 1024L),
|
|
[TYPE_MAESTRO2E] = (50000000L / 1024L)
|
|
};
|
|
|
|
static int maestro_notifier(struct notifier_block *nb, unsigned long event, void *buf);
|
|
|
|
static struct notifier_block maestro_nb = {maestro_notifier, NULL, 0};
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
struct ess_state {
|
|
unsigned int magic;
|
|
/* FIXME: we probably want submixers in here, but only one record pair */
|
|
u8 apu[6]; /* l/r output, l/r intput converters, l/r input apus */
|
|
u8 apu_mode[6]; /* Running mode for this APU */
|
|
u8 apu_pan[6]; /* Panning setup for this APU */
|
|
u32 apu_base[6]; /* base address for this apu */
|
|
struct ess_card *card; /* Card info */
|
|
/* wave stuff */
|
|
unsigned int rateadc, ratedac;
|
|
unsigned char fmt, enable;
|
|
|
|
int index;
|
|
|
|
/* this locks around the oss state in the driver */
|
|
spinlock_t lock;
|
|
/* only let 1 be opening at a time */
|
|
struct semaphore open_sem;
|
|
wait_queue_head_t open_wait;
|
|
mode_t open_mode;
|
|
|
|
/* soundcore stuff */
|
|
int dev_audio;
|
|
|
|
struct dmabuf {
|
|
void *rawbuf;
|
|
unsigned buforder;
|
|
unsigned numfrag;
|
|
unsigned fragshift;
|
|
/* XXX zab - swptr only in here so that it can be referenced by
|
|
clear_advance, as far as I can tell :( */
|
|
unsigned hwptr, swptr;
|
|
unsigned total_bytes;
|
|
int count;
|
|
unsigned error; /* over/underrun */
|
|
wait_queue_head_t wait;
|
|
/* redundant, but makes calculations easier */
|
|
unsigned fragsize;
|
|
unsigned dmasize;
|
|
unsigned fragsamples;
|
|
/* OSS stuff */
|
|
unsigned mapped:1;
|
|
unsigned ready:1; /* our oss buffers are ready to go */
|
|
unsigned endcleared:1;
|
|
unsigned ossfragshift;
|
|
int ossmaxfrags;
|
|
unsigned subdivision;
|
|
u16 base; /* Offset for ptr */
|
|
} dma_dac, dma_adc;
|
|
|
|
/* pointer to each dsp?s piece of the apu->src buffer page */
|
|
void *mixbuf;
|
|
|
|
};
|
|
|
|
struct ess_card {
|
|
unsigned int magic;
|
|
|
|
/* We keep maestro cards in a linked list */
|
|
struct ess_card *next;
|
|
|
|
int dev_mixer;
|
|
|
|
int card_type;
|
|
|
|
/* as most of this is static,
|
|
perhaps it should be a pointer to a global struct */
|
|
struct mixer_goo {
|
|
int modcnt;
|
|
int supported_mixers;
|
|
int stereo_mixers;
|
|
int record_sources;
|
|
/* the caller must guarantee arg sanity before calling these */
|
|
/* int (*read_mixer)(struct ess_card *card, int index);*/
|
|
void (*write_mixer)(struct ess_card *card,int mixer, unsigned int left,unsigned int right);
|
|
int (*recmask_io)(struct ess_card *card,int rw,int mask);
|
|
unsigned int mixer_state[SOUND_MIXER_NRDEVICES];
|
|
} mix;
|
|
|
|
int power_regs;
|
|
|
|
int in_suspend;
|
|
wait_queue_head_t suspend_queue;
|
|
|
|
struct ess_state channels[MAX_DSPS];
|
|
u16 maestro_map[NR_IDRS]; /* Register map */
|
|
/* we have to store this junk so that we can come back from a
|
|
suspend */
|
|
u16 apu_map[NR_APUS][NR_APU_REGS]; /* contents of apu regs */
|
|
|
|
/* this locks around the physical registers on the card */
|
|
spinlock_t lock;
|
|
|
|
/* memory for this card.. wavecache limited :(*/
|
|
void *dmapages;
|
|
int dmaorder;
|
|
|
|
/* hardware resources */
|
|
struct pci_dev *pcidev;
|
|
u32 iobase;
|
|
u32 irq;
|
|
|
|
int bob_freq;
|
|
char dsps_open;
|
|
|
|
int dock_mute_vol;
|
|
};
|
|
|
|
static void set_mixer(struct ess_card *card,unsigned int mixer, unsigned int val );
|
|
|
|
static unsigned
|
|
ld2(unsigned int x)
|
|
{
|
|
unsigned r = 0;
|
|
|
|
if (x >= 0x10000) {
|
|
x >>= 16;
|
|
r += 16;
|
|
}
|
|
if (x >= 0x100) {
|
|
x >>= 8;
|
|
r += 8;
|
|
}
|
|
if (x >= 0x10) {
|
|
x >>= 4;
|
|
r += 4;
|
|
}
|
|
if (x >= 4) {
|
|
x >>= 2;
|
|
r += 2;
|
|
}
|
|
if (x >= 2)
|
|
r++;
|
|
return r;
|
|
}
|
|
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
static void check_suspend(struct ess_card *card);
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
|
|
/*
|
|
* ESS Maestro AC97 codec programming interface.
|
|
*/
|
|
|
|
static void maestro_ac97_set(struct ess_card *card, u8 cmd, u16 val)
|
|
{
|
|
int io = card->iobase;
|
|
int i;
|
|
/*
|
|
* Wait for the codec bus to be free
|
|
*/
|
|
|
|
check_suspend(card);
|
|
|
|
for(i=0;i<10000;i++)
|
|
{
|
|
if(!(inb(io+ESS_AC97_INDEX)&1))
|
|
break;
|
|
}
|
|
/*
|
|
* Write the bus
|
|
*/
|
|
outw(val, io+ESS_AC97_DATA);
|
|
mdelay(1);
|
|
outb(cmd, io+ESS_AC97_INDEX);
|
|
mdelay(1);
|
|
}
|
|
|
|
static u16 maestro_ac97_get(struct ess_card *card, u8 cmd)
|
|
{
|
|
int io = card->iobase;
|
|
int sanity=10000;
|
|
u16 data;
|
|
int i;
|
|
|
|
check_suspend(card);
|
|
/*
|
|
* Wait for the codec bus to be free
|
|
*/
|
|
|
|
for(i=0;i<10000;i++)
|
|
{
|
|
if(!(inb(io+ESS_AC97_INDEX)&1))
|
|
break;
|
|
}
|
|
|
|
outb(cmd|0x80, io+ESS_AC97_INDEX);
|
|
mdelay(1);
|
|
|
|
while(inb(io+ESS_AC97_INDEX)&1)
|
|
{
|
|
sanity--;
|
|
if(!sanity)
|
|
{
|
|
printk(KERN_ERR "maestro: ac97 codec timeout reading 0x%x.\n",cmd);
|
|
return 0;
|
|
}
|
|
}
|
|
data=inw(io+ESS_AC97_DATA);
|
|
mdelay(1);
|
|
return data;
|
|
}
|
|
|
|
/* OSS interface to the ac97s.. */
|
|
|
|
#define AC97_STEREO_MASK (SOUND_MASK_VOLUME|\
|
|
SOUND_MASK_PCM|SOUND_MASK_LINE|SOUND_MASK_CD|\
|
|
SOUND_MASK_VIDEO|SOUND_MASK_LINE1|SOUND_MASK_IGAIN)
|
|
|
|
#define AC97_SUPPORTED_MASK (AC97_STEREO_MASK | \
|
|
SOUND_MASK_BASS|SOUND_MASK_TREBLE|SOUND_MASK_MIC|\
|
|
SOUND_MASK_SPEAKER)
|
|
|
|
#define AC97_RECORD_MASK (SOUND_MASK_MIC|\
|
|
SOUND_MASK_CD| SOUND_MASK_VIDEO| SOUND_MASK_LINE1| SOUND_MASK_LINE|\
|
|
SOUND_MASK_PHONEIN)
|
|
|
|
#define supported_mixer(CARD,FOO) ( CARD->mix.supported_mixers & (1<<FOO) )
|
|
|
|
/* this table has default mixer values for all OSS mixers.
|
|
be sure to fill it in if you add oss mixers
|
|
to anyone's supported mixer defines */
|
|
|
|
static unsigned int mixer_defaults[SOUND_MIXER_NRDEVICES] = {
|
|
[SOUND_MIXER_VOLUME] = 0x3232,
|
|
[SOUND_MIXER_BASS] = 0x3232,
|
|
[SOUND_MIXER_TREBLE] = 0x3232,
|
|
[SOUND_MIXER_SPEAKER] = 0x3232,
|
|
[SOUND_MIXER_MIC] = 0x8000, /* annoying */
|
|
[SOUND_MIXER_LINE] = 0x3232,
|
|
[SOUND_MIXER_CD] = 0x3232,
|
|
[SOUND_MIXER_VIDEO] = 0x3232,
|
|
[SOUND_MIXER_LINE1] = 0x3232,
|
|
[SOUND_MIXER_PCM] = 0x3232,
|
|
[SOUND_MIXER_IGAIN] = 0x3232
|
|
};
|
|
|
|
static struct ac97_mixer_hw {
|
|
unsigned char offset;
|
|
int scale;
|
|
} ac97_hw[SOUND_MIXER_NRDEVICES]= {
|
|
[SOUND_MIXER_VOLUME] = {0x02,63},
|
|
[SOUND_MIXER_BASS] = {0x08,15},
|
|
[SOUND_MIXER_TREBLE] = {0x08,15},
|
|
[SOUND_MIXER_SPEAKER] = {0x0a,15},
|
|
[SOUND_MIXER_MIC] = {0x0e,31},
|
|
[SOUND_MIXER_LINE] = {0x10,31},
|
|
[SOUND_MIXER_CD] = {0x12,31},
|
|
[SOUND_MIXER_VIDEO] = {0x14,31},
|
|
[SOUND_MIXER_LINE1] = {0x16,31},
|
|
[SOUND_MIXER_PCM] = {0x18,31},
|
|
[SOUND_MIXER_IGAIN] = {0x1c,15}
|
|
};
|
|
|
|
#if 0 /* *shrug* removed simply because we never used it.
|
|
feel free to implement again if needed */
|
|
|
|
/* reads the given OSS mixer from the ac97
|
|
the caller must have insured that the ac97 knows
|
|
about that given mixer, and should be holding a
|
|
spinlock for the card */
|
|
static int ac97_read_mixer(struct ess_card *card, int mixer)
|
|
{
|
|
u16 val;
|
|
int ret=0;
|
|
struct ac97_mixer_hw *mh = &ac97_hw[mixer];
|
|
|
|
val = maestro_ac97_get(card, mh->offset);
|
|
|
|
if(AC97_STEREO_MASK & (1<<mixer)) {
|
|
/* nice stereo mixers .. */
|
|
int left,right;
|
|
|
|
left = (val >> 8) & 0x7f;
|
|
right = val & 0x7f;
|
|
|
|
if (mixer == SOUND_MIXER_IGAIN) {
|
|
right = (right * 100) / mh->scale;
|
|
left = (left * 100) / mh->scale;
|
|
} else {
|
|
right = 100 - ((right * 100) / mh->scale);
|
|
left = 100 - ((left * 100) / mh->scale);
|
|
}
|
|
|
|
ret = left | (right << 8);
|
|
} else if (mixer == SOUND_MIXER_SPEAKER) {
|
|
ret = 100 - ((((val & 0x1e)>>1) * 100) / mh->scale);
|
|
} else if (mixer == SOUND_MIXER_MIC) {
|
|
ret = 100 - (((val & 0x1f) * 100) / mh->scale);
|
|
/* the low bit is optional in the tone sliders and masking
|
|
it lets is avoid the 0xf 'bypass'.. */
|
|
} else if (mixer == SOUND_MIXER_BASS) {
|
|
ret = 100 - ((((val >> 8) & 0xe) * 100) / mh->scale);
|
|
} else if (mixer == SOUND_MIXER_TREBLE) {
|
|
ret = 100 - (((val & 0xe) * 100) / mh->scale);
|
|
}
|
|
|
|
M_printk("read mixer %d (0x%x) %x -> %x\n",mixer,mh->offset,val,ret);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/* write the OSS encoded volume to the given OSS encoded mixer,
|
|
again caller's job to make sure all is well in arg land,
|
|
call with spinlock held */
|
|
|
|
/* linear scale -> log */
|
|
static unsigned char lin2log[101] =
|
|
{
|
|
0, 0 , 15 , 23 , 30 , 34 , 38 , 42 , 45 , 47 ,
|
|
50 , 52 , 53 , 55 , 57 , 58 , 60 , 61 , 62 ,
|
|
63 , 65 , 66 , 67 , 68 , 69 , 69 , 70 , 71 ,
|
|
72 , 73 , 73 , 74 , 75 , 75 , 76 , 77 , 77 ,
|
|
78 , 78 , 79 , 80 , 80 , 81 , 81 , 82 , 82 ,
|
|
83 , 83 , 84 , 84 , 84 , 85 , 85 , 86 , 86 ,
|
|
87 , 87 , 87 , 88 , 88 , 88 , 89 , 89 , 89 ,
|
|
90 , 90 , 90 , 91 , 91 , 91 , 92 , 92 , 92 ,
|
|
93 , 93 , 93 , 94 , 94 , 94 , 94 , 95 , 95 ,
|
|
95 , 95 , 96 , 96 , 96 , 96 , 97 , 97 , 97 ,
|
|
97 , 98 , 98 , 98 , 98 , 99 , 99 , 99 , 99 , 99
|
|
};
|
|
|
|
static void ac97_write_mixer(struct ess_card *card,int mixer, unsigned int left, unsigned int right)
|
|
{
|
|
u16 val=0;
|
|
struct ac97_mixer_hw *mh = &ac97_hw[mixer];
|
|
|
|
M_printk("wrote mixer %d (0x%x) %d,%d",mixer,mh->offset,left,right);
|
|
|
|
if(AC97_STEREO_MASK & (1<<mixer)) {
|
|
/* stereo mixers, mute them if we can */
|
|
|
|
if (mixer == SOUND_MIXER_IGAIN) {
|
|
/* igain's slider is reversed.. */
|
|
right = (right * mh->scale) / 100;
|
|
left = (left * mh->scale) / 100;
|
|
if ((left == 0) && (right == 0))
|
|
val |= 0x8000;
|
|
} else if (mixer == SOUND_MIXER_PCM || mixer == SOUND_MIXER_CD) {
|
|
/* log conversion seems bad for them */
|
|
if ((left == 0) && (right == 0))
|
|
val = 0x8000;
|
|
right = ((100 - right) * mh->scale) / 100;
|
|
left = ((100 - left) * mh->scale) / 100;
|
|
} else {
|
|
/* log conversion for the stereo controls */
|
|
if((left == 0) && (right == 0))
|
|
val = 0x8000;
|
|
right = ((100 - lin2log[right]) * mh->scale) / 100;
|
|
left = ((100 - lin2log[left]) * mh->scale) / 100;
|
|
}
|
|
|
|
val |= (left << 8) | right;
|
|
|
|
} else if (mixer == SOUND_MIXER_SPEAKER) {
|
|
val = (((100 - left) * mh->scale) / 100) << 1;
|
|
} else if (mixer == SOUND_MIXER_MIC) {
|
|
val = maestro_ac97_get(card, mh->offset) & ~0x801f;
|
|
val |= (((100 - left) * mh->scale) / 100);
|
|
/* the low bit is optional in the tone sliders and masking
|
|
it lets is avoid the 0xf 'bypass'.. */
|
|
} else if (mixer == SOUND_MIXER_BASS) {
|
|
val = maestro_ac97_get(card , mh->offset) & ~0x0f00;
|
|
val |= ((((100 - left) * mh->scale) / 100) << 8) & 0x0e00;
|
|
} else if (mixer == SOUND_MIXER_TREBLE) {
|
|
val = maestro_ac97_get(card , mh->offset) & ~0x000f;
|
|
val |= (((100 - left) * mh->scale) / 100) & 0x000e;
|
|
}
|
|
|
|
maestro_ac97_set(card , mh->offset, val);
|
|
|
|
M_printk(" -> %x\n",val);
|
|
}
|
|
|
|
/* the following tables allow us to go from
|
|
OSS <-> ac97 quickly. */
|
|
|
|
enum ac97_recsettings {
|
|
AC97_REC_MIC=0,
|
|
AC97_REC_CD,
|
|
AC97_REC_VIDEO,
|
|
AC97_REC_AUX,
|
|
AC97_REC_LINE,
|
|
AC97_REC_STEREO, /* combination of all enabled outputs.. */
|
|
AC97_REC_MONO, /*.. or the mono equivalent */
|
|
AC97_REC_PHONE
|
|
};
|
|
|
|
static unsigned int ac97_oss_mask[] = {
|
|
[AC97_REC_MIC] = SOUND_MASK_MIC,
|
|
[AC97_REC_CD] = SOUND_MASK_CD,
|
|
[AC97_REC_VIDEO] = SOUND_MASK_VIDEO,
|
|
[AC97_REC_AUX] = SOUND_MASK_LINE1,
|
|
[AC97_REC_LINE] = SOUND_MASK_LINE,
|
|
[AC97_REC_PHONE] = SOUND_MASK_PHONEIN
|
|
};
|
|
|
|
/* indexed by bit position */
|
|
static unsigned int ac97_oss_rm[] = {
|
|
[SOUND_MIXER_MIC] = AC97_REC_MIC,
|
|
[SOUND_MIXER_CD] = AC97_REC_CD,
|
|
[SOUND_MIXER_VIDEO] = AC97_REC_VIDEO,
|
|
[SOUND_MIXER_LINE1] = AC97_REC_AUX,
|
|
[SOUND_MIXER_LINE] = AC97_REC_LINE,
|
|
[SOUND_MIXER_PHONEIN] = AC97_REC_PHONE
|
|
};
|
|
|
|
/* read or write the recmask
|
|
the ac97 can really have left and right recording
|
|
inputs independently set, but OSS doesn't seem to
|
|
want us to express that to the user.
|
|
the caller guarantees that we have a supported bit set,
|
|
and they must be holding the card's spinlock */
|
|
static int
|
|
ac97_recmask_io(struct ess_card *card, int read, int mask)
|
|
{
|
|
unsigned int val = ac97_oss_mask[ maestro_ac97_get(card, 0x1a) & 0x7 ];
|
|
|
|
if (read) return val;
|
|
|
|
/* oss can have many inputs, maestro can't. try
|
|
to pick the 'new' one */
|
|
|
|
if (mask != val) mask &= ~val;
|
|
|
|
val = ffs(mask) - 1;
|
|
val = ac97_oss_rm[val];
|
|
val |= val << 8; /* set both channels */
|
|
|
|
M_printk("maestro: setting ac97 recmask to 0x%x\n",val);
|
|
|
|
maestro_ac97_set(card,0x1a,val);
|
|
|
|
return 0;
|
|
};
|
|
|
|
/*
|
|
* The Maestro can be wired to a standard AC97 compliant codec
|
|
* (see www.intel.com for the pdf's on this), or to a PT101 codec
|
|
* which appears to be the ES1918 (data sheet on the esstech.com.tw site)
|
|
*
|
|
* The PT101 setup is untested.
|
|
*/
|
|
|
|
static u16 __init maestro_ac97_init(struct ess_card *card)
|
|
{
|
|
u16 vend1, vend2, caps;
|
|
|
|
card->mix.supported_mixers = AC97_SUPPORTED_MASK;
|
|
card->mix.stereo_mixers = AC97_STEREO_MASK;
|
|
card->mix.record_sources = AC97_RECORD_MASK;
|
|
/* card->mix.read_mixer = ac97_read_mixer;*/
|
|
card->mix.write_mixer = ac97_write_mixer;
|
|
card->mix.recmask_io = ac97_recmask_io;
|
|
|
|
vend1 = maestro_ac97_get(card, 0x7c);
|
|
vend2 = maestro_ac97_get(card, 0x7e);
|
|
|
|
caps = maestro_ac97_get(card, 0x00);
|
|
|
|
printk(KERN_INFO "maestro: AC97 Codec detected: v: 0x%2x%2x caps: 0x%x pwr: 0x%x\n",
|
|
vend1,vend2,caps,maestro_ac97_get(card,0x26) & 0xf);
|
|
|
|
if (! (caps & 0x4) ) {
|
|
/* no bass/treble nobs */
|
|
card->mix.supported_mixers &= ~(SOUND_MASK_BASS|SOUND_MASK_TREBLE);
|
|
}
|
|
|
|
/* XXX endianness, dork head. */
|
|
/* vendor specifc bits.. */
|
|
switch ((long)(vend1 << 16) | vend2) {
|
|
case 0x545200ff: /* TriTech */
|
|
/* no idea what this does */
|
|
maestro_ac97_set(card,0x2a,0x0001);
|
|
maestro_ac97_set(card,0x2c,0x0000);
|
|
maestro_ac97_set(card,0x2c,0xffff);
|
|
break;
|
|
#if 0 /* i thought the problems I was seeing were with
|
|
the 1921, but apparently they were with the pci board
|
|
it was on, so this code is commented out.
|
|
lets see if this holds true. */
|
|
case 0x83847609: /* ESS 1921 */
|
|
/* writing to 0xe (mic) or 0x1a (recmask) seems
|
|
to hang this codec */
|
|
card->mix.supported_mixers &= ~(SOUND_MASK_MIC);
|
|
card->mix.record_sources = 0;
|
|
card->mix.recmask_io = NULL;
|
|
#if 0 /* don't ask. I have yet to see what these actually do. */
|
|
maestro_ac97_set(card,0x76,0xABBA); /* o/~ Take a chance on me o/~ */
|
|
udelay(20);
|
|
maestro_ac97_set(card,0x78,0x3002);
|
|
udelay(20);
|
|
maestro_ac97_set(card,0x78,0x3802);
|
|
udelay(20);
|
|
#endif
|
|
break;
|
|
#endif
|
|
default: break;
|
|
}
|
|
|
|
maestro_ac97_set(card, 0x1E, 0x0404);
|
|
/* null misc stuff */
|
|
maestro_ac97_set(card, 0x20, 0x0000);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if 0 /* there has been 1 person on the planet with a pt101 that we
|
|
know of. If they care, they can put this back in :) */
|
|
static u16 maestro_pt101_init(struct ess_card *card,int iobase)
|
|
{
|
|
printk(KERN_INFO "maestro: PT101 Codec detected, initializing but _not_ installing mixer device.\n");
|
|
/* who knows.. */
|
|
maestro_ac97_set(iobase, 0x2A, 0x0001);
|
|
maestro_ac97_set(iobase, 0x2C, 0x0000);
|
|
maestro_ac97_set(iobase, 0x2C, 0xFFFF);
|
|
maestro_ac97_set(iobase, 0x10, 0x9F1F);
|
|
maestro_ac97_set(iobase, 0x12, 0x0808);
|
|
maestro_ac97_set(iobase, 0x14, 0x9F1F);
|
|
maestro_ac97_set(iobase, 0x16, 0x9F1F);
|
|
maestro_ac97_set(iobase, 0x18, 0x0404);
|
|
maestro_ac97_set(iobase, 0x1A, 0x0000);
|
|
maestro_ac97_set(iobase, 0x1C, 0x0000);
|
|
maestro_ac97_set(iobase, 0x02, 0x0404);
|
|
maestro_ac97_set(iobase, 0x04, 0x0808);
|
|
maestro_ac97_set(iobase, 0x0C, 0x801F);
|
|
maestro_ac97_set(iobase, 0x0E, 0x801F);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
/* this is very magic, and very slow.. */
|
|
static void
|
|
maestro_ac97_reset(int ioaddr, struct pci_dev *pcidev)
|
|
{
|
|
u16 save_68;
|
|
u16 w;
|
|
u32 vend;
|
|
|
|
outw( inw(ioaddr + 0x38) & 0xfffc, ioaddr + 0x38);
|
|
outw( inw(ioaddr + 0x3a) & 0xfffc, ioaddr + 0x3a);
|
|
outw( inw(ioaddr + 0x3c) & 0xfffc, ioaddr + 0x3c);
|
|
|
|
/* reset the first codec */
|
|
outw(0x0000, ioaddr+0x36);
|
|
save_68 = inw(ioaddr+0x68);
|
|
pci_read_config_word(pcidev, 0x58, &w); /* something magical with gpio and bus arb. */
|
|
pci_read_config_dword(pcidev, PCI_SUBSYSTEM_VENDOR_ID, &vend);
|
|
if( w & 0x1)
|
|
save_68 |= 0x10;
|
|
outw(0xfffe, ioaddr + 0x64); /* tickly gpio 0.. */
|
|
outw(0x0001, ioaddr + 0x68);
|
|
outw(0x0000, ioaddr + 0x60);
|
|
udelay(20);
|
|
outw(0x0001, ioaddr + 0x60);
|
|
mdelay(20);
|
|
|
|
outw(save_68 | 0x1, ioaddr + 0x68); /* now restore .. */
|
|
outw( (inw(ioaddr + 0x38) & 0xfffc)|0x1, ioaddr + 0x38);
|
|
outw( (inw(ioaddr + 0x3a) & 0xfffc)|0x1, ioaddr + 0x3a);
|
|
outw( (inw(ioaddr + 0x3c) & 0xfffc)|0x1, ioaddr + 0x3c);
|
|
|
|
/* now the second codec */
|
|
outw(0x0000, ioaddr+0x36);
|
|
outw(0xfff7, ioaddr + 0x64);
|
|
save_68 = inw(ioaddr+0x68);
|
|
outw(0x0009, ioaddr + 0x68);
|
|
outw(0x0001, ioaddr + 0x60);
|
|
udelay(20);
|
|
outw(0x0009, ioaddr + 0x60);
|
|
mdelay(500); /* .. ouch.. */
|
|
outw( inw(ioaddr + 0x38) & 0xfffc, ioaddr + 0x38);
|
|
outw( inw(ioaddr + 0x3a) & 0xfffc, ioaddr + 0x3a);
|
|
outw( inw(ioaddr + 0x3c) & 0xfffc, ioaddr + 0x3c);
|
|
|
|
#if 0 /* the loop here needs to be much better if we want it.. */
|
|
M_printk("trying software reset\n");
|
|
/* try and do a software reset */
|
|
outb(0x80|0x7c, ioaddr + 0x30);
|
|
for (w=0; ; w++) {
|
|
if ((inw(ioaddr+ 0x30) & 1) == 0) {
|
|
if(inb(ioaddr + 0x32) !=0) break;
|
|
|
|
outb(0x80|0x7d, ioaddr + 0x30);
|
|
if (((inw(ioaddr+ 0x30) & 1) == 0) && (inb(ioaddr + 0x32) !=0)) break;
|
|
outb(0x80|0x7f, ioaddr + 0x30);
|
|
if (((inw(ioaddr+ 0x30) & 1) == 0) && (inb(ioaddr + 0x32) !=0)) break;
|
|
}
|
|
|
|
if( w > 10000) {
|
|
outb( inb(ioaddr + 0x37) | 0x08, ioaddr + 0x37); /* do a software reset */
|
|
mdelay(500); /* oh my.. */
|
|
outb( inb(ioaddr + 0x37) & ~0x08, ioaddr + 0x37);
|
|
udelay(1);
|
|
outw( 0x80, ioaddr+0x30);
|
|
for(w = 0 ; w < 10000; w++) {
|
|
if((inw(ioaddr + 0x30) & 1) ==0) break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
if ( vend == NEC_VERSA_SUBID1 || vend == NEC_VERSA_SUBID2) {
|
|
/* turn on external amp? */
|
|
outw(0xf9ff, ioaddr + 0x64);
|
|
outw(inw(ioaddr+0x68) | 0x600, ioaddr + 0x68);
|
|
outw(0x0209, ioaddr + 0x60);
|
|
}
|
|
|
|
/* Turn on the 978 docking chip.
|
|
First frob the "master output enable" bit,
|
|
then set most of the playback volume control registers to max. */
|
|
outb(inb(ioaddr+0xc0)|(1<<5), ioaddr+0xc0);
|
|
outb(0xff, ioaddr+0xc3);
|
|
outb(0xff, ioaddr+0xc4);
|
|
outb(0xff, ioaddr+0xc6);
|
|
outb(0xff, ioaddr+0xc8);
|
|
outb(0x3f, ioaddr+0xcf);
|
|
outb(0x3f, ioaddr+0xd0);
|
|
}
|
|
/*
|
|
* Indirect register access. Not all registers are readable so we
|
|
* need to keep register state ourselves
|
|
*/
|
|
|
|
#define WRITEABLE_MAP 0xEFFFFF
|
|
#define READABLE_MAP 0x64003F
|
|
|
|
/*
|
|
* The Maestro engineers were a little indirection happy. These indirected
|
|
* registers themselves include indirect registers at another layer
|
|
*/
|
|
|
|
static void __maestro_write(struct ess_card *card, u16 reg, u16 data)
|
|
{
|
|
long ioaddr = card->iobase;
|
|
|
|
outw(reg, ioaddr+0x02);
|
|
outw(data, ioaddr+0x00);
|
|
if( reg >= NR_IDRS) printk("maestro: IDR %d out of bounds!\n",reg);
|
|
else card->maestro_map[reg]=data;
|
|
|
|
}
|
|
|
|
static void maestro_write(struct ess_state *s, u16 reg, u16 data)
|
|
{
|
|
unsigned long flags;
|
|
|
|
check_suspend(s->card);
|
|
spin_lock_irqsave(&s->card->lock,flags);
|
|
|
|
__maestro_write(s->card,reg,data);
|
|
|
|
spin_unlock_irqrestore(&s->card->lock,flags);
|
|
}
|
|
|
|
static u16 __maestro_read(struct ess_card *card, u16 reg)
|
|
{
|
|
long ioaddr = card->iobase;
|
|
|
|
outw(reg, ioaddr+0x02);
|
|
return card->maestro_map[reg]=inw(ioaddr+0x00);
|
|
}
|
|
|
|
static u16 maestro_read(struct ess_state *s, u16 reg)
|
|
{
|
|
if(READABLE_MAP & (1<<reg))
|
|
{
|
|
unsigned long flags;
|
|
check_suspend(s->card);
|
|
spin_lock_irqsave(&s->card->lock,flags);
|
|
|
|
__maestro_read(s->card,reg);
|
|
|
|
spin_unlock_irqrestore(&s->card->lock,flags);
|
|
}
|
|
return s->card->maestro_map[reg];
|
|
}
|
|
|
|
/*
|
|
* These routines handle accessing the second level indirections to the
|
|
* wave ram.
|
|
*/
|
|
|
|
/*
|
|
* The register names are the ones ESS uses (see 104T31.ZIP)
|
|
*/
|
|
|
|
#define IDR0_DATA_PORT 0x00
|
|
#define IDR1_CRAM_POINTER 0x01
|
|
#define IDR2_CRAM_DATA 0x02
|
|
#define IDR3_WAVE_DATA 0x03
|
|
#define IDR4_WAVE_PTR_LOW 0x04
|
|
#define IDR5_WAVE_PTR_HI 0x05
|
|
#define IDR6_TIMER_CTRL 0x06
|
|
#define IDR7_WAVE_ROMRAM 0x07
|
|
|
|
static void apu_index_set(struct ess_card *card, u16 index)
|
|
{
|
|
int i;
|
|
__maestro_write(card, IDR1_CRAM_POINTER, index);
|
|
for(i=0;i<1000;i++)
|
|
if(__maestro_read(card, IDR1_CRAM_POINTER)==index)
|
|
return;
|
|
printk(KERN_WARNING "maestro: APU register select failed.\n");
|
|
}
|
|
|
|
static void apu_data_set(struct ess_card *card, u16 data)
|
|
{
|
|
int i;
|
|
for(i=0;i<1000;i++)
|
|
{
|
|
if(__maestro_read(card, IDR0_DATA_PORT)==data)
|
|
return;
|
|
__maestro_write(card, IDR0_DATA_PORT, data);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This is the public interface for APU manipulation. It handles the
|
|
* interlock to avoid two APU writes in parallel etc. Don't diddle
|
|
* directly with the stuff above.
|
|
*/
|
|
|
|
static void apu_set_register(struct ess_state *s, u16 channel, u8 reg, u16 data)
|
|
{
|
|
unsigned long flags;
|
|
|
|
check_suspend(s->card);
|
|
|
|
if(channel&ESS_CHAN_HARD)
|
|
channel&=~ESS_CHAN_HARD;
|
|
else
|
|
{
|
|
if(channel>5)
|
|
printk("BAD CHANNEL %d.\n",channel);
|
|
else
|
|
channel = s->apu[channel];
|
|
/* store based on real hardware apu/reg */
|
|
s->card->apu_map[channel][reg]=data;
|
|
}
|
|
reg|=(channel<<4);
|
|
|
|
/* hooray for double indirection!! */
|
|
spin_lock_irqsave(&s->card->lock,flags);
|
|
|
|
apu_index_set(s->card, reg);
|
|
apu_data_set(s->card, data);
|
|
|
|
spin_unlock_irqrestore(&s->card->lock,flags);
|
|
}
|
|
|
|
static u16 apu_get_register(struct ess_state *s, u16 channel, u8 reg)
|
|
{
|
|
unsigned long flags;
|
|
u16 v;
|
|
|
|
check_suspend(s->card);
|
|
|
|
if(channel&ESS_CHAN_HARD)
|
|
channel&=~ESS_CHAN_HARD;
|
|
else
|
|
channel = s->apu[channel];
|
|
|
|
reg|=(channel<<4);
|
|
|
|
spin_lock_irqsave(&s->card->lock,flags);
|
|
|
|
apu_index_set(s->card, reg);
|
|
v=__maestro_read(s->card, IDR0_DATA_PORT);
|
|
|
|
spin_unlock_irqrestore(&s->card->lock,flags);
|
|
return v;
|
|
}
|
|
|
|
|
|
/*
|
|
* The wavecache buffers between the APUs and
|
|
* pci bus mastering
|
|
*/
|
|
|
|
static void wave_set_register(struct ess_state *s, u16 reg, u16 value)
|
|
{
|
|
long ioaddr = s->card->iobase;
|
|
unsigned long flags;
|
|
check_suspend(s->card);
|
|
|
|
spin_lock_irqsave(&s->card->lock,flags);
|
|
|
|
outw(reg, ioaddr+0x10);
|
|
outw(value, ioaddr+0x12);
|
|
|
|
spin_unlock_irqrestore(&s->card->lock,flags);
|
|
}
|
|
|
|
static u16 wave_get_register(struct ess_state *s, u16 reg)
|
|
{
|
|
long ioaddr = s->card->iobase;
|
|
unsigned long flags;
|
|
u16 value;
|
|
check_suspend(s->card);
|
|
|
|
spin_lock_irqsave(&s->card->lock,flags);
|
|
outw(reg, ioaddr+0x10);
|
|
value=inw(ioaddr+0x12);
|
|
spin_unlock_irqrestore(&s->card->lock,flags);
|
|
|
|
return value;
|
|
}
|
|
|
|
static void sound_reset(int ioaddr)
|
|
{
|
|
outw(0x2000, 0x18+ioaddr);
|
|
udelay(1);
|
|
outw(0x0000, 0x18+ioaddr);
|
|
udelay(1);
|
|
}
|
|
|
|
/* sets the play formats of these apus, should be passed the already shifted format */
|
|
static void set_apu_fmt(struct ess_state *s, int apu, int mode)
|
|
{
|
|
int apu_fmt = 0x10;
|
|
|
|
if(!(mode&ESS_FMT_16BIT)) apu_fmt+=0x20;
|
|
if((mode&ESS_FMT_STEREO)) apu_fmt+=0x10;
|
|
s->apu_mode[apu] = apu_fmt;
|
|
s->apu_mode[apu+1] = apu_fmt;
|
|
}
|
|
|
|
/* this only fixes the output apu mode to be later set by start_dac and
|
|
company. output apu modes are set in ess_rec_setup */
|
|
static void set_fmt(struct ess_state *s, unsigned char mask, unsigned char data)
|
|
{
|
|
s->fmt = (s->fmt & mask) | data;
|
|
set_apu_fmt(s, 0, (s->fmt >> ESS_DAC_SHIFT) & ESS_FMT_MASK);
|
|
}
|
|
|
|
/* this is off by a little bit.. */
|
|
static u32 compute_rate(struct ess_state *s, u32 freq)
|
|
{
|
|
u32 clock = clock_freq[s->card->card_type];
|
|
|
|
freq = (freq * clocking)/48000;
|
|
|
|
if (freq == 48000)
|
|
return 0x10000;
|
|
|
|
return ((freq / clock) <<16 )+
|
|
(((freq % clock) << 16) / clock);
|
|
}
|
|
|
|
static void set_dac_rate(struct ess_state *s, unsigned int rate)
|
|
{
|
|
u32 freq;
|
|
int fmt = (s->fmt >> ESS_DAC_SHIFT) & ESS_FMT_MASK;
|
|
|
|
if (rate > 48000)
|
|
rate = 48000;
|
|
if (rate < 4000)
|
|
rate = 4000;
|
|
|
|
s->ratedac = rate;
|
|
|
|
if(! (fmt & ESS_FMT_16BIT) && !(fmt & ESS_FMT_STEREO))
|
|
rate >>= 1;
|
|
|
|
/* M_printk("computing dac rate %d with mode %d\n",rate,s->fmt);*/
|
|
|
|
freq = compute_rate(s, rate);
|
|
|
|
/* Load the frequency, turn on 6dB */
|
|
apu_set_register(s, 0, 2,(apu_get_register(s, 0, 2)&0x00FF)|
|
|
( ((freq&0xFF)<<8)|0x10 ));
|
|
apu_set_register(s, 0, 3, freq>>8);
|
|
apu_set_register(s, 1, 2,(apu_get_register(s, 1, 2)&0x00FF)|
|
|
( ((freq&0xFF)<<8)|0x10 ));
|
|
apu_set_register(s, 1, 3, freq>>8);
|
|
}
|
|
|
|
static void set_adc_rate(struct ess_state *s, unsigned rate)
|
|
{
|
|
u32 freq;
|
|
|
|
/* Sample Rate conversion APUs don't like 0x10000 for their rate */
|
|
if (rate > 47999)
|
|
rate = 47999;
|
|
if (rate < 4000)
|
|
rate = 4000;
|
|
|
|
s->rateadc = rate;
|
|
|
|
freq = compute_rate(s, rate);
|
|
|
|
/* Load the frequency, turn on 6dB */
|
|
apu_set_register(s, 2, 2,(apu_get_register(s, 2, 2)&0x00FF)|
|
|
( ((freq&0xFF)<<8)|0x10 ));
|
|
apu_set_register(s, 2, 3, freq>>8);
|
|
apu_set_register(s, 3, 2,(apu_get_register(s, 3, 2)&0x00FF)|
|
|
( ((freq&0xFF)<<8)|0x10 ));
|
|
apu_set_register(s, 3, 3, freq>>8);
|
|
|
|
/* fix mixer rate at 48khz. and its _must_ be 0x10000. */
|
|
freq = 0x10000;
|
|
|
|
apu_set_register(s, 4, 2,(apu_get_register(s, 4, 2)&0x00FF)|
|
|
( ((freq&0xFF)<<8)|0x10 ));
|
|
apu_set_register(s, 4, 3, freq>>8);
|
|
apu_set_register(s, 5, 2,(apu_get_register(s, 5, 2)&0x00FF)|
|
|
( ((freq&0xFF)<<8)|0x10 ));
|
|
apu_set_register(s, 5, 3, freq>>8);
|
|
}
|
|
|
|
/* Stop our host of recording apus */
|
|
static inline void stop_adc(struct ess_state *s)
|
|
{
|
|
/* XXX lets hope we don't have to lock around this */
|
|
if (! (s->enable & ADC_RUNNING)) return;
|
|
|
|
s->enable &= ~ADC_RUNNING;
|
|
apu_set_register(s, 2, 0, apu_get_register(s, 2, 0)&0xFF0F);
|
|
apu_set_register(s, 3, 0, apu_get_register(s, 3, 0)&0xFF0F);
|
|
apu_set_register(s, 4, 0, apu_get_register(s, 2, 0)&0xFF0F);
|
|
apu_set_register(s, 5, 0, apu_get_register(s, 3, 0)&0xFF0F);
|
|
}
|
|
|
|
/* stop output apus */
|
|
static void stop_dac(struct ess_state *s)
|
|
{
|
|
/* XXX have to lock around this? */
|
|
if (! (s->enable & DAC_RUNNING)) return;
|
|
|
|
s->enable &= ~DAC_RUNNING;
|
|
apu_set_register(s, 0, 0, apu_get_register(s, 0, 0)&0xFF0F);
|
|
apu_set_register(s, 1, 0, apu_get_register(s, 1, 0)&0xFF0F);
|
|
}
|
|
|
|
static void start_dac(struct ess_state *s)
|
|
{
|
|
/* XXX locks? */
|
|
if ( (s->dma_dac.mapped || s->dma_dac.count > 0) &&
|
|
s->dma_dac.ready &&
|
|
(! (s->enable & DAC_RUNNING)) ) {
|
|
|
|
s->enable |= DAC_RUNNING;
|
|
|
|
apu_set_register(s, 0, 0,
|
|
(apu_get_register(s, 0, 0)&0xFF0F)|s->apu_mode[0]);
|
|
|
|
if((s->fmt >> ESS_DAC_SHIFT) & ESS_FMT_STEREO)
|
|
apu_set_register(s, 1, 0,
|
|
(apu_get_register(s, 1, 0)&0xFF0F)|s->apu_mode[1]);
|
|
}
|
|
}
|
|
|
|
static void start_adc(struct ess_state *s)
|
|
{
|
|
/* XXX locks? */
|
|
if ((s->dma_adc.mapped || s->dma_adc.count < (signed)(s->dma_adc.dmasize - 2*s->dma_adc.fragsize))
|
|
&& s->dma_adc.ready && (! (s->enable & ADC_RUNNING)) ) {
|
|
|
|
s->enable |= ADC_RUNNING;
|
|
apu_set_register(s, 2, 0,
|
|
(apu_get_register(s, 2, 0)&0xFF0F)|s->apu_mode[2]);
|
|
apu_set_register(s, 4, 0,
|
|
(apu_get_register(s, 4, 0)&0xFF0F)|s->apu_mode[4]);
|
|
|
|
if( s->fmt & (ESS_FMT_STEREO << ESS_ADC_SHIFT)) {
|
|
apu_set_register(s, 3, 0,
|
|
(apu_get_register(s, 3, 0)&0xFF0F)|s->apu_mode[3]);
|
|
apu_set_register(s, 5, 0,
|
|
(apu_get_register(s, 5, 0)&0xFF0F)|s->apu_mode[5]);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Native play back driver
|
|
*/
|
|
|
|
/* the mode passed should be already shifted and masked */
|
|
static void
|
|
ess_play_setup(struct ess_state *ess, int mode, u32 rate, void *buffer, int size)
|
|
{
|
|
u32 pa;
|
|
u32 tmpval;
|
|
int high_apu = 0;
|
|
int channel;
|
|
|
|
M_printk("mode=%d rate=%d buf=%p len=%d.\n",
|
|
mode, rate, buffer, size);
|
|
|
|
/* all maestro sizes are in 16bit words */
|
|
size >>=1;
|
|
|
|
if(mode&ESS_FMT_STEREO) {
|
|
high_apu++;
|
|
/* only 16/stereo gets size divided */
|
|
if(mode&ESS_FMT_16BIT)
|
|
size>>=1;
|
|
}
|
|
|
|
for(channel=0; channel <= high_apu; channel++)
|
|
{
|
|
pa = virt_to_bus(buffer);
|
|
|
|
/* set the wavecache control reg */
|
|
tmpval = (pa - 0x10) & 0xFFF8;
|
|
if(!(mode & ESS_FMT_16BIT)) tmpval |= 4;
|
|
if(mode & ESS_FMT_STEREO) tmpval |= 2;
|
|
ess->apu_base[channel]=tmpval;
|
|
wave_set_register(ess, ess->apu[channel]<<3, tmpval);
|
|
|
|
pa -= virt_to_bus(ess->card->dmapages);
|
|
pa>>=1; /* words */
|
|
|
|
/* base offset of dma calcs when reading the pointer
|
|
on the left one */
|
|
if(!channel) ess->dma_dac.base = pa&0xFFFF;
|
|
|
|
pa|=0x00400000; /* System RAM */
|
|
|
|
/* XXX the 16bit here might not be needed.. */
|
|
if((mode & ESS_FMT_STEREO) && (mode & ESS_FMT_16BIT)) {
|
|
if(channel)
|
|
pa|=0x00800000; /* Stereo */
|
|
pa>>=1;
|
|
}
|
|
|
|
/* XXX think about endianess when writing these registers */
|
|
M_printk("maestro: ess_play_setup: APU[%d] pa = 0x%x\n", ess->apu[channel], pa);
|
|
/* start of sample */
|
|
apu_set_register(ess, channel, 4, ((pa>>16)&0xFF)<<8);
|
|
apu_set_register(ess, channel, 5, pa&0xFFFF);
|
|
/* sample end */
|
|
apu_set_register(ess, channel, 6, (pa+size)&0xFFFF);
|
|
/* setting loop len == sample len */
|
|
apu_set_register(ess, channel, 7, size);
|
|
|
|
/* clear effects/env.. */
|
|
apu_set_register(ess, channel, 8, 0x0000);
|
|
/* set amp now to 0xd0 (?), low byte is 'amplitude dest'? */
|
|
apu_set_register(ess, channel, 9, 0xD000);
|
|
|
|
/* clear routing stuff */
|
|
apu_set_register(ess, channel, 11, 0x0000);
|
|
/* dma on, no envelopes, filter to all 1s) */
|
|
apu_set_register(ess, channel, 0, 0x400F);
|
|
|
|
if(mode&ESS_FMT_16BIT)
|
|
ess->apu_mode[channel]=0x10;
|
|
else
|
|
ess->apu_mode[channel]=0x30;
|
|
|
|
if(mode&ESS_FMT_STEREO) {
|
|
/* set panning: left or right */
|
|
apu_set_register(ess, channel, 10, 0x8F00 | (channel ? 0 : 0x10));
|
|
ess->apu_mode[channel] += 0x10;
|
|
} else
|
|
apu_set_register(ess, channel, 10, 0x8F08);
|
|
}
|
|
|
|
/* clear WP interrupts */
|
|
outw(1, ess->card->iobase+0x04);
|
|
/* enable WP ints */
|
|
outw(inw(ess->card->iobase+0x18)|4, ess->card->iobase+0x18);
|
|
|
|
/* go team! */
|
|
set_dac_rate(ess,rate);
|
|
start_dac(ess);
|
|
}
|
|
|
|
/*
|
|
* Native record driver
|
|
*/
|
|
|
|
/* again, passed mode is alrady shifted/masked */
|
|
static void
|
|
ess_rec_setup(struct ess_state *ess, int mode, u32 rate, void *buffer, int size)
|
|
{
|
|
int apu_step = 2;
|
|
int channel;
|
|
|
|
M_printk("maestro: ess_rec_setup: mode=%d rate=%d buf=0x%p len=%d.\n",
|
|
mode, rate, buffer, size);
|
|
|
|
/* all maestro sizes are in 16bit words */
|
|
size >>=1;
|
|
|
|
/* we're given the full size of the buffer, but
|
|
in stereo each channel will only use its half */
|
|
if(mode&ESS_FMT_STEREO) {
|
|
size >>=1;
|
|
apu_step = 1;
|
|
}
|
|
|
|
/* APU assignments: 2 = mono/left SRC
|
|
3 = right SRC
|
|
4 = mono/left Input Mixer
|
|
5 = right Input Mixer */
|
|
for(channel=2;channel<6;channel+=apu_step)
|
|
{
|
|
int i;
|
|
int bsize, route;
|
|
u32 pa;
|
|
u32 tmpval;
|
|
|
|
/* data seems to flow from the codec, through an apu into
|
|
the 'mixbuf' bit of page, then through the SRC apu
|
|
and out to the real 'buffer'. ok. sure. */
|
|
|
|
if(channel & 0x04) {
|
|
/* ok, we're an input mixer going from adc
|
|
through the mixbuf to the other apus */
|
|
|
|
if(!(channel & 0x01)) {
|
|
pa = virt_to_bus(ess->mixbuf);
|
|
} else {
|
|
pa = virt_to_bus(ess->mixbuf + (PAGE_SIZE >> 4));
|
|
}
|
|
|
|
/* we source from a 'magic' apu */
|
|
bsize = PAGE_SIZE >> 5; /* half of this channels alloc, in words */
|
|
route = 0x14 + (channel - 4); /* parallel in crap, see maestro reg 0xC [8-11] */
|
|
ess->apu_mode[channel] = 0x90; /* Input Mixer */
|
|
|
|
} else {
|
|
/* we're a rate converter taking
|
|
input from the input apus and outputing it to
|
|
system memory */
|
|
if(!(channel & 0x01)) {
|
|
pa = virt_to_bus(buffer);
|
|
} else {
|
|
/* right channel records its split half.
|
|
*2 accommodates for rampant shifting earlier */
|
|
pa = virt_to_bus(buffer + size*2);
|
|
}
|
|
|
|
ess->apu_mode[channel] = 0xB0; /* Sample Rate Converter */
|
|
|
|
bsize = size;
|
|
/* get input from inputing apu */
|
|
route = channel + 2;
|
|
}
|
|
|
|
M_printk("maestro: ess_rec_setup: getting pa 0x%x from %d\n",pa,channel);
|
|
|
|
/* set the wavecache control reg */
|
|
tmpval = (pa - 0x10) & 0xFFF8;
|
|
ess->apu_base[channel]=tmpval;
|
|
wave_set_register(ess, ess->apu[channel]<<3, tmpval);
|
|
|
|
pa -= virt_to_bus(ess->card->dmapages);
|
|
pa>>=1; /* words */
|
|
|
|
/* base offset of dma calcs when reading the pointer
|
|
on this left one */
|
|
if(channel==2) ess->dma_adc.base = pa&0xFFFF;
|
|
|
|
pa|=0x00400000; /* bit 22 -> System RAM */
|
|
|
|
M_printk("maestro: ess_rec_setup: APU[%d] pa = 0x%x size = 0x%x route = 0x%x\n",
|
|
ess->apu[channel], pa, bsize, route);
|
|
|
|
/* Begin loading the APU */
|
|
for(i=0;i<15;i++) /* clear all PBRs */
|
|
apu_set_register(ess, channel, i, 0x0000);
|
|
|
|
apu_set_register(ess, channel, 0, 0x400F);
|
|
|
|
/* need to enable subgroups.. and we should probably
|
|
have different groups for different /dev/dsps.. */
|
|
apu_set_register(ess, channel, 2, 0x8);
|
|
|
|
/* Load the buffer into the wave engine */
|
|
apu_set_register(ess, channel, 4, ((pa>>16)&0xFF)<<8);
|
|
/* XXX reg is little endian.. */
|
|
apu_set_register(ess, channel, 5, pa&0xFFFF);
|
|
apu_set_register(ess, channel, 6, (pa+bsize)&0xFFFF);
|
|
apu_set_register(ess, channel, 7, bsize);
|
|
|
|
/* clear effects/env.. */
|
|
apu_set_register(ess, channel, 8, 0x00F0);
|
|
|
|
/* amplitude now? sure. why not. */
|
|
apu_set_register(ess, channel, 9, 0x0000);
|
|
|
|
/* set filter tune, radius, polar pan */
|
|
apu_set_register(ess, channel, 10, 0x8F08);
|
|
|
|
/* route input */
|
|
apu_set_register(ess, channel, 11, route);
|
|
}
|
|
|
|
/* clear WP interrupts */
|
|
outw(1, ess->card->iobase+0x04);
|
|
/* enable WP ints */
|
|
outw(inw(ess->card->iobase+0x18)|4, ess->card->iobase+0x18);
|
|
|
|
/* let 'er rip */
|
|
set_adc_rate(ess,rate);
|
|
start_adc(ess);
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
static void set_dmaa(struct ess_state *s, unsigned int addr, unsigned int count)
|
|
{
|
|
M_printk("set_dmaa??\n");
|
|
}
|
|
|
|
static void set_dmac(struct ess_state *s, unsigned int addr, unsigned int count)
|
|
{
|
|
M_printk("set_dmac??\n");
|
|
}
|
|
|
|
/* Playback pointer */
|
|
static inline unsigned get_dmaa(struct ess_state *s)
|
|
{
|
|
int offset;
|
|
|
|
offset = apu_get_register(s,0,5);
|
|
|
|
/* M_printk("dmaa: offset: %d, base: %d\n",offset,s->dma_dac.base); */
|
|
|
|
offset-=s->dma_dac.base;
|
|
|
|
return (offset&0xFFFE)<<1; /* hardware is in words */
|
|
}
|
|
|
|
/* Record pointer */
|
|
static inline unsigned get_dmac(struct ess_state *s)
|
|
{
|
|
int offset;
|
|
|
|
offset = apu_get_register(s,2,5);
|
|
|
|
/* M_printk("dmac: offset: %d, base: %d\n",offset,s->dma_adc.base); */
|
|
|
|
/* The offset is an address not a position relative to base */
|
|
offset-=s->dma_adc.base;
|
|
|
|
return (offset&0xFFFE)<<1; /* hardware is in words */
|
|
}
|
|
|
|
/*
|
|
* Meet Bob, the timer...
|
|
*/
|
|
|
|
static irqreturn_t ess_interrupt(int irq, void *dev_id, struct pt_regs *regs);
|
|
|
|
static void stop_bob(struct ess_state *s)
|
|
{
|
|
/* Mask IDR 11,17 */
|
|
maestro_write(s, 0x11, maestro_read(s, 0x11)&~1);
|
|
maestro_write(s, 0x17, maestro_read(s, 0x17)&~1);
|
|
}
|
|
|
|
/* eventually we could be clever and limit bob ints
|
|
to the frequency at which our smallest duration
|
|
chunks may expire */
|
|
#define ESS_SYSCLK 50000000
|
|
static void start_bob(struct ess_state *s)
|
|
{
|
|
int prescale;
|
|
int divide;
|
|
|
|
/* XXX make freq selector much smarter, see calc_bob_rate */
|
|
int freq = 200;
|
|
|
|
/* compute ideal interrupt frequency for buffer size & play rate */
|
|
/* first, find best prescaler value to match freq */
|
|
for(prescale=5;prescale<12;prescale++)
|
|
if(freq > (ESS_SYSCLK>>(prescale+9)))
|
|
break;
|
|
|
|
/* next, back off prescaler whilst getting divider into optimum range */
|
|
divide=1;
|
|
while((prescale > 5) && (divide<32))
|
|
{
|
|
prescale--;
|
|
divide <<=1;
|
|
}
|
|
divide>>=1;
|
|
|
|
/* now fine-tune the divider for best match */
|
|
for(;divide<31;divide++)
|
|
if(freq >= ((ESS_SYSCLK>>(prescale+9))/(divide+1)))
|
|
break;
|
|
|
|
/* divide = 0 is illegal, but don't let prescale = 4! */
|
|
if(divide == 0)
|
|
{
|
|
divide++;
|
|
if(prescale>5)
|
|
prescale--;
|
|
}
|
|
|
|
maestro_write(s, 6, 0x9000 | (prescale<<5) | divide); /* set reg */
|
|
|
|
/* Now set IDR 11/17 */
|
|
maestro_write(s, 0x11, maestro_read(s, 0x11)|1);
|
|
maestro_write(s, 0x17, maestro_read(s, 0x17)|1);
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
/* this quickly calculates the frequency needed for bob
|
|
and sets it if its different than what bob is
|
|
currently running at. its called often so
|
|
needs to be fairly quick. */
|
|
#define BOB_MIN 50
|
|
#define BOB_MAX 400
|
|
static void calc_bob_rate(struct ess_state *s) {
|
|
#if 0 /* this thing tries to set the frequency of bob such that
|
|
there are 2 interrupts / buffer walked by the dac/adc. That
|
|
is probably very wrong for people who actually care about
|
|
mid buffer positioning. it should be calculated as bytes/interrupt
|
|
and that needs to be decided :) so for now just use the static 150
|
|
in start_bob.*/
|
|
|
|
unsigned int dac_rate=2,adc_rate=1,newrate;
|
|
static int israte=-1;
|
|
|
|
if (s->dma_dac.fragsize == 0) dac_rate = BOB_MIN;
|
|
else {
|
|
dac_rate = (2 * s->ratedac * sample_size[(s->fmt >> ESS_DAC_SHIFT) & ESS_FMT_MASK]) /
|
|
(s->dma_dac.fragsize) ;
|
|
}
|
|
|
|
if (s->dma_adc.fragsize == 0) adc_rate = BOB_MIN;
|
|
else {
|
|
adc_rate = (2 * s->rateadc * sample_size[(s->fmt >> ESS_DAC_SHIFT) & ESS_FMT_MASK]) /
|
|
(s->dma_adc.fragsize) ;
|
|
}
|
|
|
|
if(dac_rate > adc_rate) newrate = adc_rate;
|
|
else newrate=dac_rate;
|
|
|
|
if(newrate > BOB_MAX) newrate = BOB_MAX;
|
|
else {
|
|
if(newrate < BOB_MIN)
|
|
newrate = BOB_MIN;
|
|
}
|
|
|
|
if( israte != newrate) {
|
|
printk("dac: %d adc: %d rate: %d\n",dac_rate,adc_rate,israte);
|
|
israte=newrate;
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
static int
|
|
prog_dmabuf(struct ess_state *s, unsigned rec)
|
|
{
|
|
struct dmabuf *db = rec ? &s->dma_adc : &s->dma_dac;
|
|
unsigned rate = rec ? s->rateadc : s->ratedac;
|
|
unsigned bytepersec;
|
|
unsigned bufs;
|
|
unsigned char fmt;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
fmt = s->fmt;
|
|
if (rec) {
|
|
stop_adc(s);
|
|
fmt >>= ESS_ADC_SHIFT;
|
|
} else {
|
|
stop_dac(s);
|
|
fmt >>= ESS_DAC_SHIFT;
|
|
}
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
fmt &= ESS_FMT_MASK;
|
|
|
|
db->hwptr = db->swptr = db->total_bytes = db->count = db->error = db->endcleared = 0;
|
|
|
|
/* this algorithm is a little nuts.. where did /1000 come from? */
|
|
bytepersec = rate << sample_shift[fmt];
|
|
bufs = PAGE_SIZE << db->buforder;
|
|
if (db->ossfragshift) {
|
|
if ((1000 << db->ossfragshift) < bytepersec)
|
|
db->fragshift = ld2(bytepersec/1000);
|
|
else
|
|
db->fragshift = db->ossfragshift;
|
|
} else {
|
|
db->fragshift = ld2(bytepersec/100/(db->subdivision ? db->subdivision : 1));
|
|
if (db->fragshift < 3)
|
|
db->fragshift = 3;
|
|
}
|
|
db->numfrag = bufs >> db->fragshift;
|
|
while (db->numfrag < 4 && db->fragshift > 3) {
|
|
db->fragshift--;
|
|
db->numfrag = bufs >> db->fragshift;
|
|
}
|
|
db->fragsize = 1 << db->fragshift;
|
|
if (db->ossmaxfrags >= 4 && db->ossmaxfrags < db->numfrag)
|
|
db->numfrag = db->ossmaxfrags;
|
|
db->fragsamples = db->fragsize >> sample_shift[fmt];
|
|
db->dmasize = db->numfrag << db->fragshift;
|
|
|
|
M_printk("maestro: setup oss: numfrag: %d fragsize: %d dmasize: %d\n",db->numfrag,db->fragsize,db->dmasize);
|
|
|
|
memset(db->rawbuf, (fmt & ESS_FMT_16BIT) ? 0 : 0x80, db->dmasize);
|
|
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
if (rec)
|
|
ess_rec_setup(s, fmt, s->rateadc, db->rawbuf, db->dmasize);
|
|
else
|
|
ess_play_setup(s, fmt, s->ratedac, db->rawbuf, db->dmasize);
|
|
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
db->ready = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static __inline__ void
|
|
clear_advance(struct ess_state *s)
|
|
{
|
|
unsigned char c = ((s->fmt >> ESS_DAC_SHIFT) & ESS_FMT_16BIT) ? 0 : 0x80;
|
|
|
|
unsigned char *buf = s->dma_dac.rawbuf;
|
|
unsigned bsize = s->dma_dac.dmasize;
|
|
unsigned bptr = s->dma_dac.swptr;
|
|
unsigned len = s->dma_dac.fragsize;
|
|
|
|
if (bptr + len > bsize) {
|
|
unsigned x = bsize - bptr;
|
|
memset(buf + bptr, c, x);
|
|
/* account for wrapping? */
|
|
bptr = 0;
|
|
len -= x;
|
|
}
|
|
memset(buf + bptr, c, len);
|
|
}
|
|
|
|
/* call with spinlock held! */
|
|
static void
|
|
ess_update_ptr(struct ess_state *s)
|
|
{
|
|
unsigned hwptr;
|
|
int diff;
|
|
|
|
/* update ADC pointer */
|
|
if (s->dma_adc.ready) {
|
|
/* oh boy should this all be re-written. everything in the current code paths think
|
|
that the various counters/pointers are expressed in bytes to the user but we have
|
|
two apus doing stereo stuff so we fix it up here.. it propagates to all the various
|
|
counters from here. */
|
|
if ( s->fmt & (ESS_FMT_STEREO << ESS_ADC_SHIFT)) {
|
|
hwptr = (get_dmac(s)*2) % s->dma_adc.dmasize;
|
|
} else {
|
|
hwptr = get_dmac(s) % s->dma_adc.dmasize;
|
|
}
|
|
diff = (s->dma_adc.dmasize + hwptr - s->dma_adc.hwptr) % s->dma_adc.dmasize;
|
|
s->dma_adc.hwptr = hwptr;
|
|
s->dma_adc.total_bytes += diff;
|
|
s->dma_adc.count += diff;
|
|
if (s->dma_adc.count >= (signed)s->dma_adc.fragsize)
|
|
wake_up(&s->dma_adc.wait);
|
|
if (!s->dma_adc.mapped) {
|
|
if (s->dma_adc.count > (signed)(s->dma_adc.dmasize - ((3 * s->dma_adc.fragsize) >> 1))) {
|
|
/* FILL ME
|
|
wrindir(s, SV_CIENABLE, s->enable); */
|
|
stop_adc(s);
|
|
/* brute force everyone back in sync, sigh */
|
|
s->dma_adc.count = 0;
|
|
s->dma_adc.swptr = 0;
|
|
s->dma_adc.hwptr = 0;
|
|
s->dma_adc.error++;
|
|
}
|
|
}
|
|
}
|
|
/* update DAC pointer */
|
|
if (s->dma_dac.ready) {
|
|
hwptr = get_dmaa(s) % s->dma_dac.dmasize;
|
|
/* the apu only reports the length it has seen, not the
|
|
length of the memory that has been used (the WP
|
|
knows that) */
|
|
if ( ((s->fmt >> ESS_DAC_SHIFT) & ESS_FMT_MASK) == (ESS_FMT_STEREO|ESS_FMT_16BIT))
|
|
hwptr<<=1;
|
|
|
|
diff = (s->dma_dac.dmasize + hwptr - s->dma_dac.hwptr) % s->dma_dac.dmasize;
|
|
/* M_printk("updating dac: hwptr: %d diff: %d\n",hwptr,diff);*/
|
|
s->dma_dac.hwptr = hwptr;
|
|
s->dma_dac.total_bytes += diff;
|
|
if (s->dma_dac.mapped) {
|
|
s->dma_dac.count += diff;
|
|
if (s->dma_dac.count >= (signed)s->dma_dac.fragsize) {
|
|
wake_up(&s->dma_dac.wait);
|
|
}
|
|
} else {
|
|
s->dma_dac.count -= diff;
|
|
/* M_printk("maestro: ess_update_ptr: diff: %d, count: %d\n", diff, s->dma_dac.count); */
|
|
if (s->dma_dac.count <= 0) {
|
|
M_printk("underflow! diff: %d count: %d hw: %d sw: %d\n", diff, s->dma_dac.count,
|
|
hwptr, s->dma_dac.swptr);
|
|
/* FILL ME
|
|
wrindir(s, SV_CIENABLE, s->enable); */
|
|
/* XXX how on earth can calling this with the lock held work.. */
|
|
stop_dac(s);
|
|
/* brute force everyone back in sync, sigh */
|
|
s->dma_dac.count = 0;
|
|
s->dma_dac.swptr = hwptr;
|
|
s->dma_dac.error++;
|
|
} else if (s->dma_dac.count <= (signed)s->dma_dac.fragsize && !s->dma_dac.endcleared) {
|
|
clear_advance(s);
|
|
s->dma_dac.endcleared = 1;
|
|
}
|
|
if (s->dma_dac.count + (signed)s->dma_dac.fragsize <= (signed)s->dma_dac.dmasize) {
|
|
wake_up(&s->dma_dac.wait);
|
|
/* printk("waking up DAC count: %d sw: %d hw: %d\n",s->dma_dac.count, s->dma_dac.swptr,
|
|
hwptr);*/
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static irqreturn_t
|
|
ess_interrupt(int irq, void *dev_id, struct pt_regs *regs)
|
|
{
|
|
struct ess_state *s;
|
|
struct ess_card *c = (struct ess_card *)dev_id;
|
|
int i;
|
|
u32 event;
|
|
|
|
if ( ! (event = inb(c->iobase+0x1A)) )
|
|
return IRQ_NONE;
|
|
|
|
outw(inw(c->iobase+4)&1, c->iobase+4);
|
|
|
|
/* M_printk("maestro int: %x\n",event);*/
|
|
if(event&(1<<6))
|
|
{
|
|
int x;
|
|
enum {UP_EVT, DOWN_EVT, MUTE_EVT} vol_evt;
|
|
int volume;
|
|
|
|
/* Figure out which volume control button was pushed,
|
|
based on differences from the default register
|
|
values. */
|
|
x = inb(c->iobase+0x1c);
|
|
if (x&1) vol_evt = MUTE_EVT;
|
|
else if (((x>>1)&7) > 4) vol_evt = UP_EVT;
|
|
else vol_evt = DOWN_EVT;
|
|
|
|
/* Reset the volume control registers. */
|
|
outb(0x88, c->iobase+0x1c);
|
|
outb(0x88, c->iobase+0x1d);
|
|
outb(0x88, c->iobase+0x1e);
|
|
outb(0x88, c->iobase+0x1f);
|
|
|
|
/* Deal with the button press in a hammer-handed
|
|
manner by adjusting the master mixer volume. */
|
|
volume = c->mix.mixer_state[0] & 0xff;
|
|
if (vol_evt == UP_EVT) {
|
|
volume += 5;
|
|
if (volume > 100)
|
|
volume = 100;
|
|
}
|
|
else if (vol_evt == DOWN_EVT) {
|
|
volume -= 5;
|
|
if (volume < 0)
|
|
volume = 0;
|
|
} else {
|
|
/* vol_evt == MUTE_EVT */
|
|
if (volume == 0)
|
|
volume = c->dock_mute_vol;
|
|
else {
|
|
c->dock_mute_vol = volume;
|
|
volume = 0;
|
|
}
|
|
}
|
|
set_mixer (c, 0, (volume << 8) | volume);
|
|
}
|
|
|
|
/* Ack all the interrupts. */
|
|
outb(0xFF, c->iobase+0x1A);
|
|
|
|
/*
|
|
* Update the pointers for all APU's we are running.
|
|
*/
|
|
for(i=0;i<NR_DSPS;i++)
|
|
{
|
|
s=&c->channels[i];
|
|
if(s->dev_audio == -1)
|
|
break;
|
|
spin_lock(&s->lock);
|
|
ess_update_ptr(s);
|
|
spin_unlock(&s->lock);
|
|
}
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
static const char invalid_magic[] = KERN_CRIT "maestro: invalid magic value in %s\n";
|
|
|
|
#define VALIDATE_MAGIC(FOO,MAG) \
|
|
({ \
|
|
if (!(FOO) || (FOO)->magic != MAG) { \
|
|
printk(invalid_magic,__FUNCTION__); \
|
|
return -ENXIO; \
|
|
} \
|
|
})
|
|
|
|
#define VALIDATE_STATE(a) VALIDATE_MAGIC(a,ESS_STATE_MAGIC)
|
|
#define VALIDATE_CARD(a) VALIDATE_MAGIC(a,ESS_CARD_MAGIC)
|
|
|
|
static void set_mixer(struct ess_card *card,unsigned int mixer, unsigned int val )
|
|
{
|
|
unsigned int left,right;
|
|
/* cleanse input a little */
|
|
right = ((val >> 8) & 0xff) ;
|
|
left = (val & 0xff) ;
|
|
|
|
if(right > 100) right = 100;
|
|
if(left > 100) left = 100;
|
|
|
|
card->mix.mixer_state[mixer]=(right << 8) | left;
|
|
card->mix.write_mixer(card,mixer,left,right);
|
|
}
|
|
|
|
static void
|
|
mixer_push_state(struct ess_card *card)
|
|
{
|
|
int i;
|
|
for(i = 0 ; i < SOUND_MIXER_NRDEVICES ; i++) {
|
|
if( ! supported_mixer(card,i)) continue;
|
|
|
|
set_mixer(card,i,card->mix.mixer_state[i]);
|
|
}
|
|
}
|
|
|
|
static int mixer_ioctl(struct ess_card *card, unsigned int cmd, unsigned long arg)
|
|
{
|
|
int i, val=0;
|
|
unsigned long flags;
|
|
void __user *argp = (void __user *)arg;
|
|
int __user *p = argp;
|
|
|
|
VALIDATE_CARD(card);
|
|
if (cmd == SOUND_MIXER_INFO) {
|
|
mixer_info info;
|
|
memset(&info, 0, sizeof(info));
|
|
strlcpy(info.id, card_names[card->card_type], sizeof(info.id));
|
|
strlcpy(info.name, card_names[card->card_type], sizeof(info.name));
|
|
info.modify_counter = card->mix.modcnt;
|
|
if (copy_to_user(argp, &info, sizeof(info)))
|
|
return -EFAULT;
|
|
return 0;
|
|
}
|
|
if (cmd == SOUND_OLD_MIXER_INFO) {
|
|
_old_mixer_info info;
|
|
memset(&info, 0, sizeof(info));
|
|
strlcpy(info.id, card_names[card->card_type], sizeof(info.id));
|
|
strlcpy(info.name, card_names[card->card_type], sizeof(info.name));
|
|
if (copy_to_user(argp, &info, sizeof(info)))
|
|
return -EFAULT;
|
|
return 0;
|
|
}
|
|
if (cmd == OSS_GETVERSION)
|
|
return put_user(SOUND_VERSION, p);
|
|
|
|
if (_IOC_TYPE(cmd) != 'M' || _IOC_SIZE(cmd) != sizeof(int))
|
|
return -EINVAL;
|
|
|
|
if (_IOC_DIR(cmd) == _IOC_READ) {
|
|
switch (_IOC_NR(cmd)) {
|
|
case SOUND_MIXER_RECSRC: /* give them the current record source */
|
|
|
|
if(!card->mix.recmask_io) {
|
|
val = 0;
|
|
} else {
|
|
spin_lock_irqsave(&card->lock, flags);
|
|
val = card->mix.recmask_io(card,1,0);
|
|
spin_unlock_irqrestore(&card->lock, flags);
|
|
}
|
|
break;
|
|
|
|
case SOUND_MIXER_DEVMASK: /* give them the supported mixers */
|
|
val = card->mix.supported_mixers;
|
|
break;
|
|
|
|
case SOUND_MIXER_RECMASK: /* Arg contains a bit for each supported recording source */
|
|
val = card->mix.record_sources;
|
|
break;
|
|
|
|
case SOUND_MIXER_STEREODEVS: /* Mixer channels supporting stereo */
|
|
val = card->mix.stereo_mixers;
|
|
break;
|
|
|
|
case SOUND_MIXER_CAPS:
|
|
val = SOUND_CAP_EXCL_INPUT;
|
|
break;
|
|
|
|
default: /* read a specific mixer */
|
|
i = _IOC_NR(cmd);
|
|
|
|
if ( ! supported_mixer(card,i))
|
|
return -EINVAL;
|
|
|
|
/* do we ever want to touch the hardware? */
|
|
/* spin_lock_irqsave(&card->lock, flags);
|
|
val = card->mix.read_mixer(card,i);
|
|
spin_unlock_irqrestore(&card->lock, flags);*/
|
|
|
|
val = card->mix.mixer_state[i];
|
|
/* M_printk("returned 0x%x for mixer %d\n",val,i);*/
|
|
|
|
break;
|
|
}
|
|
return put_user(val, p);
|
|
}
|
|
|
|
if (_IOC_DIR(cmd) != (_IOC_WRITE|_IOC_READ))
|
|
return -EINVAL;
|
|
|
|
card->mix.modcnt++;
|
|
|
|
if (get_user(val, p))
|
|
return -EFAULT;
|
|
|
|
switch (_IOC_NR(cmd)) {
|
|
case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
|
|
|
|
if (!card->mix.recmask_io) return -EINVAL;
|
|
if(!val) return 0;
|
|
if(! (val &= card->mix.record_sources)) return -EINVAL;
|
|
|
|
spin_lock_irqsave(&card->lock, flags);
|
|
card->mix.recmask_io(card,0,val);
|
|
spin_unlock_irqrestore(&card->lock, flags);
|
|
return 0;
|
|
|
|
default:
|
|
i = _IOC_NR(cmd);
|
|
|
|
if ( ! supported_mixer(card,i))
|
|
return -EINVAL;
|
|
|
|
spin_lock_irqsave(&card->lock, flags);
|
|
set_mixer(card,i,val);
|
|
spin_unlock_irqrestore(&card->lock, flags);
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
static int ess_open_mixdev(struct inode *inode, struct file *file)
|
|
{
|
|
unsigned int minor = iminor(inode);
|
|
struct ess_card *card = NULL;
|
|
struct pci_dev *pdev = NULL;
|
|
struct pci_driver *drvr;
|
|
|
|
while ((pdev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, pdev)) != NULL) {
|
|
drvr = pci_dev_driver (pdev);
|
|
if (drvr == &maestro_pci_driver) {
|
|
card = (struct ess_card*)pci_get_drvdata (pdev);
|
|
if (!card)
|
|
continue;
|
|
if (card->dev_mixer == minor)
|
|
break;
|
|
}
|
|
}
|
|
if (!card)
|
|
return -ENODEV;
|
|
file->private_data = card;
|
|
return nonseekable_open(inode, file);
|
|
}
|
|
|
|
static int ess_release_mixdev(struct inode *inode, struct file *file)
|
|
{
|
|
struct ess_card *card = (struct ess_card *)file->private_data;
|
|
|
|
VALIDATE_CARD(card);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ess_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
|
|
{
|
|
struct ess_card *card = (struct ess_card *)file->private_data;
|
|
|
|
VALIDATE_CARD(card);
|
|
|
|
return mixer_ioctl(card, cmd, arg);
|
|
}
|
|
|
|
static /*const*/ struct file_operations ess_mixer_fops = {
|
|
.owner = THIS_MODULE,
|
|
.llseek = no_llseek,
|
|
.ioctl = ess_ioctl_mixdev,
|
|
.open = ess_open_mixdev,
|
|
.release = ess_release_mixdev,
|
|
};
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
static int drain_dac(struct ess_state *s, int nonblock)
|
|
{
|
|
DECLARE_WAITQUEUE(wait,current);
|
|
unsigned long flags;
|
|
int count;
|
|
signed long tmo;
|
|
|
|
if (s->dma_dac.mapped || !s->dma_dac.ready)
|
|
return 0;
|
|
current->state = TASK_INTERRUPTIBLE;
|
|
add_wait_queue(&s->dma_dac.wait, &wait);
|
|
for (;;) {
|
|
/* XXX uhm.. questionable locking*/
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
count = s->dma_dac.count;
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
if (count <= 0)
|
|
break;
|
|
if (signal_pending(current))
|
|
break;
|
|
if (nonblock) {
|
|
remove_wait_queue(&s->dma_dac.wait, &wait);
|
|
current->state = TASK_RUNNING;
|
|
return -EBUSY;
|
|
}
|
|
tmo = (count * HZ) / s->ratedac;
|
|
tmo >>= sample_shift[(s->fmt >> ESS_DAC_SHIFT) & ESS_FMT_MASK];
|
|
/* XXX this is just broken. someone is waking us up alot, or schedule_timeout is broken.
|
|
or something. who cares. - zach */
|
|
if (!schedule_timeout(tmo ? tmo : 1) && tmo)
|
|
M_printk(KERN_DEBUG "maestro: dma timed out?? %ld\n",jiffies);
|
|
}
|
|
remove_wait_queue(&s->dma_dac.wait, &wait);
|
|
current->state = TASK_RUNNING;
|
|
if (signal_pending(current))
|
|
return -ERESTARTSYS;
|
|
return 0;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
/* Zach sez: "god this is gross.." */
|
|
static int
|
|
comb_stereo(unsigned char *real_buffer,unsigned char *tmp_buffer, int offset,
|
|
int count, int bufsize)
|
|
{
|
|
/* No such thing as stereo recording, so we
|
|
use dual input mixers. which means we have to
|
|
combine mono to stereo buffer. yuck.
|
|
|
|
but we don't have to be able to work a byte at a time..*/
|
|
|
|
unsigned char *so,*left,*right;
|
|
int i;
|
|
|
|
so = tmp_buffer;
|
|
left = real_buffer + offset;
|
|
right = real_buffer + bufsize/2 + offset;
|
|
|
|
/* M_printk("comb_stereo writing %d to %p from %p and %p, offset: %d size: %d\n",count/2, tmp_buffer,left,right,offset,bufsize);*/
|
|
|
|
for(i=count/4; i ; i--) {
|
|
(*(so+2)) = *(right++);
|
|
(*(so+3)) = *(right++);
|
|
(*so) = *(left++);
|
|
(*(so+1)) = *(left++);
|
|
so+=4;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* in this loop, dma_adc.count signifies the amount of data thats waiting
|
|
to be copied to the user's buffer. it is filled by the interrupt
|
|
handler and drained by this loop. */
|
|
static ssize_t
|
|
ess_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
|
|
{
|
|
struct ess_state *s = (struct ess_state *)file->private_data;
|
|
ssize_t ret;
|
|
unsigned long flags;
|
|
unsigned swptr;
|
|
int cnt;
|
|
unsigned char *combbuf = NULL;
|
|
|
|
VALIDATE_STATE(s);
|
|
if (s->dma_adc.mapped)
|
|
return -ENXIO;
|
|
if (!s->dma_adc.ready && (ret = prog_dmabuf(s, 1)))
|
|
return ret;
|
|
if (!access_ok(VERIFY_WRITE, buffer, count))
|
|
return -EFAULT;
|
|
if(!(combbuf = kmalloc(count,GFP_KERNEL)))
|
|
return -ENOMEM;
|
|
ret = 0;
|
|
|
|
calc_bob_rate(s);
|
|
|
|
while (count > 0) {
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
/* remember, all these things are expressed in bytes to be
|
|
sent to the user.. hence the evil / 2 down below */
|
|
swptr = s->dma_adc.swptr;
|
|
cnt = s->dma_adc.dmasize-swptr;
|
|
if (s->dma_adc.count < cnt)
|
|
cnt = s->dma_adc.count;
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
|
|
if (cnt > count)
|
|
cnt = count;
|
|
|
|
if ( cnt > 0 ) cnt &= ~3;
|
|
|
|
if (cnt <= 0) {
|
|
start_adc(s);
|
|
if (file->f_flags & O_NONBLOCK)
|
|
{
|
|
ret = ret ? ret : -EAGAIN;
|
|
goto rec_return_free;
|
|
}
|
|
if (!interruptible_sleep_on_timeout(&s->dma_adc.wait, HZ)) {
|
|
if(! s->card->in_suspend) printk(KERN_DEBUG "maestro: read: chip lockup? dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
|
|
s->dma_adc.dmasize, s->dma_adc.fragsize, s->dma_adc.count,
|
|
s->dma_adc.hwptr, s->dma_adc.swptr);
|
|
stop_adc(s);
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
set_dmac(s, virt_to_bus(s->dma_adc.rawbuf), s->dma_adc.numfrag << s->dma_adc.fragshift);
|
|
/* program enhanced mode registers */
|
|
/* FILL ME */
|
|
/* wrindir(s, SV_CIDMACBASECOUNT1, (s->dma_adc.fragsamples-1) >> 8);
|
|
wrindir(s, SV_CIDMACBASECOUNT0, s->dma_adc.fragsamples-1); */
|
|
s->dma_adc.count = s->dma_adc.hwptr = s->dma_adc.swptr = 0;
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
}
|
|
if (signal_pending(current))
|
|
{
|
|
ret = ret ? ret : -ERESTARTSYS;
|
|
goto rec_return_free;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if(s->fmt & (ESS_FMT_STEREO << ESS_ADC_SHIFT)) {
|
|
/* swptr/2 so that we know the real offset in each apu's buffer */
|
|
comb_stereo(s->dma_adc.rawbuf,combbuf,swptr/2,cnt,s->dma_adc.dmasize);
|
|
if (copy_to_user(buffer, combbuf, cnt)) {
|
|
ret = ret ? ret : -EFAULT;
|
|
goto rec_return_free;
|
|
}
|
|
} else {
|
|
if (copy_to_user(buffer, s->dma_adc.rawbuf + swptr, cnt)) {
|
|
ret = ret ? ret : -EFAULT;
|
|
goto rec_return_free;
|
|
}
|
|
}
|
|
|
|
swptr = (swptr + cnt) % s->dma_adc.dmasize;
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
s->dma_adc.swptr = swptr;
|
|
s->dma_adc.count -= cnt;
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
count -= cnt;
|
|
buffer += cnt;
|
|
ret += cnt;
|
|
start_adc(s);
|
|
}
|
|
|
|
rec_return_free:
|
|
kfree(combbuf);
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t
|
|
ess_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
|
|
{
|
|
struct ess_state *s = (struct ess_state *)file->private_data;
|
|
ssize_t ret;
|
|
unsigned long flags;
|
|
unsigned swptr;
|
|
int cnt;
|
|
|
|
VALIDATE_STATE(s);
|
|
if (s->dma_dac.mapped)
|
|
return -ENXIO;
|
|
if (!s->dma_dac.ready && (ret = prog_dmabuf(s, 0)))
|
|
return ret;
|
|
if (!access_ok(VERIFY_READ, buffer, count))
|
|
return -EFAULT;
|
|
ret = 0;
|
|
|
|
calc_bob_rate(s);
|
|
|
|
while (count > 0) {
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
|
|
if (s->dma_dac.count < 0) {
|
|
s->dma_dac.count = 0;
|
|
s->dma_dac.swptr = s->dma_dac.hwptr;
|
|
}
|
|
swptr = s->dma_dac.swptr;
|
|
|
|
cnt = s->dma_dac.dmasize-swptr;
|
|
|
|
if (s->dma_dac.count + cnt > s->dma_dac.dmasize)
|
|
cnt = s->dma_dac.dmasize - s->dma_dac.count;
|
|
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
|
|
if (cnt > count)
|
|
cnt = count;
|
|
|
|
if (cnt <= 0) {
|
|
start_dac(s);
|
|
if (file->f_flags & O_NONBLOCK) {
|
|
if(!ret) ret = -EAGAIN;
|
|
goto return_free;
|
|
}
|
|
if (!interruptible_sleep_on_timeout(&s->dma_dac.wait, HZ)) {
|
|
if(! s->card->in_suspend) printk(KERN_DEBUG "maestro: write: chip lockup? dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
|
|
s->dma_dac.dmasize, s->dma_dac.fragsize, s->dma_dac.count,
|
|
s->dma_dac.hwptr, s->dma_dac.swptr);
|
|
stop_dac(s);
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
set_dmaa(s, virt_to_bus(s->dma_dac.rawbuf), s->dma_dac.numfrag << s->dma_dac.fragshift);
|
|
/* program enhanced mode registers */
|
|
/* wrindir(s, SV_CIDMAABASECOUNT1, (s->dma_dac.fragsamples-1) >> 8);
|
|
wrindir(s, SV_CIDMAABASECOUNT0, s->dma_dac.fragsamples-1); */
|
|
/* FILL ME */
|
|
s->dma_dac.count = s->dma_dac.hwptr = s->dma_dac.swptr = 0;
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
}
|
|
if (signal_pending(current)) {
|
|
if (!ret) ret = -ERESTARTSYS;
|
|
goto return_free;
|
|
}
|
|
continue;
|
|
}
|
|
if (copy_from_user(s->dma_dac.rawbuf + swptr, buffer, cnt)) {
|
|
if (!ret) ret = -EFAULT;
|
|
goto return_free;
|
|
}
|
|
/* printk("wrote %d bytes at sw: %d cnt: %d while hw: %d\n",cnt, swptr, s->dma_dac.count, s->dma_dac.hwptr);*/
|
|
|
|
swptr = (swptr + cnt) % s->dma_dac.dmasize;
|
|
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
s->dma_dac.swptr = swptr;
|
|
s->dma_dac.count += cnt;
|
|
s->dma_dac.endcleared = 0;
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
count -= cnt;
|
|
buffer += cnt;
|
|
ret += cnt;
|
|
start_dac(s);
|
|
}
|
|
return_free:
|
|
return ret;
|
|
}
|
|
|
|
/* No kernel lock - we have our own spinlock */
|
|
static unsigned int ess_poll(struct file *file, struct poll_table_struct *wait)
|
|
{
|
|
struct ess_state *s = (struct ess_state *)file->private_data;
|
|
unsigned long flags;
|
|
unsigned int mask = 0;
|
|
|
|
VALIDATE_STATE(s);
|
|
|
|
/* In 0.14 prog_dmabuf always returns success anyway ... */
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
if (!s->dma_dac.ready && prog_dmabuf(s, 0))
|
|
return 0;
|
|
}
|
|
if (file->f_mode & FMODE_READ) {
|
|
if (!s->dma_adc.ready && prog_dmabuf(s, 1))
|
|
return 0;
|
|
}
|
|
|
|
if (file->f_mode & FMODE_WRITE)
|
|
poll_wait(file, &s->dma_dac.wait, wait);
|
|
if (file->f_mode & FMODE_READ)
|
|
poll_wait(file, &s->dma_adc.wait, wait);
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
ess_update_ptr(s);
|
|
if (file->f_mode & FMODE_READ) {
|
|
if (s->dma_adc.count >= (signed)s->dma_adc.fragsize)
|
|
mask |= POLLIN | POLLRDNORM;
|
|
}
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
if (s->dma_dac.mapped) {
|
|
if (s->dma_dac.count >= (signed)s->dma_dac.fragsize)
|
|
mask |= POLLOUT | POLLWRNORM;
|
|
} else {
|
|
if ((signed)s->dma_dac.dmasize >= s->dma_dac.count + (signed)s->dma_dac.fragsize)
|
|
mask |= POLLOUT | POLLWRNORM;
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
return mask;
|
|
}
|
|
|
|
static int ess_mmap(struct file *file, struct vm_area_struct *vma)
|
|
{
|
|
struct ess_state *s = (struct ess_state *)file->private_data;
|
|
struct dmabuf *db;
|
|
int ret = -EINVAL;
|
|
unsigned long size;
|
|
|
|
VALIDATE_STATE(s);
|
|
lock_kernel();
|
|
if (vma->vm_flags & VM_WRITE) {
|
|
if ((ret = prog_dmabuf(s, 1)) != 0)
|
|
goto out;
|
|
db = &s->dma_dac;
|
|
} else
|
|
#if 0
|
|
/* if we can have the wp/wc do the combining
|
|
we can turn this back on. */
|
|
if (vma->vm_flags & VM_READ) {
|
|
if ((ret = prog_dmabuf(s, 0)) != 0)
|
|
goto out;
|
|
db = &s->dma_adc;
|
|
} else
|
|
#endif
|
|
goto out;
|
|
ret = -EINVAL;
|
|
if (vma->vm_pgoff != 0)
|
|
goto out;
|
|
size = vma->vm_end - vma->vm_start;
|
|
if (size > (PAGE_SIZE << db->buforder))
|
|
goto out;
|
|
ret = -EAGAIN;
|
|
if (remap_pfn_range(vma, vma->vm_start,
|
|
virt_to_phys(db->rawbuf) >> PAGE_SHIFT,
|
|
size, vma->vm_page_prot))
|
|
goto out;
|
|
db->mapped = 1;
|
|
ret = 0;
|
|
out:
|
|
unlock_kernel();
|
|
return ret;
|
|
}
|
|
|
|
static int ess_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
|
|
{
|
|
struct ess_state *s = (struct ess_state *)file->private_data;
|
|
unsigned long flags;
|
|
audio_buf_info abinfo;
|
|
count_info cinfo;
|
|
int val, mapped, ret;
|
|
unsigned char fmtm, fmtd;
|
|
void __user *argp = (void __user *)arg;
|
|
int __user *p = argp;
|
|
|
|
/* printk("maestro: ess_ioctl: cmd %d\n", cmd);*/
|
|
|
|
VALIDATE_STATE(s);
|
|
mapped = ((file->f_mode & FMODE_WRITE) && s->dma_dac.mapped) ||
|
|
((file->f_mode & FMODE_READ) && s->dma_adc.mapped);
|
|
switch (cmd) {
|
|
case OSS_GETVERSION:
|
|
return put_user(SOUND_VERSION, p);
|
|
|
|
case SNDCTL_DSP_SYNC:
|
|
if (file->f_mode & FMODE_WRITE)
|
|
return drain_dac(s, file->f_flags & O_NONBLOCK);
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_SETDUPLEX:
|
|
/* XXX fix */
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_GETCAPS:
|
|
return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER | DSP_CAP_MMAP, p);
|
|
|
|
case SNDCTL_DSP_RESET:
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
stop_dac(s);
|
|
synchronize_irq(s->card->pcidev->irq);
|
|
s->dma_dac.swptr = s->dma_dac.hwptr = s->dma_dac.count = s->dma_dac.total_bytes = 0;
|
|
}
|
|
if (file->f_mode & FMODE_READ) {
|
|
stop_adc(s);
|
|
synchronize_irq(s->card->pcidev->irq);
|
|
s->dma_adc.swptr = s->dma_adc.hwptr = s->dma_adc.count = s->dma_adc.total_bytes = 0;
|
|
}
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_SPEED:
|
|
if (get_user(val, p))
|
|
return -EFAULT;
|
|
if (val >= 0) {
|
|
if (file->f_mode & FMODE_READ) {
|
|
stop_adc(s);
|
|
s->dma_adc.ready = 0;
|
|
set_adc_rate(s, val);
|
|
}
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
stop_dac(s);
|
|
s->dma_dac.ready = 0;
|
|
set_dac_rate(s, val);
|
|
}
|
|
}
|
|
return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, p);
|
|
|
|
case SNDCTL_DSP_STEREO:
|
|
if (get_user(val, p))
|
|
return -EFAULT;
|
|
fmtd = 0;
|
|
fmtm = ~0;
|
|
if (file->f_mode & FMODE_READ) {
|
|
stop_adc(s);
|
|
s->dma_adc.ready = 0;
|
|
if (val)
|
|
fmtd |= ESS_FMT_STEREO << ESS_ADC_SHIFT;
|
|
else
|
|
fmtm &= ~(ESS_FMT_STEREO << ESS_ADC_SHIFT);
|
|
}
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
stop_dac(s);
|
|
s->dma_dac.ready = 0;
|
|
if (val)
|
|
fmtd |= ESS_FMT_STEREO << ESS_DAC_SHIFT;
|
|
else
|
|
fmtm &= ~(ESS_FMT_STEREO << ESS_DAC_SHIFT);
|
|
}
|
|
set_fmt(s, fmtm, fmtd);
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_CHANNELS:
|
|
if (get_user(val, p))
|
|
return -EFAULT;
|
|
if (val != 0) {
|
|
fmtd = 0;
|
|
fmtm = ~0;
|
|
if (file->f_mode & FMODE_READ) {
|
|
stop_adc(s);
|
|
s->dma_adc.ready = 0;
|
|
if (val >= 2)
|
|
fmtd |= ESS_FMT_STEREO << ESS_ADC_SHIFT;
|
|
else
|
|
fmtm &= ~(ESS_FMT_STEREO << ESS_ADC_SHIFT);
|
|
}
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
stop_dac(s);
|
|
s->dma_dac.ready = 0;
|
|
if (val >= 2)
|
|
fmtd |= ESS_FMT_STEREO << ESS_DAC_SHIFT;
|
|
else
|
|
fmtm &= ~(ESS_FMT_STEREO << ESS_DAC_SHIFT);
|
|
}
|
|
set_fmt(s, fmtm, fmtd);
|
|
}
|
|
return put_user((s->fmt & ((file->f_mode & FMODE_READ) ? (ESS_FMT_STEREO << ESS_ADC_SHIFT)
|
|
: (ESS_FMT_STEREO << ESS_DAC_SHIFT))) ? 2 : 1, p);
|
|
|
|
case SNDCTL_DSP_GETFMTS: /* Returns a mask */
|
|
return put_user(AFMT_U8|AFMT_S16_LE, p);
|
|
|
|
case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
|
|
if (get_user(val, p))
|
|
return -EFAULT;
|
|
if (val != AFMT_QUERY) {
|
|
fmtd = 0;
|
|
fmtm = ~0;
|
|
if (file->f_mode & FMODE_READ) {
|
|
stop_adc(s);
|
|
s->dma_adc.ready = 0;
|
|
/* fixed at 16bit for now */
|
|
fmtd |= ESS_FMT_16BIT << ESS_ADC_SHIFT;
|
|
#if 0
|
|
if (val == AFMT_S16_LE)
|
|
fmtd |= ESS_FMT_16BIT << ESS_ADC_SHIFT;
|
|
else
|
|
fmtm &= ~(ESS_FMT_16BIT << ESS_ADC_SHIFT);
|
|
#endif
|
|
}
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
stop_dac(s);
|
|
s->dma_dac.ready = 0;
|
|
if (val == AFMT_S16_LE)
|
|
fmtd |= ESS_FMT_16BIT << ESS_DAC_SHIFT;
|
|
else
|
|
fmtm &= ~(ESS_FMT_16BIT << ESS_DAC_SHIFT);
|
|
}
|
|
set_fmt(s, fmtm, fmtd);
|
|
}
|
|
return put_user((s->fmt & ((file->f_mode & FMODE_READ) ?
|
|
(ESS_FMT_16BIT << ESS_ADC_SHIFT)
|
|
: (ESS_FMT_16BIT << ESS_DAC_SHIFT))) ?
|
|
AFMT_S16_LE :
|
|
AFMT_U8,
|
|
p);
|
|
|
|
case SNDCTL_DSP_POST:
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_GETTRIGGER:
|
|
val = 0;
|
|
if ((file->f_mode & FMODE_READ) && (s->enable & ADC_RUNNING))
|
|
val |= PCM_ENABLE_INPUT;
|
|
if ((file->f_mode & FMODE_WRITE) && (s->enable & DAC_RUNNING))
|
|
val |= PCM_ENABLE_OUTPUT;
|
|
return put_user(val, p);
|
|
|
|
case SNDCTL_DSP_SETTRIGGER:
|
|
if (get_user(val, p))
|
|
return -EFAULT;
|
|
if (file->f_mode & FMODE_READ) {
|
|
if (val & PCM_ENABLE_INPUT) {
|
|
if (!s->dma_adc.ready && (ret = prog_dmabuf(s, 1)))
|
|
return ret;
|
|
start_adc(s);
|
|
} else
|
|
stop_adc(s);
|
|
}
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
if (val & PCM_ENABLE_OUTPUT) {
|
|
if (!s->dma_dac.ready && (ret = prog_dmabuf(s, 0)))
|
|
return ret;
|
|
start_dac(s);
|
|
} else
|
|
stop_dac(s);
|
|
}
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_GETOSPACE:
|
|
if (!(file->f_mode & FMODE_WRITE))
|
|
return -EINVAL;
|
|
if (!s->dma_dac.ready && (ret = prog_dmabuf(s, 0)))
|
|
return ret;
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
ess_update_ptr(s);
|
|
abinfo.fragsize = s->dma_dac.fragsize;
|
|
abinfo.bytes = s->dma_dac.dmasize - s->dma_dac.count;
|
|
abinfo.fragstotal = s->dma_dac.numfrag;
|
|
abinfo.fragments = abinfo.bytes >> s->dma_dac.fragshift;
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
|
|
|
|
case SNDCTL_DSP_GETISPACE:
|
|
if (!(file->f_mode & FMODE_READ))
|
|
return -EINVAL;
|
|
if (!s->dma_adc.ready && (ret = prog_dmabuf(s, 1)))
|
|
return ret;
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
ess_update_ptr(s);
|
|
abinfo.fragsize = s->dma_adc.fragsize;
|
|
abinfo.bytes = s->dma_adc.count;
|
|
abinfo.fragstotal = s->dma_adc.numfrag;
|
|
abinfo.fragments = abinfo.bytes >> s->dma_adc.fragshift;
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
|
|
|
|
case SNDCTL_DSP_NONBLOCK:
|
|
file->f_flags |= O_NONBLOCK;
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_GETODELAY:
|
|
if (!(file->f_mode & FMODE_WRITE))
|
|
return -EINVAL;
|
|
if (!s->dma_dac.ready && (ret = prog_dmabuf(s, 0)))
|
|
return ret;
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
ess_update_ptr(s);
|
|
val = s->dma_dac.count;
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
return put_user(val, p);
|
|
|
|
case SNDCTL_DSP_GETIPTR:
|
|
if (!(file->f_mode & FMODE_READ))
|
|
return -EINVAL;
|
|
if (!s->dma_adc.ready && (ret = prog_dmabuf(s, 1)))
|
|
return ret;
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
ess_update_ptr(s);
|
|
cinfo.bytes = s->dma_adc.total_bytes;
|
|
cinfo.blocks = s->dma_adc.count >> s->dma_adc.fragshift;
|
|
cinfo.ptr = s->dma_adc.hwptr;
|
|
if (s->dma_adc.mapped)
|
|
s->dma_adc.count &= s->dma_adc.fragsize-1;
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
|
|
return -EFAULT;
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_GETOPTR:
|
|
if (!(file->f_mode & FMODE_WRITE))
|
|
return -EINVAL;
|
|
if (!s->dma_dac.ready && (ret = prog_dmabuf(s, 0)))
|
|
return ret;
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
ess_update_ptr(s);
|
|
cinfo.bytes = s->dma_dac.total_bytes;
|
|
cinfo.blocks = s->dma_dac.count >> s->dma_dac.fragshift;
|
|
cinfo.ptr = s->dma_dac.hwptr;
|
|
if (s->dma_dac.mapped)
|
|
s->dma_dac.count &= s->dma_dac.fragsize-1;
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
|
|
return -EFAULT;
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_GETBLKSIZE:
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
if ((val = prog_dmabuf(s, 0)))
|
|
return val;
|
|
return put_user(s->dma_dac.fragsize, p);
|
|
}
|
|
if ((val = prog_dmabuf(s, 1)))
|
|
return val;
|
|
return put_user(s->dma_adc.fragsize, p);
|
|
|
|
case SNDCTL_DSP_SETFRAGMENT:
|
|
if (get_user(val, p))
|
|
return -EFAULT;
|
|
M_printk("maestro: SETFRAGMENT: %0x\n",val);
|
|
if (file->f_mode & FMODE_READ) {
|
|
s->dma_adc.ossfragshift = val & 0xffff;
|
|
s->dma_adc.ossmaxfrags = (val >> 16) & 0xffff;
|
|
if (s->dma_adc.ossfragshift < 4)
|
|
s->dma_adc.ossfragshift = 4;
|
|
if (s->dma_adc.ossfragshift > 15)
|
|
s->dma_adc.ossfragshift = 15;
|
|
if (s->dma_adc.ossmaxfrags < 4)
|
|
s->dma_adc.ossmaxfrags = 4;
|
|
}
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
s->dma_dac.ossfragshift = val & 0xffff;
|
|
s->dma_dac.ossmaxfrags = (val >> 16) & 0xffff;
|
|
if (s->dma_dac.ossfragshift < 4)
|
|
s->dma_dac.ossfragshift = 4;
|
|
if (s->dma_dac.ossfragshift > 15)
|
|
s->dma_dac.ossfragshift = 15;
|
|
if (s->dma_dac.ossmaxfrags < 4)
|
|
s->dma_dac.ossmaxfrags = 4;
|
|
}
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_SUBDIVIDE:
|
|
if ((file->f_mode & FMODE_READ && s->dma_adc.subdivision) ||
|
|
(file->f_mode & FMODE_WRITE && s->dma_dac.subdivision))
|
|
return -EINVAL;
|
|
if (get_user(val, p))
|
|
return -EFAULT;
|
|
if (val != 1 && val != 2 && val != 4)
|
|
return -EINVAL;
|
|
if (file->f_mode & FMODE_READ)
|
|
s->dma_adc.subdivision = val;
|
|
if (file->f_mode & FMODE_WRITE)
|
|
s->dma_dac.subdivision = val;
|
|
return 0;
|
|
|
|
case SOUND_PCM_READ_RATE:
|
|
return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, p);
|
|
|
|
case SOUND_PCM_READ_CHANNELS:
|
|
return put_user((s->fmt & ((file->f_mode & FMODE_READ) ? (ESS_FMT_STEREO << ESS_ADC_SHIFT)
|
|
: (ESS_FMT_STEREO << ESS_DAC_SHIFT))) ? 2 : 1, p);
|
|
|
|
case SOUND_PCM_READ_BITS:
|
|
return put_user((s->fmt & ((file->f_mode & FMODE_READ) ? (ESS_FMT_16BIT << ESS_ADC_SHIFT)
|
|
: (ESS_FMT_16BIT << ESS_DAC_SHIFT))) ? 16 : 8, p);
|
|
|
|
case SOUND_PCM_WRITE_FILTER:
|
|
case SNDCTL_DSP_SETSYNCRO:
|
|
case SOUND_PCM_READ_FILTER:
|
|
return -EINVAL;
|
|
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|
|
static void
|
|
set_base_registers(struct ess_state *s,void *vaddr)
|
|
{
|
|
unsigned long packed_phys = virt_to_bus(vaddr)>>12;
|
|
wave_set_register(s, 0x01FC , packed_phys);
|
|
wave_set_register(s, 0x01FD , packed_phys);
|
|
wave_set_register(s, 0x01FE , packed_phys);
|
|
wave_set_register(s, 0x01FF , packed_phys);
|
|
}
|
|
|
|
/*
|
|
* this guy makes sure we're in the right power
|
|
* state for what we want to be doing
|
|
*/
|
|
static void maestro_power(struct ess_card *card, int tostate)
|
|
{
|
|
u16 active_mask = acpi_state_mask[tostate];
|
|
u8 state;
|
|
|
|
if(!use_pm) return;
|
|
|
|
pci_read_config_byte(card->pcidev, card->power_regs+0x4, &state);
|
|
state&=3;
|
|
|
|
/* make sure we're in the right state */
|
|
if(state != tostate) {
|
|
M_printk(KERN_WARNING "maestro: dev %02x:%02x.%x switching from D%d to D%d\n",
|
|
card->pcidev->bus->number,
|
|
PCI_SLOT(card->pcidev->devfn),
|
|
PCI_FUNC(card->pcidev->devfn),
|
|
state,tostate);
|
|
pci_write_config_byte(card->pcidev, card->power_regs+0x4, tostate);
|
|
}
|
|
|
|
/* and make sure the units we care about are on
|
|
XXX we might want to do this before state flipping? */
|
|
pci_write_config_word(card->pcidev, 0x54, ~ active_mask);
|
|
pci_write_config_word(card->pcidev, 0x56, ~ active_mask);
|
|
}
|
|
|
|
/* we allocate a large power of two for all our memory.
|
|
this is cut up into (not to scale :):
|
|
|silly fifo word | 512byte mixbuf per adc | dac/adc * channels |
|
|
*/
|
|
static int
|
|
allocate_buffers(struct ess_state *s)
|
|
{
|
|
void *rawbuf=NULL;
|
|
int order,i;
|
|
struct page *page, *pend;
|
|
|
|
/* alloc as big a chunk as we can */
|
|
for (order = (dsps_order + (16-PAGE_SHIFT) + 1); order >= (dsps_order + 2 + 1); order--)
|
|
if((rawbuf = (void *)__get_free_pages(GFP_KERNEL|GFP_DMA, order)))
|
|
break;
|
|
|
|
if (!rawbuf)
|
|
return 1;
|
|
|
|
M_printk("maestro: allocated %ld (%d) bytes at %p\n",PAGE_SIZE<<order,order, rawbuf);
|
|
|
|
if ((virt_to_bus(rawbuf) + (PAGE_SIZE << order) - 1) & ~((1<<28)-1)) {
|
|
printk(KERN_ERR "maestro: DMA buffer beyond 256MB! busaddr 0x%lx size %ld\n",
|
|
virt_to_bus(rawbuf), PAGE_SIZE << order);
|
|
kfree(rawbuf);
|
|
return 1;
|
|
}
|
|
|
|
s->card->dmapages = rawbuf;
|
|
s->card->dmaorder = order;
|
|
|
|
for(i=0;i<NR_DSPS;i++) {
|
|
struct ess_state *ess = &s->card->channels[i];
|
|
|
|
if(ess->dev_audio == -1)
|
|
continue;
|
|
|
|
ess->dma_dac.ready = s->dma_dac.mapped = 0;
|
|
ess->dma_adc.ready = s->dma_adc.mapped = 0;
|
|
ess->dma_adc.buforder = ess->dma_dac.buforder = order - 1 - dsps_order - 1;
|
|
|
|
/* offset dac and adc buffers starting half way through and then at each [da][ad]c's
|
|
order's intervals.. */
|
|
ess->dma_dac.rawbuf = rawbuf + (PAGE_SIZE<<(order-1)) + (i * ( PAGE_SIZE << (ess->dma_dac.buforder + 1 )));
|
|
ess->dma_adc.rawbuf = ess->dma_dac.rawbuf + ( PAGE_SIZE << ess->dma_dac.buforder);
|
|
/* offset mixbuf by a mixbuf so that the lame status fifo can
|
|
happily scribble away.. */
|
|
ess->mixbuf = rawbuf + (512 * (i+1));
|
|
|
|
M_printk("maestro: setup apu %d: dac: %p adc: %p mix: %p\n",i,ess->dma_dac.rawbuf,
|
|
ess->dma_adc.rawbuf, ess->mixbuf);
|
|
|
|
}
|
|
|
|
/* now mark the pages as reserved; otherwise remap_pfn_range doesn't do what we want */
|
|
pend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
|
|
for (page = virt_to_page(rawbuf); page <= pend; page++)
|
|
SetPageReserved(page);
|
|
|
|
return 0;
|
|
}
|
|
static void
|
|
free_buffers(struct ess_state *s)
|
|
{
|
|
struct page *page, *pend;
|
|
|
|
s->dma_dac.rawbuf = s->dma_adc.rawbuf = NULL;
|
|
s->dma_dac.mapped = s->dma_adc.mapped = 0;
|
|
s->dma_dac.ready = s->dma_adc.ready = 0;
|
|
|
|
M_printk("maestro: freeing %p\n",s->card->dmapages);
|
|
/* undo marking the pages as reserved */
|
|
|
|
pend = virt_to_page(s->card->dmapages + (PAGE_SIZE << s->card->dmaorder) - 1);
|
|
for (page = virt_to_page(s->card->dmapages); page <= pend; page++)
|
|
ClearPageReserved(page);
|
|
|
|
free_pages((unsigned long)s->card->dmapages,s->card->dmaorder);
|
|
s->card->dmapages = NULL;
|
|
}
|
|
|
|
static int
|
|
ess_open(struct inode *inode, struct file *file)
|
|
{
|
|
unsigned int minor = iminor(inode);
|
|
struct ess_state *s = NULL;
|
|
unsigned char fmtm = ~0, fmts = 0;
|
|
struct pci_dev *pdev = NULL;
|
|
/*
|
|
* Scan the cards and find the channel. We only
|
|
* do this at open time so it is ok
|
|
*/
|
|
|
|
while ((pdev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, pdev)) != NULL) {
|
|
struct ess_card *c;
|
|
struct pci_driver *drvr;
|
|
|
|
drvr = pci_dev_driver (pdev);
|
|
if (drvr == &maestro_pci_driver) {
|
|
int i;
|
|
struct ess_state *sp;
|
|
|
|
c = (struct ess_card*)pci_get_drvdata (pdev);
|
|
if (!c)
|
|
continue;
|
|
for(i=0;i<NR_DSPS;i++)
|
|
{
|
|
sp=&c->channels[i];
|
|
if(sp->dev_audio < 0)
|
|
continue;
|
|
if((sp->dev_audio ^ minor) & ~0xf)
|
|
continue;
|
|
s=sp;
|
|
}
|
|
}
|
|
}
|
|
if (!s)
|
|
return -ENODEV;
|
|
|
|
VALIDATE_STATE(s);
|
|
file->private_data = s;
|
|
/* wait for device to become free */
|
|
down(&s->open_sem);
|
|
while (s->open_mode & file->f_mode) {
|
|
if (file->f_flags & O_NONBLOCK) {
|
|
up(&s->open_sem);
|
|
return -EWOULDBLOCK;
|
|
}
|
|
up(&s->open_sem);
|
|
interruptible_sleep_on(&s->open_wait);
|
|
if (signal_pending(current))
|
|
return -ERESTARTSYS;
|
|
down(&s->open_sem);
|
|
}
|
|
|
|
/* under semaphore.. */
|
|
if ((s->card->dmapages==NULL) && allocate_buffers(s)) {
|
|
up(&s->open_sem);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* we're covered by the open_sem */
|
|
if( ! s->card->dsps_open ) {
|
|
maestro_power(s->card,ACPI_D0);
|
|
start_bob(s);
|
|
}
|
|
s->card->dsps_open++;
|
|
M_printk("maestro: open, %d bobs now\n",s->card->dsps_open);
|
|
|
|
/* ok, lets write WC base regs now that we've
|
|
powered up the chip */
|
|
M_printk("maestro: writing 0x%lx (bus 0x%lx) to the wp\n",virt_to_bus(s->card->dmapages),
|
|
((virt_to_bus(s->card->dmapages))&0xFFE00000)>>12);
|
|
set_base_registers(s,s->card->dmapages);
|
|
|
|
if (file->f_mode & FMODE_READ) {
|
|
/*
|
|
fmtm &= ~((ESS_FMT_STEREO | ESS_FMT_16BIT) << ESS_ADC_SHIFT);
|
|
if ((minor & 0xf) == SND_DEV_DSP16)
|
|
fmts |= ESS_FMT_16BIT << ESS_ADC_SHIFT; */
|
|
|
|
fmtm &= ~((ESS_FMT_STEREO|ESS_FMT_16BIT) << ESS_ADC_SHIFT);
|
|
fmts = (ESS_FMT_STEREO|ESS_FMT_16BIT) << ESS_ADC_SHIFT;
|
|
|
|
s->dma_adc.ossfragshift = s->dma_adc.ossmaxfrags = s->dma_adc.subdivision = 0;
|
|
set_adc_rate(s, 8000);
|
|
}
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
fmtm &= ~((ESS_FMT_STEREO | ESS_FMT_16BIT) << ESS_DAC_SHIFT);
|
|
if ((minor & 0xf) == SND_DEV_DSP16)
|
|
fmts |= ESS_FMT_16BIT << ESS_DAC_SHIFT;
|
|
|
|
s->dma_dac.ossfragshift = s->dma_dac.ossmaxfrags = s->dma_dac.subdivision = 0;
|
|
set_dac_rate(s, 8000);
|
|
}
|
|
set_fmt(s, fmtm, fmts);
|
|
s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
|
|
|
|
up(&s->open_sem);
|
|
return nonseekable_open(inode, file);
|
|
}
|
|
|
|
static int
|
|
ess_release(struct inode *inode, struct file *file)
|
|
{
|
|
struct ess_state *s = (struct ess_state *)file->private_data;
|
|
|
|
VALIDATE_STATE(s);
|
|
lock_kernel();
|
|
if (file->f_mode & FMODE_WRITE)
|
|
drain_dac(s, file->f_flags & O_NONBLOCK);
|
|
down(&s->open_sem);
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
stop_dac(s);
|
|
}
|
|
if (file->f_mode & FMODE_READ) {
|
|
stop_adc(s);
|
|
}
|
|
|
|
s->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
|
|
/* we're covered by the open_sem */
|
|
M_printk("maestro: %d dsps now alive\n",s->card->dsps_open-1);
|
|
if( --s->card->dsps_open <= 0) {
|
|
s->card->dsps_open = 0;
|
|
stop_bob(s);
|
|
free_buffers(s);
|
|
maestro_power(s->card,ACPI_D2);
|
|
}
|
|
up(&s->open_sem);
|
|
wake_up(&s->open_wait);
|
|
unlock_kernel();
|
|
return 0;
|
|
}
|
|
|
|
static struct file_operations ess_audio_fops = {
|
|
.owner = THIS_MODULE,
|
|
.llseek = no_llseek,
|
|
.read = ess_read,
|
|
.write = ess_write,
|
|
.poll = ess_poll,
|
|
.ioctl = ess_ioctl,
|
|
.mmap = ess_mmap,
|
|
.open = ess_open,
|
|
.release = ess_release,
|
|
};
|
|
|
|
static int
|
|
maestro_config(struct ess_card *card)
|
|
{
|
|
struct pci_dev *pcidev = card->pcidev;
|
|
struct ess_state *ess = &card->channels[0];
|
|
int apu,iobase = card->iobase;
|
|
u16 w;
|
|
u32 n;
|
|
|
|
/* We used to muck around with pci config space that
|
|
* we had no business messing with. We don't know enough
|
|
* about the machine to know which DMA mode is appropriate,
|
|
* etc. We were guessing wrong on some machines and making
|
|
* them unhappy. We now trust in the BIOS to do things right,
|
|
* which almost certainly means a new host of problems will
|
|
* arise with broken BIOS implementations. screw 'em.
|
|
* We're already intolerant of machines that don't assign
|
|
* IRQs.
|
|
*/
|
|
|
|
/* do config work at full power */
|
|
maestro_power(card,ACPI_D0);
|
|
|
|
pci_read_config_word(pcidev, 0x50, &w);
|
|
|
|
w&=~(1<<5); /* Don't swap left/right (undoc)*/
|
|
|
|
pci_write_config_word(pcidev, 0x50, w);
|
|
|
|
pci_read_config_word(pcidev, 0x52, &w);
|
|
w&=~(1<<15); /* Turn off internal clock multiplier */
|
|
/* XXX how do we know which to use? */
|
|
w&=~(1<<14); /* External clock */
|
|
|
|
w|= (1<<7); /* Hardware volume control on */
|
|
w|= (1<<6); /* Debounce off: easier to push the HWV buttons. */
|
|
w&=~(1<<5); /* GPIO 4:5 */
|
|
w|= (1<<4); /* Disconnect from the CHI. Enabling this made a dell 7500 work. */
|
|
w&=~(1<<2); /* MIDI fix off (undoc) */
|
|
w&=~(1<<1); /* reserved, always write 0 */
|
|
pci_write_config_word(pcidev, 0x52, w);
|
|
|
|
/*
|
|
* Legacy mode
|
|
*/
|
|
|
|
pci_read_config_word(pcidev, 0x40, &w);
|
|
w|=(1<<15); /* legacy decode off */
|
|
w&=~(1<<14); /* Disable SIRQ */
|
|
w&=~(0x1f); /* disable mpu irq/io, game port, fm, SB */
|
|
|
|
pci_write_config_word(pcidev, 0x40, w);
|
|
|
|
/* Set up 978 docking control chip. */
|
|
pci_read_config_word(pcidev, 0x58, &w);
|
|
w|=1<<2; /* Enable 978. */
|
|
w|=1<<3; /* Turn on 978 hardware volume control. */
|
|
w&=~(1<<11); /* Turn on 978 mixer volume control. */
|
|
pci_write_config_word(pcidev, 0x58, w);
|
|
|
|
sound_reset(iobase);
|
|
|
|
/*
|
|
* Ring Bus Setup
|
|
*/
|
|
|
|
/* setup usual 0x34 stuff.. 0x36 may be chip specific */
|
|
outw(0xC090, iobase+0x34); /* direct sound, stereo */
|
|
udelay(20);
|
|
outw(0x3000, iobase+0x36); /* direct sound, stereo */
|
|
udelay(20);
|
|
|
|
|
|
/*
|
|
* Reset the CODEC
|
|
*/
|
|
|
|
maestro_ac97_reset(iobase,pcidev);
|
|
|
|
/*
|
|
* Ring Bus Setup
|
|
*/
|
|
|
|
n=inl(iobase+0x34);
|
|
n&=~0xF000;
|
|
n|=12<<12; /* Direct Sound, Stereo */
|
|
outl(n, iobase+0x34);
|
|
|
|
n=inl(iobase+0x34);
|
|
n&=~0x0F00; /* Modem off */
|
|
outl(n, iobase+0x34);
|
|
|
|
n=inl(iobase+0x34);
|
|
n&=~0x00F0;
|
|
n|=9<<4; /* DAC, Stereo */
|
|
outl(n, iobase+0x34);
|
|
|
|
n=inl(iobase+0x34);
|
|
n&=~0x000F; /* ASSP off */
|
|
outl(n, iobase+0x34);
|
|
|
|
n=inl(iobase+0x34);
|
|
n|=(1<<29); /* Enable ring bus */
|
|
outl(n, iobase+0x34);
|
|
|
|
n=inl(iobase+0x34);
|
|
n|=(1<<28); /* Enable serial bus */
|
|
outl(n, iobase+0x34);
|
|
|
|
n=inl(iobase+0x34);
|
|
n&=~0x00F00000; /* MIC off */
|
|
outl(n, iobase+0x34);
|
|
|
|
n=inl(iobase+0x34);
|
|
n&=~0x000F0000; /* I2S off */
|
|
outl(n, iobase+0x34);
|
|
|
|
|
|
w=inw(iobase+0x18);
|
|
w&=~(1<<7); /* ClkRun off */
|
|
outw(w, iobase+0x18);
|
|
|
|
w=inw(iobase+0x18);
|
|
w&=~(1<<6); /* Hardware volume control interrupt off... for now. */
|
|
outw(w, iobase+0x18);
|
|
|
|
w=inw(iobase+0x18);
|
|
w&=~(1<<4); /* ASSP irq off */
|
|
outw(w, iobase+0x18);
|
|
|
|
w=inw(iobase+0x18);
|
|
w&=~(1<<3); /* ISDN irq off */
|
|
outw(w, iobase+0x18);
|
|
|
|
w=inw(iobase+0x18);
|
|
w|=(1<<2); /* Direct Sound IRQ on */
|
|
outw(w, iobase+0x18);
|
|
|
|
w=inw(iobase+0x18);
|
|
w&=~(1<<1); /* MPU401 IRQ off */
|
|
outw(w, iobase+0x18);
|
|
|
|
w=inw(iobase+0x18);
|
|
w|=(1<<0); /* SB IRQ on */
|
|
outw(w, iobase+0x18);
|
|
|
|
/* Set hardware volume control registers to midpoints.
|
|
We can tell which button was pushed based on how they change. */
|
|
outb(0x88, iobase+0x1c);
|
|
outb(0x88, iobase+0x1d);
|
|
outb(0x88, iobase+0x1e);
|
|
outb(0x88, iobase+0x1f);
|
|
|
|
/* it appears some maestros (dell 7500) only work if these are set,
|
|
regardless of whether we use the assp or not. */
|
|
|
|
outb(0, iobase+0xA4);
|
|
outb(3, iobase+0xA2);
|
|
outb(0, iobase+0xA6);
|
|
|
|
for(apu=0;apu<16;apu++)
|
|
{
|
|
/* Write 0 into the buffer area 0x1E0->1EF */
|
|
outw(0x01E0+apu, 0x10+iobase);
|
|
outw(0x0000, 0x12+iobase);
|
|
|
|
/*
|
|
* The 1.10 test program seem to write 0 into the buffer area
|
|
* 0x1D0-0x1DF too.
|
|
*/
|
|
outw(0x01D0+apu, 0x10+iobase);
|
|
outw(0x0000, 0x12+iobase);
|
|
}
|
|
|
|
#if 1
|
|
wave_set_register(ess, IDR7_WAVE_ROMRAM,
|
|
(wave_get_register(ess, IDR7_WAVE_ROMRAM)&0xFF00));
|
|
wave_set_register(ess, IDR7_WAVE_ROMRAM,
|
|
wave_get_register(ess, IDR7_WAVE_ROMRAM)|0x100);
|
|
wave_set_register(ess, IDR7_WAVE_ROMRAM,
|
|
wave_get_register(ess, IDR7_WAVE_ROMRAM)&~0x200);
|
|
wave_set_register(ess, IDR7_WAVE_ROMRAM,
|
|
wave_get_register(ess, IDR7_WAVE_ROMRAM)|~0x400);
|
|
#else
|
|
maestro_write(ess, IDR7_WAVE_ROMRAM,
|
|
(maestro_read(ess, IDR7_WAVE_ROMRAM)&0xFF00));
|
|
maestro_write(ess, IDR7_WAVE_ROMRAM,
|
|
maestro_read(ess, IDR7_WAVE_ROMRAM)|0x100);
|
|
maestro_write(ess, IDR7_WAVE_ROMRAM,
|
|
maestro_read(ess, IDR7_WAVE_ROMRAM)&~0x200);
|
|
maestro_write(ess, IDR7_WAVE_ROMRAM,
|
|
maestro_read(ess, IDR7_WAVE_ROMRAM)|0x400);
|
|
#endif
|
|
|
|
maestro_write(ess, IDR2_CRAM_DATA, 0x0000);
|
|
maestro_write(ess, 0x08, 0xB004);
|
|
/* Now back to the DirectSound stuff */
|
|
maestro_write(ess, 0x09, 0x001B);
|
|
maestro_write(ess, 0x0A, 0x8000);
|
|
maestro_write(ess, 0x0B, 0x3F37);
|
|
maestro_write(ess, 0x0C, 0x0098);
|
|
|
|
/* parallel out ?? */
|
|
maestro_write(ess, 0x0C,
|
|
(maestro_read(ess, 0x0C)&~0xF000)|0x8000);
|
|
/* parallel in, has something to do with recording :) */
|
|
maestro_write(ess, 0x0C,
|
|
(maestro_read(ess, 0x0C)&~0x0F00)|0x0500);
|
|
|
|
maestro_write(ess, 0x0D, 0x7632);
|
|
|
|
/* Wave cache control on - test off, sg off,
|
|
enable, enable extra chans 1Mb */
|
|
|
|
outw(inw(0x14+iobase)|(1<<8),0x14+iobase);
|
|
outw(inw(0x14+iobase)&0xFE03,0x14+iobase);
|
|
outw((inw(0x14+iobase)&0xFFFC), 0x14+iobase);
|
|
outw(inw(0x14+iobase)|(1<<7),0x14+iobase);
|
|
|
|
outw(0xA1A0, 0x14+iobase); /* 0300 ? */
|
|
|
|
/* Now clear the APU control ram */
|
|
for(apu=0;apu<NR_APUS;apu++)
|
|
{
|
|
for(w=0;w<NR_APU_REGS;w++)
|
|
apu_set_register(ess, apu|ESS_CHAN_HARD, w, 0);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* this guy tries to find the pci power management
|
|
* register bank. this should really be in core
|
|
* code somewhere. 1 on success. */
|
|
static int
|
|
parse_power(struct ess_card *card, struct pci_dev *pcidev)
|
|
{
|
|
u32 n;
|
|
u16 w;
|
|
u8 next;
|
|
int max = 64; /* an a 8bit guy pointing to 32bit guys
|
|
can only express so much. */
|
|
|
|
card->power_regs = 0;
|
|
|
|
/* check to see if we have a capabilities list in
|
|
the config register */
|
|
pci_read_config_word(pcidev, PCI_STATUS, &w);
|
|
if(!(w & PCI_STATUS_CAP_LIST)) return 0;
|
|
|
|
/* walk the list, starting at the head. */
|
|
pci_read_config_byte(pcidev,PCI_CAPABILITY_LIST,&next);
|
|
|
|
while(next && max--) {
|
|
pci_read_config_dword(pcidev, next & ~3, &n);
|
|
if((n & 0xff) == PCI_CAP_ID_PM) {
|
|
card->power_regs = next;
|
|
break;
|
|
}
|
|
next = ((n>>8) & 0xff);
|
|
}
|
|
|
|
return card->power_regs ? 1 : 0;
|
|
}
|
|
|
|
static int __init
|
|
maestro_probe(struct pci_dev *pcidev,const struct pci_device_id *pdid)
|
|
{
|
|
int card_type = pdid->driver_data;
|
|
u32 n;
|
|
int iobase;
|
|
int i, ret;
|
|
struct ess_card *card;
|
|
struct ess_state *ess;
|
|
struct pm_dev *pmdev;
|
|
int num = 0;
|
|
|
|
/* when built into the kernel, we only print version if device is found */
|
|
#ifndef MODULE
|
|
static int printed_version;
|
|
if (!printed_version++)
|
|
printk(version);
|
|
#endif
|
|
|
|
/* don't pick up weird modem maestros */
|
|
if(((pcidev->class >> 8) & 0xffff) != PCI_CLASS_MULTIMEDIA_AUDIO)
|
|
return -ENODEV;
|
|
|
|
|
|
if ((ret=pci_enable_device(pcidev)))
|
|
return ret;
|
|
|
|
iobase = pci_resource_start(pcidev,0);
|
|
if (!iobase || !(pci_resource_flags(pcidev, 0 ) & IORESOURCE_IO))
|
|
return -ENODEV;
|
|
|
|
if(pcidev->irq == 0)
|
|
return -ENODEV;
|
|
|
|
/* stake our claim on the iospace */
|
|
if( request_region(iobase, 256, card_names[card_type]) == NULL )
|
|
{
|
|
printk(KERN_WARNING "maestro: can't allocate 256 bytes I/O at 0x%4.4x\n", iobase);
|
|
return -EBUSY;
|
|
}
|
|
|
|
/* just to be sure */
|
|
pci_set_master(pcidev);
|
|
|
|
card = kmalloc(sizeof(struct ess_card), GFP_KERNEL);
|
|
if(card == NULL)
|
|
{
|
|
printk(KERN_WARNING "maestro: out of memory\n");
|
|
release_region(iobase, 256);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
memset(card, 0, sizeof(*card));
|
|
card->pcidev = pcidev;
|
|
|
|
pmdev = pm_register(PM_PCI_DEV, PM_PCI_ID(pcidev),
|
|
maestro_pm_callback);
|
|
if (pmdev)
|
|
pmdev->data = card;
|
|
|
|
card->iobase = iobase;
|
|
card->card_type = card_type;
|
|
card->irq = pcidev->irq;
|
|
card->magic = ESS_CARD_MAGIC;
|
|
spin_lock_init(&card->lock);
|
|
init_waitqueue_head(&card->suspend_queue);
|
|
|
|
card->dock_mute_vol = 50;
|
|
|
|
/* init our groups of 6 apus */
|
|
for(i=0;i<NR_DSPS;i++)
|
|
{
|
|
struct ess_state *s=&card->channels[i];
|
|
|
|
s->index = i;
|
|
|
|
s->card = card;
|
|
init_waitqueue_head(&s->dma_adc.wait);
|
|
init_waitqueue_head(&s->dma_dac.wait);
|
|
init_waitqueue_head(&s->open_wait);
|
|
spin_lock_init(&s->lock);
|
|
init_MUTEX(&s->open_sem);
|
|
s->magic = ESS_STATE_MAGIC;
|
|
|
|
s->apu[0] = 6*i;
|
|
s->apu[1] = (6*i)+1;
|
|
s->apu[2] = (6*i)+2;
|
|
s->apu[3] = (6*i)+3;
|
|
s->apu[4] = (6*i)+4;
|
|
s->apu[5] = (6*i)+5;
|
|
|
|
if(s->dma_adc.ready || s->dma_dac.ready || s->dma_adc.rawbuf)
|
|
printk("maestro: BOTCH!\n");
|
|
/* register devices */
|
|
if ((s->dev_audio = register_sound_dsp(&ess_audio_fops, -1)) < 0)
|
|
break;
|
|
}
|
|
|
|
num = i;
|
|
|
|
/* clear the rest if we ran out of slots to register */
|
|
for(;i<NR_DSPS;i++)
|
|
{
|
|
struct ess_state *s=&card->channels[i];
|
|
s->dev_audio = -1;
|
|
}
|
|
|
|
ess = &card->channels[0];
|
|
|
|
/*
|
|
* Ok card ready. Begin setup proper
|
|
*/
|
|
|
|
printk(KERN_INFO "maestro: Configuring %s found at IO 0x%04X IRQ %d\n",
|
|
card_names[card_type],iobase,card->irq);
|
|
pci_read_config_dword(pcidev, PCI_SUBSYSTEM_VENDOR_ID, &n);
|
|
printk(KERN_INFO "maestro: subvendor id: 0x%08x\n",n);
|
|
|
|
/* turn off power management unless:
|
|
* - the user explicitly asks for it
|
|
* or
|
|
* - we're not a 2e, lesser chipps seem to have problems.
|
|
* - we're not on our _very_ small whitelist. some implemenetations
|
|
* really don't like the pm code, others require it.
|
|
* feel free to expand this as required.
|
|
*/
|
|
#define SUBSYSTEM_VENDOR(x) (x&0xffff)
|
|
if( (use_pm != 1) &&
|
|
((card_type != TYPE_MAESTRO2E) || (SUBSYSTEM_VENDOR(n) != 0x1028)))
|
|
use_pm = 0;
|
|
|
|
if(!use_pm)
|
|
printk(KERN_INFO "maestro: not attempting power management.\n");
|
|
else {
|
|
if(!parse_power(card,pcidev))
|
|
printk(KERN_INFO "maestro: no PCI power management interface found.\n");
|
|
else {
|
|
pci_read_config_dword(pcidev, card->power_regs, &n);
|
|
printk(KERN_INFO "maestro: PCI power management capability: 0x%x\n",n>>16);
|
|
}
|
|
}
|
|
|
|
maestro_config(card);
|
|
|
|
if(maestro_ac97_get(card, 0x00)==0x0080) {
|
|
printk(KERN_ERR "maestro: my goodness! you seem to have a pt101 codec, which is quite rare.\n"
|
|
"\tyou should tell someone about this.\n");
|
|
} else {
|
|
maestro_ac97_init(card);
|
|
}
|
|
|
|
if ((card->dev_mixer = register_sound_mixer(&ess_mixer_fops, -1)) < 0) {
|
|
printk("maestro: couldn't register mixer!\n");
|
|
} else {
|
|
memcpy(card->mix.mixer_state,mixer_defaults,sizeof(card->mix.mixer_state));
|
|
mixer_push_state(card);
|
|
}
|
|
|
|
if((ret=request_irq(card->irq, ess_interrupt, SA_SHIRQ, card_names[card_type], card)))
|
|
{
|
|
printk(KERN_ERR "maestro: unable to allocate irq %d,\n", card->irq);
|
|
unregister_sound_mixer(card->dev_mixer);
|
|
for(i=0;i<NR_DSPS;i++)
|
|
{
|
|
struct ess_state *s = &card->channels[i];
|
|
if(s->dev_audio != -1)
|
|
unregister_sound_dsp(s->dev_audio);
|
|
}
|
|
release_region(card->iobase, 256);
|
|
unregister_reboot_notifier(&maestro_nb);
|
|
kfree(card);
|
|
return ret;
|
|
}
|
|
|
|
/* Turn on hardware volume control interrupt.
|
|
This has to come after we grab the IRQ above,
|
|
or a crash will result on installation if a button has been pressed,
|
|
because in that case we'll get an immediate interrupt. */
|
|
n = inw(iobase+0x18);
|
|
n|=(1<<6);
|
|
outw(n, iobase+0x18);
|
|
|
|
pci_set_drvdata(pcidev,card);
|
|
/* now go to sleep 'till something interesting happens */
|
|
maestro_power(card,ACPI_D2);
|
|
|
|
printk(KERN_INFO "maestro: %d channels configured.\n", num);
|
|
return 0;
|
|
}
|
|
|
|
static void maestro_remove(struct pci_dev *pcidev) {
|
|
struct ess_card *card = pci_get_drvdata(pcidev);
|
|
int i;
|
|
u32 n;
|
|
|
|
/* XXX maybe should force stop bob, but should be all
|
|
stopped by _release by now */
|
|
|
|
/* Turn off hardware volume control interrupt.
|
|
This has to come before we leave the IRQ below,
|
|
or a crash results if a button is pressed ! */
|
|
n = inw(card->iobase+0x18);
|
|
n&=~(1<<6);
|
|
outw(n, card->iobase+0x18);
|
|
|
|
free_irq(card->irq, card);
|
|
unregister_sound_mixer(card->dev_mixer);
|
|
for(i=0;i<NR_DSPS;i++)
|
|
{
|
|
struct ess_state *ess = &card->channels[i];
|
|
if(ess->dev_audio != -1)
|
|
unregister_sound_dsp(ess->dev_audio);
|
|
}
|
|
/* Goodbye, Mr. Bond. */
|
|
maestro_power(card,ACPI_D3);
|
|
release_region(card->iobase, 256);
|
|
kfree(card);
|
|
pci_set_drvdata(pcidev,NULL);
|
|
}
|
|
|
|
static struct pci_device_id maestro_pci_tbl[] = {
|
|
{PCI_VENDOR_ESS, PCI_DEVICE_ID_ESS_ESS1968, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPE_MAESTRO2},
|
|
{PCI_VENDOR_ESS, PCI_DEVICE_ID_ESS_ESS1978, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPE_MAESTRO2E},
|
|
{PCI_VENDOR_ESS_OLD, PCI_DEVICE_ID_ESS_ESS0100, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPE_MAESTRO},
|
|
{0,}
|
|
};
|
|
MODULE_DEVICE_TABLE(pci, maestro_pci_tbl);
|
|
|
|
static struct pci_driver maestro_pci_driver = {
|
|
.name = "maestro",
|
|
.id_table = maestro_pci_tbl,
|
|
.probe = maestro_probe,
|
|
.remove = maestro_remove,
|
|
};
|
|
|
|
static int __init init_maestro(void)
|
|
{
|
|
int rc;
|
|
|
|
rc = pci_module_init(&maestro_pci_driver);
|
|
if (rc < 0)
|
|
return rc;
|
|
|
|
if (register_reboot_notifier(&maestro_nb))
|
|
printk(KERN_WARNING "maestro: reboot notifier registration failed; may not reboot properly.\n");
|
|
#ifdef MODULE
|
|
printk(version);
|
|
#endif
|
|
if (dsps_order < 0) {
|
|
dsps_order = 1;
|
|
printk(KERN_WARNING "maestro: clipping dsps_order to %d\n",dsps_order);
|
|
}
|
|
else if (dsps_order > MAX_DSP_ORDER) {
|
|
dsps_order = MAX_DSP_ORDER;
|
|
printk(KERN_WARNING "maestro: clipping dsps_order to %d\n",dsps_order);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int maestro_notifier(struct notifier_block *nb, unsigned long event, void *buf)
|
|
{
|
|
/* this notifier is called when the kernel is really shut down. */
|
|
M_printk("maestro: shutting down\n");
|
|
/* this will remove all card instances too */
|
|
pci_unregister_driver(&maestro_pci_driver);
|
|
/* XXX dunno about power management */
|
|
return NOTIFY_OK;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
|
|
static void cleanup_maestro(void) {
|
|
M_printk("maestro: unloading\n");
|
|
pci_unregister_driver(&maestro_pci_driver);
|
|
pm_unregister_all(maestro_pm_callback);
|
|
unregister_reboot_notifier(&maestro_nb);
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
void
|
|
check_suspend(struct ess_card *card)
|
|
{
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
|
if(!card->in_suspend) return;
|
|
|
|
card->in_suspend++;
|
|
add_wait_queue(&(card->suspend_queue), &wait);
|
|
current->state = TASK_UNINTERRUPTIBLE;
|
|
schedule();
|
|
remove_wait_queue(&(card->suspend_queue), &wait);
|
|
current->state = TASK_RUNNING;
|
|
}
|
|
|
|
static int
|
|
maestro_suspend(struct ess_card *card)
|
|
{
|
|
unsigned long flags;
|
|
int i,j;
|
|
|
|
spin_lock_irqsave(&card->lock,flags); /* over-kill */
|
|
|
|
M_printk("maestro: apm in dev %p\n",card);
|
|
|
|
/* we have to read from the apu regs, need
|
|
to power it up */
|
|
maestro_power(card,ACPI_D0);
|
|
|
|
for(i=0;i<NR_DSPS;i++) {
|
|
struct ess_state *s = &card->channels[i];
|
|
|
|
if(s->dev_audio == -1)
|
|
continue;
|
|
|
|
M_printk("maestro: stopping apus for device %d\n",i);
|
|
stop_dac(s);
|
|
stop_adc(s);
|
|
for(j=0;j<6;j++)
|
|
card->apu_map[s->apu[j]][5]=apu_get_register(s,j,5);
|
|
|
|
}
|
|
|
|
/* get rid of interrupts? */
|
|
if( card->dsps_open > 0)
|
|
stop_bob(&card->channels[0]);
|
|
|
|
card->in_suspend++;
|
|
|
|
spin_unlock_irqrestore(&card->lock,flags);
|
|
|
|
/* we trust in the bios to power down the chip on suspend.
|
|
* XXX I'm also not sure that in_suspend will protect
|
|
* against all reg accesses from here on out.
|
|
*/
|
|
return 0;
|
|
}
|
|
static int
|
|
maestro_resume(struct ess_card *card)
|
|
{
|
|
unsigned long flags;
|
|
int i;
|
|
|
|
spin_lock_irqsave(&card->lock,flags); /* over-kill */
|
|
|
|
card->in_suspend = 0;
|
|
|
|
M_printk("maestro: resuming card at %p\n",card);
|
|
|
|
/* restore all our config */
|
|
maestro_config(card);
|
|
/* need to restore the base pointers.. */
|
|
if(card->dmapages)
|
|
set_base_registers(&card->channels[0],card->dmapages);
|
|
|
|
mixer_push_state(card);
|
|
|
|
/* set each channels' apu control registers before
|
|
* restoring audio
|
|
*/
|
|
for(i=0;i<NR_DSPS;i++) {
|
|
struct ess_state *s = &card->channels[i];
|
|
int chan,reg;
|
|
|
|
if(s->dev_audio == -1)
|
|
continue;
|
|
|
|
for(chan = 0 ; chan < 6 ; chan++) {
|
|
wave_set_register(s,s->apu[chan]<<3,s->apu_base[chan]);
|
|
for(reg = 1 ; reg < NR_APU_REGS ; reg++)
|
|
apu_set_register(s,chan,reg,s->card->apu_map[s->apu[chan]][reg]);
|
|
}
|
|
for(chan = 0 ; chan < 6 ; chan++)
|
|
apu_set_register(s,chan,0,s->card->apu_map[s->apu[chan]][0] & 0xFF0F);
|
|
}
|
|
|
|
/* now we flip on the music */
|
|
|
|
if( card->dsps_open <= 0) {
|
|
/* this card's idle */
|
|
maestro_power(card,ACPI_D2);
|
|
} else {
|
|
/* ok, we're actually playing things on
|
|
this card */
|
|
maestro_power(card,ACPI_D0);
|
|
start_bob(&card->channels[0]);
|
|
for(i=0;i<NR_DSPS;i++) {
|
|
struct ess_state *s = &card->channels[i];
|
|
|
|
/* these use the apu_mode, and can handle
|
|
spurious calls */
|
|
start_dac(s);
|
|
start_adc(s);
|
|
}
|
|
}
|
|
|
|
spin_unlock_irqrestore(&card->lock,flags);
|
|
|
|
/* all right, we think things are ready,
|
|
wake up people who were using the device
|
|
when we suspended */
|
|
wake_up(&(card->suspend_queue));
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
maestro_pm_callback(struct pm_dev *dev, pm_request_t rqst, void *data)
|
|
{
|
|
struct ess_card *card = (struct ess_card*) dev->data;
|
|
|
|
if ( ! card ) goto out;
|
|
|
|
M_printk("maestro: pm event 0x%x received for card %p\n", rqst, card);
|
|
|
|
switch (rqst) {
|
|
case PM_SUSPEND:
|
|
maestro_suspend(card);
|
|
break;
|
|
case PM_RESUME:
|
|
maestro_resume(card);
|
|
break;
|
|
/*
|
|
* we'd also like to find out about
|
|
* power level changes because some biosen
|
|
* do mean things to the maestro when they
|
|
* change their power state.
|
|
*/
|
|
}
|
|
out:
|
|
return 0;
|
|
}
|
|
|
|
module_init(init_maestro);
|
|
module_exit(cleanup_maestro);
|