3485 lines
95 KiB
C
3485 lines
95 KiB
C
/*
|
|
* Sound driver for Silicon Graphics 320 and 540 Visual Workstations'
|
|
* onboard audio. See notes in Documentation/sound/oss/vwsnd .
|
|
*
|
|
* Copyright 1999 Silicon Graphics, Inc. All rights reserved.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#undef VWSND_DEBUG /* define for debugging */
|
|
|
|
/*
|
|
* XXX to do -
|
|
*
|
|
* External sync.
|
|
* Rename swbuf, hwbuf, u&i, hwptr&swptr to something rational.
|
|
* Bug - if select() called before read(), pcm_setup() not called.
|
|
* Bug - output doesn't stop soon enough if process killed.
|
|
*/
|
|
|
|
/*
|
|
* Things to test -
|
|
*
|
|
* Will readv/writev work? Write a test.
|
|
*
|
|
* insmod/rmmod 100 million times.
|
|
*
|
|
* Run I/O until int ptrs wrap around (roughly 6.2 hours @ DAT
|
|
* rate).
|
|
*
|
|
* Concurrent threads banging on mixer simultaneously, both UP
|
|
* and SMP kernels. Especially, watch for thread A changing
|
|
* OUTSRC while thread B changes gain -- both write to the same
|
|
* ad1843 register.
|
|
*
|
|
* What happens if a client opens /dev/audio then forks?
|
|
* Do two procs have /dev/audio open? Test.
|
|
*
|
|
* Pump audio through the CD, MIC and line inputs and verify that
|
|
* they mix/mute into the output.
|
|
*
|
|
* Apps:
|
|
* amp
|
|
* mpg123
|
|
* x11amp
|
|
* mxv
|
|
* kmedia
|
|
* esound
|
|
* need more input apps
|
|
*
|
|
* Run tests while bombarding with signals. setitimer(2) will do it... */
|
|
|
|
/*
|
|
* This driver is organized in nine sections.
|
|
* The nine sections are:
|
|
*
|
|
* debug stuff
|
|
* low level lithium access
|
|
* high level lithium access
|
|
* AD1843 access
|
|
* PCM I/O
|
|
* audio driver
|
|
* mixer driver
|
|
* probe/attach/unload
|
|
* initialization and loadable kernel module interface
|
|
*
|
|
* That is roughly the order of increasing abstraction, so forward
|
|
* dependencies are minimal.
|
|
*/
|
|
|
|
/*
|
|
* Locking Notes
|
|
*
|
|
* INC_USE_COUNT and DEC_USE_COUNT keep track of the number of
|
|
* open descriptors to this driver. They store it in vwsnd_use_count.
|
|
* The global device list, vwsnd_dev_list, is immutable when the IN_USE
|
|
* is true.
|
|
*
|
|
* devc->open_lock is a semaphore that is used to enforce the
|
|
* single reader/single writer rule for /dev/audio. The rule is
|
|
* that each device may have at most one reader and one writer.
|
|
* Open will block until the previous client has closed the
|
|
* device, unless O_NONBLOCK is specified.
|
|
*
|
|
* The semaphore devc->io_mutex serializes PCM I/O syscalls. This
|
|
* is unnecessary in Linux 2.2, because the kernel lock
|
|
* serializes read, write, and ioctl globally, but it's there,
|
|
* ready for the brave, new post-kernel-lock world.
|
|
*
|
|
* Locking between interrupt and baselevel is handled by the
|
|
* "lock" spinlock in vwsnd_port (one lock each for read and
|
|
* write). Each half holds the lock just long enough to see what
|
|
* area it owns and update its pointers. See pcm_output() and
|
|
* pcm_input() for most of the gory stuff.
|
|
*
|
|
* devc->mix_mutex serializes all mixer ioctls. This is also
|
|
* redundant because of the kernel lock.
|
|
*
|
|
* The lowest level lock is lith->lithium_lock. It is a
|
|
* spinlock which is held during the two-register tango of
|
|
* reading/writing an AD1843 register. See
|
|
* li_{read,write}_ad1843_reg().
|
|
*/
|
|
|
|
/*
|
|
* Sample Format Notes
|
|
*
|
|
* Lithium's DMA engine has two formats: 16-bit 2's complement
|
|
* and 8-bit unsigned . 16-bit transfers the data unmodified, 2
|
|
* bytes per sample. 8-bit unsigned transfers 1 byte per sample
|
|
* and XORs each byte with 0x80. Lithium can input or output
|
|
* either mono or stereo in either format.
|
|
*
|
|
* The AD1843 has four formats: 16-bit 2's complement, 8-bit
|
|
* unsigned, 8-bit mu-Law and 8-bit A-Law.
|
|
*
|
|
* This driver supports five formats: AFMT_S8, AFMT_U8,
|
|
* AFMT_MU_LAW, AFMT_A_LAW, and AFMT_S16_LE.
|
|
*
|
|
* For AFMT_U8 output, we keep the AD1843 in 16-bit mode, and
|
|
* rely on Lithium's XOR to translate between U8 and S8.
|
|
*
|
|
* For AFMT_S8, AFMT_MU_LAW and AFMT_A_LAW output, we have to XOR
|
|
* the 0x80 bit in software to compensate for Lithium's XOR.
|
|
* This happens in pcm_copy_{in,out}().
|
|
*
|
|
* Changes:
|
|
* 11-10-2000 Bartlomiej Zolnierkiewicz <bkz@linux-ide.org>
|
|
* Added some __init/__exit
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
#include <linux/smp_lock.h>
|
|
#include <linux/wait.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/mutex.h>
|
|
|
|
#include <asm/visws/cobalt.h>
|
|
|
|
#include "sound_config.h"
|
|
|
|
/*****************************************************************************/
|
|
/* debug stuff */
|
|
|
|
#ifdef VWSND_DEBUG
|
|
|
|
static int shut_up = 1;
|
|
|
|
/*
|
|
* dbgassert - called when an assertion fails.
|
|
*/
|
|
|
|
static void dbgassert(const char *fcn, int line, const char *expr)
|
|
{
|
|
if (in_interrupt())
|
|
panic("ASSERTION FAILED IN INTERRUPT, %s:%s:%d %s\n",
|
|
__FILE__, fcn, line, expr);
|
|
else {
|
|
int x;
|
|
printk(KERN_ERR "ASSERTION FAILED, %s:%s:%d %s\n",
|
|
__FILE__, fcn, line, expr);
|
|
x = * (volatile int *) 0; /* force proc to exit */
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Bunch of useful debug macros:
|
|
*
|
|
* ASSERT - print unless e nonzero (panic if in interrupt)
|
|
* DBGDO - include arbitrary code if debugging
|
|
* DBGX - debug print raw (w/o function name)
|
|
* DBGP - debug print w/ function name
|
|
* DBGE - debug print function entry
|
|
* DBGC - debug print function call
|
|
* DBGR - debug print function return
|
|
* DBGXV - debug print raw when verbose
|
|
* DBGPV - debug print when verbose
|
|
* DBGEV - debug print function entry when verbose
|
|
* DBGRV - debug print function return when verbose
|
|
*/
|
|
|
|
#define ASSERT(e) ((e) ? (void) 0 : dbgassert(__func__, __LINE__, #e))
|
|
#define DBGDO(x) x
|
|
#define DBGX(fmt, args...) (in_interrupt() ? 0 : printk(KERN_ERR fmt, ##args))
|
|
#define DBGP(fmt, args...) (DBGX("%s: " fmt, __func__ , ##args))
|
|
#define DBGE(fmt, args...) (DBGX("%s" fmt, __func__ , ##args))
|
|
#define DBGC(rtn) (DBGP("calling %s\n", rtn))
|
|
#define DBGR() (DBGP("returning\n"))
|
|
#define DBGXV(fmt, args...) (shut_up ? 0 : DBGX(fmt, ##args))
|
|
#define DBGPV(fmt, args...) (shut_up ? 0 : DBGP(fmt, ##args))
|
|
#define DBGEV(fmt, args...) (shut_up ? 0 : DBGE(fmt, ##args))
|
|
#define DBGCV(rtn) (shut_up ? 0 : DBGC(rtn))
|
|
#define DBGRV() (shut_up ? 0 : DBGR())
|
|
|
|
#else /* !VWSND_DEBUG */
|
|
|
|
#define ASSERT(e) ((void) 0)
|
|
#define DBGDO(x) /* don't */
|
|
#define DBGX(fmt, args...) ((void) 0)
|
|
#define DBGP(fmt, args...) ((void) 0)
|
|
#define DBGE(fmt, args...) ((void) 0)
|
|
#define DBGC(rtn) ((void) 0)
|
|
#define DBGR() ((void) 0)
|
|
#define DBGPV(fmt, args...) ((void) 0)
|
|
#define DBGXV(fmt, args...) ((void) 0)
|
|
#define DBGEV(fmt, args...) ((void) 0)
|
|
#define DBGCV(rtn) ((void) 0)
|
|
#define DBGRV() ((void) 0)
|
|
|
|
#endif /* !VWSND_DEBUG */
|
|
|
|
/*****************************************************************************/
|
|
/* low level lithium access */
|
|
|
|
/*
|
|
* We need to talk to Lithium registers on three pages. Here are
|
|
* the pages' offsets from the base address (0xFF001000).
|
|
*/
|
|
|
|
enum {
|
|
LI_PAGE0_OFFSET = 0x01000 - 0x1000, /* FF001000 */
|
|
LI_PAGE1_OFFSET = 0x0F000 - 0x1000, /* FF00F000 */
|
|
LI_PAGE2_OFFSET = 0x10000 - 0x1000, /* FF010000 */
|
|
};
|
|
|
|
/* low-level lithium data */
|
|
|
|
typedef struct lithium {
|
|
void * page0; /* virtual addresses */
|
|
void * page1;
|
|
void * page2;
|
|
spinlock_t lock; /* protects codec and UST/MSC access */
|
|
} lithium_t;
|
|
|
|
/*
|
|
* li_destroy destroys the lithium_t structure and vm mappings.
|
|
*/
|
|
|
|
static void li_destroy(lithium_t *lith)
|
|
{
|
|
if (lith->page0) {
|
|
iounmap(lith->page0);
|
|
lith->page0 = NULL;
|
|
}
|
|
if (lith->page1) {
|
|
iounmap(lith->page1);
|
|
lith->page1 = NULL;
|
|
}
|
|
if (lith->page2) {
|
|
iounmap(lith->page2);
|
|
lith->page2 = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* li_create initializes the lithium_t structure and sets up vm mappings
|
|
* to access the registers.
|
|
* Returns 0 on success, -errno on failure.
|
|
*/
|
|
|
|
static int __init li_create(lithium_t *lith, unsigned long baseaddr)
|
|
{
|
|
spin_lock_init(&lith->lock);
|
|
lith->page0 = ioremap_nocache(baseaddr + LI_PAGE0_OFFSET, PAGE_SIZE);
|
|
lith->page1 = ioremap_nocache(baseaddr + LI_PAGE1_OFFSET, PAGE_SIZE);
|
|
lith->page2 = ioremap_nocache(baseaddr + LI_PAGE2_OFFSET, PAGE_SIZE);
|
|
if (!lith->page0 || !lith->page1 || !lith->page2) {
|
|
li_destroy(lith);
|
|
return -ENOMEM;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* basic register accessors - read/write long/byte
|
|
*/
|
|
|
|
static __inline__ unsigned long li_readl(lithium_t *lith, int off)
|
|
{
|
|
return * (volatile unsigned long *) (lith->page0 + off);
|
|
}
|
|
|
|
static __inline__ unsigned char li_readb(lithium_t *lith, int off)
|
|
{
|
|
return * (volatile unsigned char *) (lith->page0 + off);
|
|
}
|
|
|
|
static __inline__ void li_writel(lithium_t *lith, int off, unsigned long val)
|
|
{
|
|
* (volatile unsigned long *) (lith->page0 + off) = val;
|
|
}
|
|
|
|
static __inline__ void li_writeb(lithium_t *lith, int off, unsigned char val)
|
|
{
|
|
* (volatile unsigned char *) (lith->page0 + off) = val;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* High Level Lithium Access */
|
|
|
|
/*
|
|
* Lithium DMA Notes
|
|
*
|
|
* Lithium has two dedicated DMA channels for audio. They are known
|
|
* as comm1 and comm2 (communication areas 1 and 2). Comm1 is for
|
|
* input, and comm2 is for output. Each is controlled by three
|
|
* registers: BASE (base address), CFG (config) and CCTL
|
|
* (config/control).
|
|
*
|
|
* Each DMA channel points to a physically contiguous ring buffer in
|
|
* main memory of up to 8 Kbytes. (This driver always uses 8 Kb.)
|
|
* There are three pointers into the ring buffer: read, write, and
|
|
* trigger. The pointers are 8 bits each. Each pointer points to
|
|
* 32-byte "chunks" of data. The DMA engine moves 32 bytes at a time,
|
|
* so there is no finer-granularity control.
|
|
*
|
|
* In comm1, the hardware updates the write ptr, and software updates
|
|
* the read ptr. In comm2, it's the opposite: hardware updates the
|
|
* read ptr, and software updates the write ptr. I designate the
|
|
* hardware-updated ptr as the hwptr, and the software-updated ptr as
|
|
* the swptr.
|
|
*
|
|
* The trigger ptr and trigger mask are used to trigger interrupts.
|
|
* From the Lithium spec, section 5.6.8, revision of 12/15/1998:
|
|
*
|
|
* Trigger Mask Value
|
|
*
|
|
* A three bit wide field that represents a power of two mask
|
|
* that is used whenever the trigger pointer is compared to its
|
|
* respective read or write pointer. A value of zero here
|
|
* implies a mask of 0xFF and a value of seven implies a mask
|
|
* 0x01. This value can be used to sub-divide the ring buffer
|
|
* into pie sections so that interrupts monitor the progress of
|
|
* hardware from section to section.
|
|
*
|
|
* My interpretation of that is, whenever the hw ptr is updated, it is
|
|
* compared with the trigger ptr, and the result is masked by the
|
|
* trigger mask. (Actually, by the complement of the trigger mask.)
|
|
* If the result is zero, an interrupt is triggered. I.e., interrupt
|
|
* if ((hwptr & ~mask) == (trptr & ~mask)). The mask is formed from
|
|
* the trigger register value as mask = (1 << (8 - tmreg)) - 1.
|
|
*
|
|
* In yet different words, setting tmreg to 0 causes an interrupt after
|
|
* every 256 DMA chunks (8192 bytes) or once per traversal of the
|
|
* ring buffer. Setting it to 7 caues an interrupt every 2 DMA chunks
|
|
* (64 bytes) or 128 times per traversal of the ring buffer.
|
|
*/
|
|
|
|
/* Lithium register offsets and bit definitions */
|
|
|
|
#define LI_HOST_CONTROLLER 0x000
|
|
# define LI_HC_RESET 0x00008000
|
|
# define LI_HC_LINK_ENABLE 0x00004000
|
|
# define LI_HC_LINK_FAILURE 0x00000004
|
|
# define LI_HC_LINK_CODEC 0x00000002
|
|
# define LI_HC_LINK_READY 0x00000001
|
|
|
|
#define LI_INTR_STATUS 0x010
|
|
#define LI_INTR_MASK 0x014
|
|
# define LI_INTR_LINK_ERR 0x00008000
|
|
# define LI_INTR_COMM2_TRIG 0x00000008
|
|
# define LI_INTR_COMM2_UNDERFLOW 0x00000004
|
|
# define LI_INTR_COMM1_TRIG 0x00000002
|
|
# define LI_INTR_COMM1_OVERFLOW 0x00000001
|
|
|
|
#define LI_CODEC_COMMAND 0x018
|
|
# define LI_CC_BUSY 0x00008000
|
|
# define LI_CC_DIR 0x00000080
|
|
# define LI_CC_DIR_RD LI_CC_DIR
|
|
# define LI_CC_DIR_WR (!LI_CC_DIR)
|
|
# define LI_CC_ADDR_MASK 0x0000007F
|
|
|
|
#define LI_CODEC_DATA 0x01C
|
|
|
|
#define LI_COMM1_BASE 0x100
|
|
#define LI_COMM1_CTL 0x104
|
|
# define LI_CCTL_RESET 0x80000000
|
|
# define LI_CCTL_SIZE 0x70000000
|
|
# define LI_CCTL_DMA_ENABLE 0x08000000
|
|
# define LI_CCTL_TMASK 0x07000000 /* trigger mask */
|
|
# define LI_CCTL_TPTR 0x00FF0000 /* trigger pointer */
|
|
# define LI_CCTL_RPTR 0x0000FF00
|
|
# define LI_CCTL_WPTR 0x000000FF
|
|
#define LI_COMM1_CFG 0x108
|
|
# define LI_CCFG_LOCK 0x00008000
|
|
# define LI_CCFG_SLOT 0x00000070
|
|
# define LI_CCFG_DIRECTION 0x00000008
|
|
# define LI_CCFG_DIR_IN (!LI_CCFG_DIRECTION)
|
|
# define LI_CCFG_DIR_OUT LI_CCFG_DIRECTION
|
|
# define LI_CCFG_MODE 0x00000004
|
|
# define LI_CCFG_MODE_MONO (!LI_CCFG_MODE)
|
|
# define LI_CCFG_MODE_STEREO LI_CCFG_MODE
|
|
# define LI_CCFG_FORMAT 0x00000003
|
|
# define LI_CCFG_FMT_8BIT 0x00000000
|
|
# define LI_CCFG_FMT_16BIT 0x00000001
|
|
#define LI_COMM2_BASE 0x10C
|
|
#define LI_COMM2_CTL 0x110
|
|
/* bit definitions are the same as LI_COMM1_CTL */
|
|
#define LI_COMM2_CFG 0x114
|
|
/* bit definitions are the same as LI_COMM1_CFG */
|
|
|
|
#define LI_UST_LOW 0x200 /* 64-bit Unadjusted System Time is */
|
|
#define LI_UST_HIGH 0x204 /* microseconds since boot */
|
|
|
|
#define LI_AUDIO1_UST 0x300 /* UST-MSC pairs */
|
|
#define LI_AUDIO1_MSC 0x304 /* MSC (Media Stream Counter) */
|
|
#define LI_AUDIO2_UST 0x308 /* counts samples actually */
|
|
#define LI_AUDIO2_MSC 0x30C /* processed as of time UST */
|
|
|
|
/*
|
|
* Lithium's DMA engine operates on chunks of 32 bytes. We call that
|
|
* a DMACHUNK.
|
|
*/
|
|
|
|
#define DMACHUNK_SHIFT 5
|
|
#define DMACHUNK_SIZE (1 << DMACHUNK_SHIFT)
|
|
#define BYTES_TO_CHUNKS(bytes) ((bytes) >> DMACHUNK_SHIFT)
|
|
#define CHUNKS_TO_BYTES(chunks) ((chunks) << DMACHUNK_SHIFT)
|
|
|
|
/*
|
|
* Two convenient macros to shift bitfields into/out of position.
|
|
*
|
|
* Observe that (mask & -mask) is (1 << low_set_bit_of(mask)).
|
|
* As long as mask is constant, we trust the compiler will change the
|
|
* multipy and divide into shifts.
|
|
*/
|
|
|
|
#define SHIFT_FIELD(val, mask) (((val) * ((mask) & -(mask))) & (mask))
|
|
#define UNSHIFT_FIELD(val, mask) (((val) & (mask)) / ((mask) & -(mask)))
|
|
|
|
/*
|
|
* dma_chan_desc is invariant information about a Lithium
|
|
* DMA channel. There are two instances, li_comm1 and li_comm2.
|
|
*
|
|
* Note that the CCTL register fields are write ptr and read ptr, but what
|
|
* we care about are which pointer is updated by software and which by
|
|
* hardware.
|
|
*/
|
|
|
|
typedef struct dma_chan_desc {
|
|
int basereg;
|
|
int cfgreg;
|
|
int ctlreg;
|
|
int hwptrreg;
|
|
int swptrreg;
|
|
int ustreg;
|
|
int mscreg;
|
|
unsigned long swptrmask;
|
|
int ad1843_slot;
|
|
int direction; /* LI_CCTL_DIR_IN/OUT */
|
|
} dma_chan_desc_t;
|
|
|
|
static const dma_chan_desc_t li_comm1 = {
|
|
LI_COMM1_BASE, /* base register offset */
|
|
LI_COMM1_CFG, /* config register offset */
|
|
LI_COMM1_CTL, /* control register offset */
|
|
LI_COMM1_CTL + 0, /* hw ptr reg offset (write ptr) */
|
|
LI_COMM1_CTL + 1, /* sw ptr reg offset (read ptr) */
|
|
LI_AUDIO1_UST, /* ust reg offset */
|
|
LI_AUDIO1_MSC, /* msc reg offset */
|
|
LI_CCTL_RPTR, /* sw ptr bitmask in ctlval */
|
|
2, /* ad1843 serial slot */
|
|
LI_CCFG_DIR_IN /* direction */
|
|
};
|
|
|
|
static const dma_chan_desc_t li_comm2 = {
|
|
LI_COMM2_BASE, /* base register offset */
|
|
LI_COMM2_CFG, /* config register offset */
|
|
LI_COMM2_CTL, /* control register offset */
|
|
LI_COMM2_CTL + 1, /* hw ptr reg offset (read ptr) */
|
|
LI_COMM2_CTL + 0, /* sw ptr reg offset (writr ptr) */
|
|
LI_AUDIO2_UST, /* ust reg offset */
|
|
LI_AUDIO2_MSC, /* msc reg offset */
|
|
LI_CCTL_WPTR, /* sw ptr bitmask in ctlval */
|
|
2, /* ad1843 serial slot */
|
|
LI_CCFG_DIR_OUT /* direction */
|
|
};
|
|
|
|
/*
|
|
* dma_chan is variable information about a Lithium DMA channel.
|
|
*
|
|
* The desc field points to invariant information.
|
|
* The lith field points to a lithium_t which is passed
|
|
* to li_read* and li_write* to access the registers.
|
|
* The *val fields shadow the lithium registers' contents.
|
|
*/
|
|
|
|
typedef struct dma_chan {
|
|
const dma_chan_desc_t *desc;
|
|
lithium_t *lith;
|
|
unsigned long baseval;
|
|
unsigned long cfgval;
|
|
unsigned long ctlval;
|
|
} dma_chan_t;
|
|
|
|
/*
|
|
* ustmsc is a UST/MSC pair (Unadjusted System Time/Media Stream Counter).
|
|
* UST is time in microseconds since the system booted, and MSC is a
|
|
* counter that increments with every audio sample.
|
|
*/
|
|
|
|
typedef struct ustmsc {
|
|
unsigned long long ust;
|
|
unsigned long msc;
|
|
} ustmsc_t;
|
|
|
|
/*
|
|
* li_ad1843_wait waits until lithium says the AD1843 register
|
|
* exchange is not busy. Returns 0 on success, -EBUSY on timeout.
|
|
*
|
|
* Locking: must be called with lithium_lock held.
|
|
*/
|
|
|
|
static int li_ad1843_wait(lithium_t *lith)
|
|
{
|
|
unsigned long later = jiffies + 2;
|
|
while (li_readl(lith, LI_CODEC_COMMAND) & LI_CC_BUSY)
|
|
if (time_after_eq(jiffies, later))
|
|
return -EBUSY;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* li_read_ad1843_reg returns the current contents of a 16 bit AD1843 register.
|
|
*
|
|
* Returns unsigned register value on success, -errno on failure.
|
|
*/
|
|
|
|
static int li_read_ad1843_reg(lithium_t *lith, int reg)
|
|
{
|
|
int val;
|
|
|
|
ASSERT(!in_interrupt());
|
|
spin_lock(&lith->lock);
|
|
{
|
|
val = li_ad1843_wait(lith);
|
|
if (val == 0) {
|
|
li_writel(lith, LI_CODEC_COMMAND, LI_CC_DIR_RD | reg);
|
|
val = li_ad1843_wait(lith);
|
|
}
|
|
if (val == 0)
|
|
val = li_readl(lith, LI_CODEC_DATA);
|
|
}
|
|
spin_unlock(&lith->lock);
|
|
|
|
DBGXV("li_read_ad1843_reg(lith=0x%p, reg=%d) returns 0x%04x\n",
|
|
lith, reg, val);
|
|
|
|
return val;
|
|
}
|
|
|
|
/*
|
|
* li_write_ad1843_reg writes the specified value to a 16 bit AD1843 register.
|
|
*/
|
|
|
|
static void li_write_ad1843_reg(lithium_t *lith, int reg, int newval)
|
|
{
|
|
spin_lock(&lith->lock);
|
|
{
|
|
if (li_ad1843_wait(lith) == 0) {
|
|
li_writel(lith, LI_CODEC_DATA, newval);
|
|
li_writel(lith, LI_CODEC_COMMAND, LI_CC_DIR_WR | reg);
|
|
}
|
|
}
|
|
spin_unlock(&lith->lock);
|
|
}
|
|
|
|
/*
|
|
* li_setup_dma calculates all the register settings for DMA in a particular
|
|
* mode. It takes too many arguments.
|
|
*/
|
|
|
|
static void li_setup_dma(dma_chan_t *chan,
|
|
const dma_chan_desc_t *desc,
|
|
lithium_t *lith,
|
|
unsigned long buffer_paddr,
|
|
int bufshift,
|
|
int fragshift,
|
|
int channels,
|
|
int sampsize)
|
|
{
|
|
unsigned long mode, format;
|
|
unsigned long size, tmask;
|
|
|
|
DBGEV("(chan=0x%p, desc=0x%p, lith=0x%p, buffer_paddr=0x%lx, "
|
|
"bufshift=%d, fragshift=%d, channels=%d, sampsize=%d)\n",
|
|
chan, desc, lith, buffer_paddr,
|
|
bufshift, fragshift, channels, sampsize);
|
|
|
|
/* Reset the channel first. */
|
|
|
|
li_writel(lith, desc->ctlreg, LI_CCTL_RESET);
|
|
|
|
ASSERT(channels == 1 || channels == 2);
|
|
if (channels == 2)
|
|
mode = LI_CCFG_MODE_STEREO;
|
|
else
|
|
mode = LI_CCFG_MODE_MONO;
|
|
ASSERT(sampsize == 1 || sampsize == 2);
|
|
if (sampsize == 2)
|
|
format = LI_CCFG_FMT_16BIT;
|
|
else
|
|
format = LI_CCFG_FMT_8BIT;
|
|
chan->desc = desc;
|
|
chan->lith = lith;
|
|
|
|
/*
|
|
* Lithium DMA address register takes a 40-bit physical
|
|
* address, right-shifted by 8 so it fits in 32 bits. Bit 37
|
|
* must be set -- it enables cache coherence.
|
|
*/
|
|
|
|
ASSERT(!(buffer_paddr & 0xFF));
|
|
chan->baseval = (buffer_paddr >> 8) | 1 << (37 - 8);
|
|
|
|
chan->cfgval = (!LI_CCFG_LOCK |
|
|
SHIFT_FIELD(desc->ad1843_slot, LI_CCFG_SLOT) |
|
|
desc->direction |
|
|
mode |
|
|
format);
|
|
|
|
size = bufshift - 6;
|
|
tmask = 13 - fragshift; /* See Lithium DMA Notes above. */
|
|
ASSERT(size >= 2 && size <= 7);
|
|
ASSERT(tmask >= 1 && tmask <= 7);
|
|
chan->ctlval = (!LI_CCTL_RESET |
|
|
SHIFT_FIELD(size, LI_CCTL_SIZE) |
|
|
!LI_CCTL_DMA_ENABLE |
|
|
SHIFT_FIELD(tmask, LI_CCTL_TMASK) |
|
|
SHIFT_FIELD(0, LI_CCTL_TPTR));
|
|
|
|
DBGPV("basereg 0x%x = 0x%lx\n", desc->basereg, chan->baseval);
|
|
DBGPV("cfgreg 0x%x = 0x%lx\n", desc->cfgreg, chan->cfgval);
|
|
DBGPV("ctlreg 0x%x = 0x%lx\n", desc->ctlreg, chan->ctlval);
|
|
|
|
li_writel(lith, desc->basereg, chan->baseval);
|
|
li_writel(lith, desc->cfgreg, chan->cfgval);
|
|
li_writel(lith, desc->ctlreg, chan->ctlval);
|
|
|
|
DBGRV();
|
|
}
|
|
|
|
static void li_shutdown_dma(dma_chan_t *chan)
|
|
{
|
|
lithium_t *lith = chan->lith;
|
|
void * lith1 = lith->page1;
|
|
|
|
DBGEV("(chan=0x%p)\n", chan);
|
|
|
|
chan->ctlval &= ~LI_CCTL_DMA_ENABLE;
|
|
DBGPV("ctlreg 0x%x = 0x%lx\n", chan->desc->ctlreg, chan->ctlval);
|
|
li_writel(lith, chan->desc->ctlreg, chan->ctlval);
|
|
|
|
/*
|
|
* Offset 0x500 on Lithium page 1 is an undocumented,
|
|
* unsupported register that holds the zero sample value.
|
|
* Lithium is supposed to output zero samples when DMA is
|
|
* inactive, and repeat the last sample when DMA underflows.
|
|
* But it has a bug, where, after underflow occurs, the zero
|
|
* sample is not reset.
|
|
*
|
|
* I expect this to break in a future rev of Lithium.
|
|
*/
|
|
|
|
if (lith1 && chan->desc->direction == LI_CCFG_DIR_OUT)
|
|
* (volatile unsigned long *) (lith1 + 0x500) = 0;
|
|
}
|
|
|
|
/*
|
|
* li_activate_dma always starts dma at the beginning of the buffer.
|
|
*
|
|
* N.B., these may be called from interrupt.
|
|
*/
|
|
|
|
static __inline__ void li_activate_dma(dma_chan_t *chan)
|
|
{
|
|
chan->ctlval |= LI_CCTL_DMA_ENABLE;
|
|
DBGPV("ctlval = 0x%lx\n", chan->ctlval);
|
|
li_writel(chan->lith, chan->desc->ctlreg, chan->ctlval);
|
|
}
|
|
|
|
static void li_deactivate_dma(dma_chan_t *chan)
|
|
{
|
|
lithium_t *lith = chan->lith;
|
|
void * lith2 = lith->page2;
|
|
|
|
chan->ctlval &= ~(LI_CCTL_DMA_ENABLE | LI_CCTL_RPTR | LI_CCTL_WPTR);
|
|
DBGPV("ctlval = 0x%lx\n", chan->ctlval);
|
|
DBGPV("ctlreg 0x%x = 0x%lx\n", chan->desc->ctlreg, chan->ctlval);
|
|
li_writel(lith, chan->desc->ctlreg, chan->ctlval);
|
|
|
|
/*
|
|
* Offsets 0x98 and 0x9C on Lithium page 2 are undocumented,
|
|
* unsupported registers that are internal copies of the DMA
|
|
* read and write pointers. Because of a Lithium bug, these
|
|
* registers aren't zeroed correctly when DMA is shut off. So
|
|
* we whack them directly.
|
|
*
|
|
* I expect this to break in a future rev of Lithium.
|
|
*/
|
|
|
|
if (lith2 && chan->desc->direction == LI_CCFG_DIR_OUT) {
|
|
* (volatile unsigned long *) (lith2 + 0x98) = 0;
|
|
* (volatile unsigned long *) (lith2 + 0x9C) = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* read/write the ring buffer pointers. These routines' arguments and results
|
|
* are byte offsets from the beginning of the ring buffer.
|
|
*/
|
|
|
|
static __inline__ int li_read_swptr(dma_chan_t *chan)
|
|
{
|
|
const unsigned long mask = chan->desc->swptrmask;
|
|
|
|
return CHUNKS_TO_BYTES(UNSHIFT_FIELD(chan->ctlval, mask));
|
|
}
|
|
|
|
static __inline__ int li_read_hwptr(dma_chan_t *chan)
|
|
{
|
|
return CHUNKS_TO_BYTES(li_readb(chan->lith, chan->desc->hwptrreg));
|
|
}
|
|
|
|
static __inline__ void li_write_swptr(dma_chan_t *chan, int val)
|
|
{
|
|
const unsigned long mask = chan->desc->swptrmask;
|
|
|
|
ASSERT(!(val & ~CHUNKS_TO_BYTES(0xFF)));
|
|
val = BYTES_TO_CHUNKS(val);
|
|
chan->ctlval = (chan->ctlval & ~mask) | SHIFT_FIELD(val, mask);
|
|
li_writeb(chan->lith, chan->desc->swptrreg, val);
|
|
}
|
|
|
|
/* li_read_USTMSC() returns a UST/MSC pair for the given channel. */
|
|
|
|
static void li_read_USTMSC(dma_chan_t *chan, ustmsc_t *ustmsc)
|
|
{
|
|
lithium_t *lith = chan->lith;
|
|
const dma_chan_desc_t *desc = chan->desc;
|
|
unsigned long now_low, now_high0, now_high1, chan_ust;
|
|
|
|
spin_lock(&lith->lock);
|
|
{
|
|
/*
|
|
* retry until we do all five reads without the
|
|
* high word changing. (High word increments
|
|
* every 2^32 microseconds, i.e., not often)
|
|
*/
|
|
do {
|
|
now_high0 = li_readl(lith, LI_UST_HIGH);
|
|
now_low = li_readl(lith, LI_UST_LOW);
|
|
|
|
/*
|
|
* Lithium guarantees these two reads will be
|
|
* atomic -- ust will not increment after msc
|
|
* is read.
|
|
*/
|
|
|
|
ustmsc->msc = li_readl(lith, desc->mscreg);
|
|
chan_ust = li_readl(lith, desc->ustreg);
|
|
|
|
now_high1 = li_readl(lith, LI_UST_HIGH);
|
|
} while (now_high0 != now_high1);
|
|
}
|
|
spin_unlock(&lith->lock);
|
|
ustmsc->ust = ((unsigned long long) now_high0 << 32 | chan_ust);
|
|
}
|
|
|
|
static void li_enable_interrupts(lithium_t *lith, unsigned int mask)
|
|
{
|
|
DBGEV("(lith=0x%p, mask=0x%x)\n", lith, mask);
|
|
|
|
/* clear any already-pending interrupts. */
|
|
|
|
li_writel(lith, LI_INTR_STATUS, mask);
|
|
|
|
/* enable the interrupts. */
|
|
|
|
mask |= li_readl(lith, LI_INTR_MASK);
|
|
li_writel(lith, LI_INTR_MASK, mask);
|
|
}
|
|
|
|
static void li_disable_interrupts(lithium_t *lith, unsigned int mask)
|
|
{
|
|
unsigned int keepmask;
|
|
|
|
DBGEV("(lith=0x%p, mask=0x%x)\n", lith, mask);
|
|
|
|
/* disable the interrupts */
|
|
|
|
keepmask = li_readl(lith, LI_INTR_MASK) & ~mask;
|
|
li_writel(lith, LI_INTR_MASK, keepmask);
|
|
|
|
/* clear any pending interrupts. */
|
|
|
|
li_writel(lith, LI_INTR_STATUS, mask);
|
|
}
|
|
|
|
/* Get the interrupt status and clear all pending interrupts. */
|
|
|
|
static unsigned int li_get_clear_intr_status(lithium_t *lith)
|
|
{
|
|
unsigned int status;
|
|
|
|
status = li_readl(lith, LI_INTR_STATUS);
|
|
li_writel(lith, LI_INTR_STATUS, ~0);
|
|
return status & li_readl(lith, LI_INTR_MASK);
|
|
}
|
|
|
|
static int li_init(lithium_t *lith)
|
|
{
|
|
/* 1. System power supplies stabilize. */
|
|
|
|
/* 2. Assert the ~RESET signal. */
|
|
|
|
li_writel(lith, LI_HOST_CONTROLLER, LI_HC_RESET);
|
|
udelay(1);
|
|
|
|
/* 3. Deassert the ~RESET signal and enter a wait period to allow
|
|
the AD1843 internal clocks and the external crystal oscillator
|
|
to stabilize. */
|
|
|
|
li_writel(lith, LI_HOST_CONTROLLER, LI_HC_LINK_ENABLE);
|
|
udelay(1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* AD1843 access */
|
|
|
|
/*
|
|
* AD1843 bitfield definitions. All are named as in the AD1843 data
|
|
* sheet, with ad1843_ prepended and individual bit numbers removed.
|
|
*
|
|
* E.g., bits LSS0 through LSS2 become ad1843_LSS.
|
|
*
|
|
* Only the bitfields we need are defined.
|
|
*/
|
|
|
|
typedef struct ad1843_bitfield {
|
|
char reg;
|
|
char lo_bit;
|
|
char nbits;
|
|
} ad1843_bitfield_t;
|
|
|
|
static const ad1843_bitfield_t
|
|
ad1843_PDNO = { 0, 14, 1 }, /* Converter Power-Down Flag */
|
|
ad1843_INIT = { 0, 15, 1 }, /* Clock Initialization Flag */
|
|
ad1843_RIG = { 2, 0, 4 }, /* Right ADC Input Gain */
|
|
ad1843_RMGE = { 2, 4, 1 }, /* Right ADC Mic Gain Enable */
|
|
ad1843_RSS = { 2, 5, 3 }, /* Right ADC Source Select */
|
|
ad1843_LIG = { 2, 8, 4 }, /* Left ADC Input Gain */
|
|
ad1843_LMGE = { 2, 12, 1 }, /* Left ADC Mic Gain Enable */
|
|
ad1843_LSS = { 2, 13, 3 }, /* Left ADC Source Select */
|
|
ad1843_RX1M = { 4, 0, 5 }, /* Right Aux 1 Mix Gain/Atten */
|
|
ad1843_RX1MM = { 4, 7, 1 }, /* Right Aux 1 Mix Mute */
|
|
ad1843_LX1M = { 4, 8, 5 }, /* Left Aux 1 Mix Gain/Atten */
|
|
ad1843_LX1MM = { 4, 15, 1 }, /* Left Aux 1 Mix Mute */
|
|
ad1843_RX2M = { 5, 0, 5 }, /* Right Aux 2 Mix Gain/Atten */
|
|
ad1843_RX2MM = { 5, 7, 1 }, /* Right Aux 2 Mix Mute */
|
|
ad1843_LX2M = { 5, 8, 5 }, /* Left Aux 2 Mix Gain/Atten */
|
|
ad1843_LX2MM = { 5, 15, 1 }, /* Left Aux 2 Mix Mute */
|
|
ad1843_RMCM = { 7, 0, 5 }, /* Right Mic Mix Gain/Atten */
|
|
ad1843_RMCMM = { 7, 7, 1 }, /* Right Mic Mix Mute */
|
|
ad1843_LMCM = { 7, 8, 5 }, /* Left Mic Mix Gain/Atten */
|
|
ad1843_LMCMM = { 7, 15, 1 }, /* Left Mic Mix Mute */
|
|
ad1843_HPOS = { 8, 4, 1 }, /* Headphone Output Voltage Swing */
|
|
ad1843_HPOM = { 8, 5, 1 }, /* Headphone Output Mute */
|
|
ad1843_RDA1G = { 9, 0, 6 }, /* Right DAC1 Analog/Digital Gain */
|
|
ad1843_RDA1GM = { 9, 7, 1 }, /* Right DAC1 Analog Mute */
|
|
ad1843_LDA1G = { 9, 8, 6 }, /* Left DAC1 Analog/Digital Gain */
|
|
ad1843_LDA1GM = { 9, 15, 1 }, /* Left DAC1 Analog Mute */
|
|
ad1843_RDA1AM = { 11, 7, 1 }, /* Right DAC1 Digital Mute */
|
|
ad1843_LDA1AM = { 11, 15, 1 }, /* Left DAC1 Digital Mute */
|
|
ad1843_ADLC = { 15, 0, 2 }, /* ADC Left Sample Rate Source */
|
|
ad1843_ADRC = { 15, 2, 2 }, /* ADC Right Sample Rate Source */
|
|
ad1843_DA1C = { 15, 8, 2 }, /* DAC1 Sample Rate Source */
|
|
ad1843_C1C = { 17, 0, 16 }, /* Clock 1 Sample Rate Select */
|
|
ad1843_C2C = { 20, 0, 16 }, /* Clock 1 Sample Rate Select */
|
|
ad1843_DAADL = { 25, 4, 2 }, /* Digital ADC Left Source Select */
|
|
ad1843_DAADR = { 25, 6, 2 }, /* Digital ADC Right Source Select */
|
|
ad1843_DRSFLT = { 25, 15, 1 }, /* Digital Reampler Filter Mode */
|
|
ad1843_ADLF = { 26, 0, 2 }, /* ADC Left Channel Data Format */
|
|
ad1843_ADRF = { 26, 2, 2 }, /* ADC Right Channel Data Format */
|
|
ad1843_ADTLK = { 26, 4, 1 }, /* ADC Transmit Lock Mode Select */
|
|
ad1843_SCF = { 26, 7, 1 }, /* SCLK Frequency Select */
|
|
ad1843_DA1F = { 26, 8, 2 }, /* DAC1 Data Format Select */
|
|
ad1843_DA1SM = { 26, 14, 1 }, /* DAC1 Stereo/Mono Mode Select */
|
|
ad1843_ADLEN = { 27, 0, 1 }, /* ADC Left Channel Enable */
|
|
ad1843_ADREN = { 27, 1, 1 }, /* ADC Right Channel Enable */
|
|
ad1843_AAMEN = { 27, 4, 1 }, /* Analog to Analog Mix Enable */
|
|
ad1843_ANAEN = { 27, 7, 1 }, /* Analog Channel Enable */
|
|
ad1843_DA1EN = { 27, 8, 1 }, /* DAC1 Enable */
|
|
ad1843_DA2EN = { 27, 9, 1 }, /* DAC2 Enable */
|
|
ad1843_C1EN = { 28, 11, 1 }, /* Clock Generator 1 Enable */
|
|
ad1843_C2EN = { 28, 12, 1 }, /* Clock Generator 2 Enable */
|
|
ad1843_PDNI = { 28, 15, 1 }; /* Converter Power Down */
|
|
|
|
/*
|
|
* The various registers of the AD1843 use three different formats for
|
|
* specifying gain. The ad1843_gain structure parameterizes the
|
|
* formats.
|
|
*/
|
|
|
|
typedef struct ad1843_gain {
|
|
|
|
int negative; /* nonzero if gain is negative. */
|
|
const ad1843_bitfield_t *lfield;
|
|
const ad1843_bitfield_t *rfield;
|
|
|
|
} ad1843_gain_t;
|
|
|
|
static const ad1843_gain_t ad1843_gain_RECLEV
|
|
= { 0, &ad1843_LIG, &ad1843_RIG };
|
|
static const ad1843_gain_t ad1843_gain_LINE
|
|
= { 1, &ad1843_LX1M, &ad1843_RX1M };
|
|
static const ad1843_gain_t ad1843_gain_CD
|
|
= { 1, &ad1843_LX2M, &ad1843_RX2M };
|
|
static const ad1843_gain_t ad1843_gain_MIC
|
|
= { 1, &ad1843_LMCM, &ad1843_RMCM };
|
|
static const ad1843_gain_t ad1843_gain_PCM
|
|
= { 1, &ad1843_LDA1G, &ad1843_RDA1G };
|
|
|
|
/* read the current value of an AD1843 bitfield. */
|
|
|
|
static int ad1843_read_bits(lithium_t *lith, const ad1843_bitfield_t *field)
|
|
{
|
|
int w = li_read_ad1843_reg(lith, field->reg);
|
|
int val = w >> field->lo_bit & ((1 << field->nbits) - 1);
|
|
|
|
DBGXV("ad1843_read_bits(lith=0x%p, field->{%d %d %d}) returns 0x%x\n",
|
|
lith, field->reg, field->lo_bit, field->nbits, val);
|
|
|
|
return val;
|
|
}
|
|
|
|
/*
|
|
* write a new value to an AD1843 bitfield and return the old value.
|
|
*/
|
|
|
|
static int ad1843_write_bits(lithium_t *lith,
|
|
const ad1843_bitfield_t *field,
|
|
int newval)
|
|
{
|
|
int w = li_read_ad1843_reg(lith, field->reg);
|
|
int mask = ((1 << field->nbits) - 1) << field->lo_bit;
|
|
int oldval = (w & mask) >> field->lo_bit;
|
|
int newbits = (newval << field->lo_bit) & mask;
|
|
w = (w & ~mask) | newbits;
|
|
(void) li_write_ad1843_reg(lith, field->reg, w);
|
|
|
|
DBGXV("ad1843_write_bits(lith=0x%p, field->{%d %d %d}, val=0x%x) "
|
|
"returns 0x%x\n",
|
|
lith, field->reg, field->lo_bit, field->nbits, newval,
|
|
oldval);
|
|
|
|
return oldval;
|
|
}
|
|
|
|
/*
|
|
* ad1843_read_multi reads multiple bitfields from the same AD1843
|
|
* register. It uses a single read cycle to do it. (Reading the
|
|
* ad1843 requires 256 bit times at 12.288 MHz, or nearly 20
|
|
* microseconds.)
|
|
*
|
|
* Called ike this.
|
|
*
|
|
* ad1843_read_multi(lith, nfields,
|
|
* &ad1843_FIELD1, &val1,
|
|
* &ad1843_FIELD2, &val2, ...);
|
|
*/
|
|
|
|
static void ad1843_read_multi(lithium_t *lith, int argcount, ...)
|
|
{
|
|
va_list ap;
|
|
const ad1843_bitfield_t *fp;
|
|
int w = 0, mask, *value, reg = -1;
|
|
|
|
va_start(ap, argcount);
|
|
while (--argcount >= 0) {
|
|
fp = va_arg(ap, const ad1843_bitfield_t *);
|
|
value = va_arg(ap, int *);
|
|
if (reg == -1) {
|
|
reg = fp->reg;
|
|
w = li_read_ad1843_reg(lith, reg);
|
|
}
|
|
ASSERT(reg == fp->reg);
|
|
mask = (1 << fp->nbits) - 1;
|
|
*value = w >> fp->lo_bit & mask;
|
|
}
|
|
va_end(ap);
|
|
}
|
|
|
|
/*
|
|
* ad1843_write_multi stores multiple bitfields into the same AD1843
|
|
* register. It uses one read and one write cycle to do it.
|
|
*
|
|
* Called like this.
|
|
*
|
|
* ad1843_write_multi(lith, nfields,
|
|
* &ad1843_FIELD1, val1,
|
|
* &ad1843_FIELF2, val2, ...);
|
|
*/
|
|
|
|
static void ad1843_write_multi(lithium_t *lith, int argcount, ...)
|
|
{
|
|
va_list ap;
|
|
int reg;
|
|
const ad1843_bitfield_t *fp;
|
|
int value;
|
|
int w, m, mask, bits;
|
|
|
|
mask = 0;
|
|
bits = 0;
|
|
reg = -1;
|
|
|
|
va_start(ap, argcount);
|
|
while (--argcount >= 0) {
|
|
fp = va_arg(ap, const ad1843_bitfield_t *);
|
|
value = va_arg(ap, int);
|
|
if (reg == -1)
|
|
reg = fp->reg;
|
|
ASSERT(fp->reg == reg);
|
|
m = ((1 << fp->nbits) - 1) << fp->lo_bit;
|
|
mask |= m;
|
|
bits |= (value << fp->lo_bit) & m;
|
|
}
|
|
va_end(ap);
|
|
ASSERT(!(bits & ~mask));
|
|
if (~mask & 0xFFFF)
|
|
w = li_read_ad1843_reg(lith, reg);
|
|
else
|
|
w = 0;
|
|
w = (w & ~mask) | bits;
|
|
(void) li_write_ad1843_reg(lith, reg, w);
|
|
}
|
|
|
|
/*
|
|
* ad1843_get_gain reads the specified register and extracts the gain value
|
|
* using the supplied gain type. It returns the gain in OSS format.
|
|
*/
|
|
|
|
static int ad1843_get_gain(lithium_t *lith, const ad1843_gain_t *gp)
|
|
{
|
|
int lg, rg;
|
|
unsigned short mask = (1 << gp->lfield->nbits) - 1;
|
|
|
|
ad1843_read_multi(lith, 2, gp->lfield, &lg, gp->rfield, &rg);
|
|
if (gp->negative) {
|
|
lg = mask - lg;
|
|
rg = mask - rg;
|
|
}
|
|
lg = (lg * 100 + (mask >> 1)) / mask;
|
|
rg = (rg * 100 + (mask >> 1)) / mask;
|
|
return lg << 0 | rg << 8;
|
|
}
|
|
|
|
/*
|
|
* Set an audio channel's gain. Converts from OSS format to AD1843's
|
|
* format.
|
|
*
|
|
* Returns the new gain, which may be lower than the old gain.
|
|
*/
|
|
|
|
static int ad1843_set_gain(lithium_t *lith,
|
|
const ad1843_gain_t *gp,
|
|
int newval)
|
|
{
|
|
unsigned short mask = (1 << gp->lfield->nbits) - 1;
|
|
|
|
int lg = newval >> 0 & 0xFF;
|
|
int rg = newval >> 8;
|
|
if (lg < 0 || lg > 100 || rg < 0 || rg > 100)
|
|
return -EINVAL;
|
|
lg = (lg * mask + (mask >> 1)) / 100;
|
|
rg = (rg * mask + (mask >> 1)) / 100;
|
|
if (gp->negative) {
|
|
lg = mask - lg;
|
|
rg = mask - rg;
|
|
}
|
|
ad1843_write_multi(lith, 2, gp->lfield, lg, gp->rfield, rg);
|
|
return ad1843_get_gain(lith, gp);
|
|
}
|
|
|
|
/* Returns the current recording source, in OSS format. */
|
|
|
|
static int ad1843_get_recsrc(lithium_t *lith)
|
|
{
|
|
int ls = ad1843_read_bits(lith, &ad1843_LSS);
|
|
|
|
switch (ls) {
|
|
case 1:
|
|
return SOUND_MASK_MIC;
|
|
case 2:
|
|
return SOUND_MASK_LINE;
|
|
case 3:
|
|
return SOUND_MASK_CD;
|
|
case 6:
|
|
return SOUND_MASK_PCM;
|
|
default:
|
|
ASSERT(0);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Enable/disable digital resample mode in the AD1843.
|
|
*
|
|
* The AD1843 requires that ADL, ADR, DA1 and DA2 be powered down
|
|
* while switching modes. So we save DA1's state (DA2's state is not
|
|
* interesting), power them down, switch into/out of resample mode,
|
|
* power them up, and restore state.
|
|
*
|
|
* This will cause audible glitches if D/A or A/D is going on, so the
|
|
* driver disallows that (in mixer_write_ioctl()).
|
|
*
|
|
* The open question is, is this worth doing? I'm leaving it in,
|
|
* because it's written, but...
|
|
*/
|
|
|
|
static void ad1843_set_resample_mode(lithium_t *lith, int onoff)
|
|
{
|
|
/* Save DA1 mute and gain (addr 9 is DA1 analog gain/attenuation) */
|
|
int save_da1 = li_read_ad1843_reg(lith, 9);
|
|
|
|
/* Power down A/D and D/A. */
|
|
ad1843_write_multi(lith, 4,
|
|
&ad1843_DA1EN, 0,
|
|
&ad1843_DA2EN, 0,
|
|
&ad1843_ADLEN, 0,
|
|
&ad1843_ADREN, 0);
|
|
|
|
/* Switch mode */
|
|
ASSERT(onoff == 0 || onoff == 1);
|
|
ad1843_write_bits(lith, &ad1843_DRSFLT, onoff);
|
|
|
|
/* Power up A/D and D/A. */
|
|
ad1843_write_multi(lith, 3,
|
|
&ad1843_DA1EN, 1,
|
|
&ad1843_ADLEN, 1,
|
|
&ad1843_ADREN, 1);
|
|
|
|
/* Restore DA1 mute and gain. */
|
|
li_write_ad1843_reg(lith, 9, save_da1);
|
|
}
|
|
|
|
/*
|
|
* Set recording source. Arg newsrc specifies an OSS channel mask.
|
|
*
|
|
* The complication is that when we switch into/out of loopback mode
|
|
* (i.e., src = SOUND_MASK_PCM), we change the AD1843 into/out of
|
|
* digital resampling mode.
|
|
*
|
|
* Returns newsrc on success, -errno on failure.
|
|
*/
|
|
|
|
static int ad1843_set_recsrc(lithium_t *lith, int newsrc)
|
|
{
|
|
int bits;
|
|
int oldbits;
|
|
|
|
switch (newsrc) {
|
|
case SOUND_MASK_PCM:
|
|
bits = 6;
|
|
break;
|
|
|
|
case SOUND_MASK_MIC:
|
|
bits = 1;
|
|
break;
|
|
|
|
case SOUND_MASK_LINE:
|
|
bits = 2;
|
|
break;
|
|
|
|
case SOUND_MASK_CD:
|
|
bits = 3;
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
oldbits = ad1843_read_bits(lith, &ad1843_LSS);
|
|
if (newsrc == SOUND_MASK_PCM && oldbits != 6) {
|
|
DBGP("enabling digital resample mode\n");
|
|
ad1843_set_resample_mode(lith, 1);
|
|
ad1843_write_multi(lith, 2,
|
|
&ad1843_DAADL, 2,
|
|
&ad1843_DAADR, 2);
|
|
} else if (newsrc != SOUND_MASK_PCM && oldbits == 6) {
|
|
DBGP("disabling digital resample mode\n");
|
|
ad1843_set_resample_mode(lith, 0);
|
|
ad1843_write_multi(lith, 2,
|
|
&ad1843_DAADL, 0,
|
|
&ad1843_DAADR, 0);
|
|
}
|
|
ad1843_write_multi(lith, 2, &ad1843_LSS, bits, &ad1843_RSS, bits);
|
|
return newsrc;
|
|
}
|
|
|
|
/*
|
|
* Return current output sources, in OSS format.
|
|
*/
|
|
|
|
static int ad1843_get_outsrc(lithium_t *lith)
|
|
{
|
|
int pcm, line, mic, cd;
|
|
|
|
pcm = ad1843_read_bits(lith, &ad1843_LDA1GM) ? 0 : SOUND_MASK_PCM;
|
|
line = ad1843_read_bits(lith, &ad1843_LX1MM) ? 0 : SOUND_MASK_LINE;
|
|
cd = ad1843_read_bits(lith, &ad1843_LX2MM) ? 0 : SOUND_MASK_CD;
|
|
mic = ad1843_read_bits(lith, &ad1843_LMCMM) ? 0 : SOUND_MASK_MIC;
|
|
|
|
return pcm | line | cd | mic;
|
|
}
|
|
|
|
/*
|
|
* Set output sources. Arg is a mask of active sources in OSS format.
|
|
*
|
|
* Returns source mask on success, -errno on failure.
|
|
*/
|
|
|
|
static int ad1843_set_outsrc(lithium_t *lith, int mask)
|
|
{
|
|
int pcm, line, mic, cd;
|
|
|
|
if (mask & ~(SOUND_MASK_PCM | SOUND_MASK_LINE |
|
|
SOUND_MASK_CD | SOUND_MASK_MIC))
|
|
return -EINVAL;
|
|
pcm = (mask & SOUND_MASK_PCM) ? 0 : 1;
|
|
line = (mask & SOUND_MASK_LINE) ? 0 : 1;
|
|
mic = (mask & SOUND_MASK_MIC) ? 0 : 1;
|
|
cd = (mask & SOUND_MASK_CD) ? 0 : 1;
|
|
|
|
ad1843_write_multi(lith, 2, &ad1843_LDA1GM, pcm, &ad1843_RDA1GM, pcm);
|
|
ad1843_write_multi(lith, 2, &ad1843_LX1MM, line, &ad1843_RX1MM, line);
|
|
ad1843_write_multi(lith, 2, &ad1843_LX2MM, cd, &ad1843_RX2MM, cd);
|
|
ad1843_write_multi(lith, 2, &ad1843_LMCMM, mic, &ad1843_RMCMM, mic);
|
|
|
|
return mask;
|
|
}
|
|
|
|
/* Setup ad1843 for D/A conversion. */
|
|
|
|
static void ad1843_setup_dac(lithium_t *lith,
|
|
int framerate,
|
|
int fmt,
|
|
int channels)
|
|
{
|
|
int ad_fmt = 0, ad_mode = 0;
|
|
|
|
DBGEV("(lith=0x%p, framerate=%d, fmt=%d, channels=%d)\n",
|
|
lith, framerate, fmt, channels);
|
|
|
|
switch (fmt) {
|
|
case AFMT_S8: ad_fmt = 1; break;
|
|
case AFMT_U8: ad_fmt = 1; break;
|
|
case AFMT_S16_LE: ad_fmt = 1; break;
|
|
case AFMT_MU_LAW: ad_fmt = 2; break;
|
|
case AFMT_A_LAW: ad_fmt = 3; break;
|
|
default: ASSERT(0);
|
|
}
|
|
|
|
switch (channels) {
|
|
case 2: ad_mode = 0; break;
|
|
case 1: ad_mode = 1; break;
|
|
default: ASSERT(0);
|
|
}
|
|
|
|
DBGPV("ad_mode = %d, ad_fmt = %d\n", ad_mode, ad_fmt);
|
|
ASSERT(framerate >= 4000 && framerate <= 49000);
|
|
ad1843_write_bits(lith, &ad1843_C1C, framerate);
|
|
ad1843_write_multi(lith, 2,
|
|
&ad1843_DA1SM, ad_mode, &ad1843_DA1F, ad_fmt);
|
|
}
|
|
|
|
static void ad1843_shutdown_dac(lithium_t *lith)
|
|
{
|
|
ad1843_write_bits(lith, &ad1843_DA1F, 1);
|
|
}
|
|
|
|
static void ad1843_setup_adc(lithium_t *lith, int framerate, int fmt, int channels)
|
|
{
|
|
int da_fmt = 0;
|
|
|
|
DBGEV("(lith=0x%p, framerate=%d, fmt=%d, channels=%d)\n",
|
|
lith, framerate, fmt, channels);
|
|
|
|
switch (fmt) {
|
|
case AFMT_S8: da_fmt = 1; break;
|
|
case AFMT_U8: da_fmt = 1; break;
|
|
case AFMT_S16_LE: da_fmt = 1; break;
|
|
case AFMT_MU_LAW: da_fmt = 2; break;
|
|
case AFMT_A_LAW: da_fmt = 3; break;
|
|
default: ASSERT(0);
|
|
}
|
|
|
|
DBGPV("da_fmt = %d\n", da_fmt);
|
|
ASSERT(framerate >= 4000 && framerate <= 49000);
|
|
ad1843_write_bits(lith, &ad1843_C2C, framerate);
|
|
ad1843_write_multi(lith, 2,
|
|
&ad1843_ADLF, da_fmt, &ad1843_ADRF, da_fmt);
|
|
}
|
|
|
|
static void ad1843_shutdown_adc(lithium_t *lith)
|
|
{
|
|
/* nothing to do */
|
|
}
|
|
|
|
/*
|
|
* Fully initialize the ad1843. As described in the AD1843 data
|
|
* sheet, section "START-UP SEQUENCE". The numbered comments are
|
|
* subsection headings from the data sheet. See the data sheet, pages
|
|
* 52-54, for more info.
|
|
*
|
|
* return 0 on success, -errno on failure. */
|
|
|
|
static int __init ad1843_init(lithium_t *lith)
|
|
{
|
|
unsigned long later;
|
|
int err;
|
|
|
|
err = li_init(lith);
|
|
if (err)
|
|
return err;
|
|
|
|
if (ad1843_read_bits(lith, &ad1843_INIT) != 0) {
|
|
printk(KERN_ERR "vwsnd sound: AD1843 won't initialize\n");
|
|
return -EIO;
|
|
}
|
|
|
|
ad1843_write_bits(lith, &ad1843_SCF, 1);
|
|
|
|
/* 4. Put the conversion resources into standby. */
|
|
|
|
ad1843_write_bits(lith, &ad1843_PDNI, 0);
|
|
later = jiffies + HZ / 2; /* roughly half a second */
|
|
DBGDO(shut_up++);
|
|
while (ad1843_read_bits(lith, &ad1843_PDNO)) {
|
|
if (time_after(jiffies, later)) {
|
|
printk(KERN_ERR
|
|
"vwsnd audio: AD1843 won't power up\n");
|
|
return -EIO;
|
|
}
|
|
schedule();
|
|
}
|
|
DBGDO(shut_up--);
|
|
|
|
/* 5. Power up the clock generators and enable clock output pins. */
|
|
|
|
ad1843_write_multi(lith, 2, &ad1843_C1EN, 1, &ad1843_C2EN, 1);
|
|
|
|
/* 6. Configure conversion resources while they are in standby. */
|
|
|
|
/* DAC1 uses clock 1 as source, ADC uses clock 2. Always. */
|
|
|
|
ad1843_write_multi(lith, 3,
|
|
&ad1843_DA1C, 1,
|
|
&ad1843_ADLC, 2,
|
|
&ad1843_ADRC, 2);
|
|
|
|
/* 7. Enable conversion resources. */
|
|
|
|
ad1843_write_bits(lith, &ad1843_ADTLK, 1);
|
|
ad1843_write_multi(lith, 5,
|
|
&ad1843_ANAEN, 1,
|
|
&ad1843_AAMEN, 1,
|
|
&ad1843_DA1EN, 1,
|
|
&ad1843_ADLEN, 1,
|
|
&ad1843_ADREN, 1);
|
|
|
|
/* 8. Configure conversion resources while they are enabled. */
|
|
|
|
ad1843_write_bits(lith, &ad1843_DA1C, 1);
|
|
|
|
/* Unmute all channels. */
|
|
|
|
ad1843_set_outsrc(lith,
|
|
(SOUND_MASK_PCM | SOUND_MASK_LINE |
|
|
SOUND_MASK_MIC | SOUND_MASK_CD));
|
|
ad1843_write_multi(lith, 2, &ad1843_LDA1AM, 0, &ad1843_RDA1AM, 0);
|
|
|
|
/* Set default recording source to Line In and set
|
|
* mic gain to +20 dB.
|
|
*/
|
|
|
|
ad1843_set_recsrc(lith, SOUND_MASK_LINE);
|
|
ad1843_write_multi(lith, 2, &ad1843_LMGE, 1, &ad1843_RMGE, 1);
|
|
|
|
/* Set Speaker Out level to +/- 4V and unmute it. */
|
|
|
|
ad1843_write_multi(lith, 2, &ad1843_HPOS, 1, &ad1843_HPOM, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* PCM I/O */
|
|
|
|
#define READ_INTR_MASK (LI_INTR_COMM1_TRIG | LI_INTR_COMM1_OVERFLOW)
|
|
#define WRITE_INTR_MASK (LI_INTR_COMM2_TRIG | LI_INTR_COMM2_UNDERFLOW)
|
|
|
|
typedef enum vwsnd_port_swstate { /* software state */
|
|
SW_OFF,
|
|
SW_INITIAL,
|
|
SW_RUN,
|
|
SW_DRAIN,
|
|
} vwsnd_port_swstate_t;
|
|
|
|
typedef enum vwsnd_port_hwstate { /* hardware state */
|
|
HW_STOPPED,
|
|
HW_RUNNING,
|
|
} vwsnd_port_hwstate_t;
|
|
|
|
/*
|
|
* These flags are read by ISR, but only written at baseline.
|
|
*/
|
|
|
|
typedef enum vwsnd_port_flags {
|
|
DISABLED = 1 << 0,
|
|
ERFLOWN = 1 << 1, /* overflown or underflown */
|
|
HW_BUSY = 1 << 2,
|
|
} vwsnd_port_flags_t;
|
|
|
|
/*
|
|
* vwsnd_port is the per-port data structure. Each device has two
|
|
* ports, one for input and one for output.
|
|
*
|
|
* Locking:
|
|
*
|
|
* port->lock protects: hwstate, flags, swb_[iu]_avail.
|
|
*
|
|
* devc->io_mutex protects: swstate, sw_*, swb_[iu]_idx.
|
|
*
|
|
* everything else is only written by open/release or
|
|
* pcm_{setup,shutdown}(), which are serialized by a
|
|
* combination of devc->open_mutex and devc->io_mutex.
|
|
*/
|
|
|
|
typedef struct vwsnd_port {
|
|
|
|
spinlock_t lock;
|
|
wait_queue_head_t queue;
|
|
vwsnd_port_swstate_t swstate;
|
|
vwsnd_port_hwstate_t hwstate;
|
|
vwsnd_port_flags_t flags;
|
|
|
|
int sw_channels;
|
|
int sw_samplefmt;
|
|
int sw_framerate;
|
|
int sample_size;
|
|
int frame_size;
|
|
unsigned int zero_word; /* zero for the sample format */
|
|
|
|
int sw_fragshift;
|
|
int sw_fragcount;
|
|
int sw_subdivshift;
|
|
|
|
unsigned int hw_fragshift;
|
|
unsigned int hw_fragsize;
|
|
unsigned int hw_fragcount;
|
|
|
|
int hwbuf_size;
|
|
unsigned long hwbuf_paddr;
|
|
unsigned long hwbuf_vaddr;
|
|
void * hwbuf; /* hwbuf == hwbuf_vaddr */
|
|
int hwbuf_max; /* max bytes to preload */
|
|
|
|
void * swbuf;
|
|
unsigned int swbuf_size; /* size in bytes */
|
|
unsigned int swb_u_idx; /* index of next user byte */
|
|
unsigned int swb_i_idx; /* index of next intr byte */
|
|
unsigned int swb_u_avail; /* # bytes avail to user */
|
|
unsigned int swb_i_avail; /* # bytes avail to intr */
|
|
|
|
dma_chan_t chan;
|
|
|
|
/* Accounting */
|
|
|
|
int byte_count;
|
|
int frag_count;
|
|
int MSC_offset;
|
|
|
|
} vwsnd_port_t;
|
|
|
|
/* vwsnd_dev is the per-device data structure. */
|
|
|
|
typedef struct vwsnd_dev {
|
|
struct vwsnd_dev *next_dev;
|
|
int audio_minor; /* minor number of audio device */
|
|
int mixer_minor; /* minor number of mixer device */
|
|
|
|
struct mutex open_mutex;
|
|
struct mutex io_mutex;
|
|
struct mutex mix_mutex;
|
|
mode_t open_mode;
|
|
wait_queue_head_t open_wait;
|
|
|
|
lithium_t lith;
|
|
|
|
vwsnd_port_t rport;
|
|
vwsnd_port_t wport;
|
|
} vwsnd_dev_t;
|
|
|
|
static vwsnd_dev_t *vwsnd_dev_list; /* linked list of all devices */
|
|
|
|
static atomic_t vwsnd_use_count = ATOMIC_INIT(0);
|
|
|
|
# define INC_USE_COUNT (atomic_inc(&vwsnd_use_count))
|
|
# define DEC_USE_COUNT (atomic_dec(&vwsnd_use_count))
|
|
# define IN_USE (atomic_read(&vwsnd_use_count) != 0)
|
|
|
|
/*
|
|
* Lithium can only DMA multiples of 32 bytes. Its DMA buffer may
|
|
* be up to 8 Kb. This driver always uses 8 Kb.
|
|
*
|
|
* Memory bug workaround -- I'm not sure what's going on here, but
|
|
* somehow pcm_copy_out() was triggering segv's going on to the next
|
|
* page of the hw buffer. So, I make the hw buffer one size bigger
|
|
* than we actually use. That way, the following page is allocated
|
|
* and mapped, and no error. I suspect that something is broken
|
|
* in Cobalt, but haven't really investigated. HBO is the actual
|
|
* size of the buffer, and HWBUF_ORDER is what we allocate.
|
|
*/
|
|
|
|
#define HWBUF_SHIFT 13
|
|
#define HWBUF_SIZE (1 << HWBUF_SHIFT)
|
|
# define HBO (HWBUF_SHIFT > PAGE_SHIFT ? HWBUF_SHIFT - PAGE_SHIFT : 0)
|
|
# define HWBUF_ORDER (HBO + 1) /* next size bigger */
|
|
#define MIN_SPEED 4000
|
|
#define MAX_SPEED 49000
|
|
|
|
#define MIN_FRAGSHIFT (DMACHUNK_SHIFT + 1)
|
|
#define MAX_FRAGSHIFT (PAGE_SHIFT)
|
|
#define MIN_FRAGSIZE (1 << MIN_FRAGSHIFT)
|
|
#define MAX_FRAGSIZE (1 << MAX_FRAGSHIFT)
|
|
#define MIN_FRAGCOUNT(fragsize) 3
|
|
#define MAX_FRAGCOUNT(fragsize) (32 * PAGE_SIZE / (fragsize))
|
|
#define DEFAULT_FRAGSHIFT 12
|
|
#define DEFAULT_FRAGCOUNT 16
|
|
#define DEFAULT_SUBDIVSHIFT 0
|
|
|
|
/*
|
|
* The software buffer (swbuf) is a ring buffer shared between user
|
|
* level and interrupt level. Each level owns some of the bytes in
|
|
* the buffer, and may give bytes away by calling swb_inc_{u,i}().
|
|
* User level calls _u for user, and interrupt level calls _i for
|
|
* interrupt.
|
|
*
|
|
* port->swb_{u,i}_avail is the number of bytes available to that level.
|
|
*
|
|
* port->swb_{u,i}_idx is the index of the first available byte in the
|
|
* buffer.
|
|
*
|
|
* Each level calls swb_inc_{u,i}() to atomically increment its index,
|
|
* recalculate the number of bytes available for both sides, and
|
|
* return the number of bytes available. Since each side can only
|
|
* give away bytes, the other side can only increase the number of
|
|
* bytes available to this side. Each side updates its own index
|
|
* variable, swb_{u,i}_idx, so no lock is needed to read it.
|
|
*
|
|
* To query the number of bytes available, call swb_inc_{u,i} with an
|
|
* increment of zero.
|
|
*/
|
|
|
|
static __inline__ unsigned int __swb_inc_u(vwsnd_port_t *port, int inc)
|
|
{
|
|
if (inc) {
|
|
port->swb_u_idx += inc;
|
|
port->swb_u_idx %= port->swbuf_size;
|
|
port->swb_u_avail -= inc;
|
|
port->swb_i_avail += inc;
|
|
}
|
|
return port->swb_u_avail;
|
|
}
|
|
|
|
static __inline__ unsigned int swb_inc_u(vwsnd_port_t *port, int inc)
|
|
{
|
|
unsigned long flags;
|
|
unsigned int ret;
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
{
|
|
ret = __swb_inc_u(port, inc);
|
|
}
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
return ret;
|
|
}
|
|
|
|
static __inline__ unsigned int __swb_inc_i(vwsnd_port_t *port, int inc)
|
|
{
|
|
if (inc) {
|
|
port->swb_i_idx += inc;
|
|
port->swb_i_idx %= port->swbuf_size;
|
|
port->swb_i_avail -= inc;
|
|
port->swb_u_avail += inc;
|
|
}
|
|
return port->swb_i_avail;
|
|
}
|
|
|
|
static __inline__ unsigned int swb_inc_i(vwsnd_port_t *port, int inc)
|
|
{
|
|
unsigned long flags;
|
|
unsigned int ret;
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
{
|
|
ret = __swb_inc_i(port, inc);
|
|
}
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* pcm_setup - this routine initializes all port state after
|
|
* mode-setting ioctls have been done, but before the first I/O is
|
|
* done.
|
|
*
|
|
* Locking: called with devc->io_mutex held.
|
|
*
|
|
* Returns 0 on success, -errno on failure.
|
|
*/
|
|
|
|
static int pcm_setup(vwsnd_dev_t *devc,
|
|
vwsnd_port_t *rport,
|
|
vwsnd_port_t *wport)
|
|
{
|
|
vwsnd_port_t *aport = rport ? rport : wport;
|
|
int sample_size;
|
|
unsigned int zero_word;
|
|
|
|
DBGEV("(devc=0x%p, rport=0x%p, wport=0x%p)\n", devc, rport, wport);
|
|
|
|
ASSERT(aport != NULL);
|
|
if (aport->swbuf != NULL)
|
|
return 0;
|
|
switch (aport->sw_samplefmt) {
|
|
case AFMT_MU_LAW:
|
|
sample_size = 1;
|
|
zero_word = 0xFFFFFFFF ^ 0x80808080;
|
|
break;
|
|
|
|
case AFMT_A_LAW:
|
|
sample_size = 1;
|
|
zero_word = 0xD5D5D5D5 ^ 0x80808080;
|
|
break;
|
|
|
|
case AFMT_U8:
|
|
sample_size = 1;
|
|
zero_word = 0x80808080;
|
|
break;
|
|
|
|
case AFMT_S8:
|
|
sample_size = 1;
|
|
zero_word = 0x00000000;
|
|
break;
|
|
|
|
case AFMT_S16_LE:
|
|
sample_size = 2;
|
|
zero_word = 0x00000000;
|
|
break;
|
|
|
|
default:
|
|
sample_size = 0; /* prevent compiler warning */
|
|
zero_word = 0;
|
|
ASSERT(0);
|
|
}
|
|
aport->sample_size = sample_size;
|
|
aport->zero_word = zero_word;
|
|
aport->frame_size = aport->sw_channels * aport->sample_size;
|
|
aport->hw_fragshift = aport->sw_fragshift - aport->sw_subdivshift;
|
|
aport->hw_fragsize = 1 << aport->hw_fragshift;
|
|
aport->hw_fragcount = aport->sw_fragcount << aport->sw_subdivshift;
|
|
ASSERT(aport->hw_fragsize >= MIN_FRAGSIZE);
|
|
ASSERT(aport->hw_fragsize <= MAX_FRAGSIZE);
|
|
ASSERT(aport->hw_fragcount >= MIN_FRAGCOUNT(aport->hw_fragsize));
|
|
ASSERT(aport->hw_fragcount <= MAX_FRAGCOUNT(aport->hw_fragsize));
|
|
if (rport) {
|
|
int hwfrags, swfrags;
|
|
rport->hwbuf_max = aport->hwbuf_size - DMACHUNK_SIZE;
|
|
hwfrags = rport->hwbuf_max >> aport->hw_fragshift;
|
|
swfrags = aport->hw_fragcount - hwfrags;
|
|
if (swfrags < 2)
|
|
swfrags = 2;
|
|
rport->swbuf_size = swfrags * aport->hw_fragsize;
|
|
DBGPV("hwfrags = %d, swfrags = %d\n", hwfrags, swfrags);
|
|
DBGPV("read hwbuf_max = %d, swbuf_size = %d\n",
|
|
rport->hwbuf_max, rport->swbuf_size);
|
|
}
|
|
if (wport) {
|
|
int hwfrags, swfrags;
|
|
int total_bytes = aport->hw_fragcount * aport->hw_fragsize;
|
|
wport->hwbuf_max = aport->hwbuf_size - DMACHUNK_SIZE;
|
|
if (wport->hwbuf_max > total_bytes)
|
|
wport->hwbuf_max = total_bytes;
|
|
hwfrags = wport->hwbuf_max >> aport->hw_fragshift;
|
|
DBGPV("hwfrags = %d\n", hwfrags);
|
|
swfrags = aport->hw_fragcount - hwfrags;
|
|
if (swfrags < 2)
|
|
swfrags = 2;
|
|
wport->swbuf_size = swfrags * aport->hw_fragsize;
|
|
DBGPV("hwfrags = %d, swfrags = %d\n", hwfrags, swfrags);
|
|
DBGPV("write hwbuf_max = %d, swbuf_size = %d\n",
|
|
wport->hwbuf_max, wport->swbuf_size);
|
|
}
|
|
|
|
aport->swb_u_idx = 0;
|
|
aport->swb_i_idx = 0;
|
|
aport->byte_count = 0;
|
|
|
|
/*
|
|
* Is this a Cobalt bug? We need to make this buffer extend
|
|
* one page further than we actually use -- somehow memcpy
|
|
* causes an exceptoin otherwise. I suspect there's a bug in
|
|
* Cobalt (or somewhere) where it's generating a fault on a
|
|
* speculative load or something. Obviously, I haven't taken
|
|
* the time to track it down.
|
|
*/
|
|
|
|
aport->swbuf = vmalloc(aport->swbuf_size + PAGE_SIZE);
|
|
if (!aport->swbuf)
|
|
return -ENOMEM;
|
|
if (rport && wport) {
|
|
ASSERT(aport == rport);
|
|
ASSERT(wport->swbuf == NULL);
|
|
/* One extra page - see comment above. */
|
|
wport->swbuf = vmalloc(aport->swbuf_size + PAGE_SIZE);
|
|
if (!wport->swbuf) {
|
|
vfree(aport->swbuf);
|
|
aport->swbuf = NULL;
|
|
return -ENOMEM;
|
|
}
|
|
wport->sample_size = rport->sample_size;
|
|
wport->zero_word = rport->zero_word;
|
|
wport->frame_size = rport->frame_size;
|
|
wport->hw_fragshift = rport->hw_fragshift;
|
|
wport->hw_fragsize = rport->hw_fragsize;
|
|
wport->hw_fragcount = rport->hw_fragcount;
|
|
wport->swbuf_size = rport->swbuf_size;
|
|
wport->hwbuf_max = rport->hwbuf_max;
|
|
wport->swb_u_idx = rport->swb_u_idx;
|
|
wport->swb_i_idx = rport->swb_i_idx;
|
|
wport->byte_count = rport->byte_count;
|
|
}
|
|
if (rport) {
|
|
rport->swb_u_avail = 0;
|
|
rport->swb_i_avail = rport->swbuf_size;
|
|
rport->swstate = SW_RUN;
|
|
li_setup_dma(&rport->chan,
|
|
&li_comm1,
|
|
&devc->lith,
|
|
rport->hwbuf_paddr,
|
|
HWBUF_SHIFT,
|
|
rport->hw_fragshift,
|
|
rport->sw_channels,
|
|
rport->sample_size);
|
|
ad1843_setup_adc(&devc->lith,
|
|
rport->sw_framerate,
|
|
rport->sw_samplefmt,
|
|
rport->sw_channels);
|
|
li_enable_interrupts(&devc->lith, READ_INTR_MASK);
|
|
if (!(rport->flags & DISABLED)) {
|
|
ustmsc_t ustmsc;
|
|
rport->hwstate = HW_RUNNING;
|
|
li_activate_dma(&rport->chan);
|
|
li_read_USTMSC(&rport->chan, &ustmsc);
|
|
rport->MSC_offset = ustmsc.msc;
|
|
}
|
|
}
|
|
if (wport) {
|
|
if (wport->hwbuf_max > wport->swbuf_size)
|
|
wport->hwbuf_max = wport->swbuf_size;
|
|
wport->flags &= ~ERFLOWN;
|
|
wport->swb_u_avail = wport->swbuf_size;
|
|
wport->swb_i_avail = 0;
|
|
wport->swstate = SW_RUN;
|
|
li_setup_dma(&wport->chan,
|
|
&li_comm2,
|
|
&devc->lith,
|
|
wport->hwbuf_paddr,
|
|
HWBUF_SHIFT,
|
|
wport->hw_fragshift,
|
|
wport->sw_channels,
|
|
wport->sample_size);
|
|
ad1843_setup_dac(&devc->lith,
|
|
wport->sw_framerate,
|
|
wport->sw_samplefmt,
|
|
wport->sw_channels);
|
|
li_enable_interrupts(&devc->lith, WRITE_INTR_MASK);
|
|
}
|
|
DBGRV();
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* pcm_shutdown_port - shut down one port (direction) for PCM I/O.
|
|
* Only called from pcm_shutdown.
|
|
*/
|
|
|
|
static void pcm_shutdown_port(vwsnd_dev_t *devc,
|
|
vwsnd_port_t *aport,
|
|
unsigned int mask)
|
|
{
|
|
unsigned long flags;
|
|
vwsnd_port_hwstate_t hwstate;
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
|
aport->swstate = SW_INITIAL;
|
|
add_wait_queue(&aport->queue, &wait);
|
|
while (1) {
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
spin_lock_irqsave(&aport->lock, flags);
|
|
{
|
|
hwstate = aport->hwstate;
|
|
}
|
|
spin_unlock_irqrestore(&aport->lock, flags);
|
|
if (hwstate == HW_STOPPED)
|
|
break;
|
|
schedule();
|
|
}
|
|
current->state = TASK_RUNNING;
|
|
remove_wait_queue(&aport->queue, &wait);
|
|
li_disable_interrupts(&devc->lith, mask);
|
|
if (aport == &devc->rport)
|
|
ad1843_shutdown_adc(&devc->lith);
|
|
else /* aport == &devc->wport) */
|
|
ad1843_shutdown_dac(&devc->lith);
|
|
li_shutdown_dma(&aport->chan);
|
|
vfree(aport->swbuf);
|
|
aport->swbuf = NULL;
|
|
aport->byte_count = 0;
|
|
}
|
|
|
|
/*
|
|
* pcm_shutdown undoes what pcm_setup did.
|
|
* Also sets the ports' swstate to newstate.
|
|
*/
|
|
|
|
static void pcm_shutdown(vwsnd_dev_t *devc,
|
|
vwsnd_port_t *rport,
|
|
vwsnd_port_t *wport)
|
|
{
|
|
DBGEV("(devc=0x%p, rport=0x%p, wport=0x%p)\n", devc, rport, wport);
|
|
|
|
if (rport && rport->swbuf) {
|
|
DBGPV("shutting down rport\n");
|
|
pcm_shutdown_port(devc, rport, READ_INTR_MASK);
|
|
}
|
|
if (wport && wport->swbuf) {
|
|
DBGPV("shutting down wport\n");
|
|
pcm_shutdown_port(devc, wport, WRITE_INTR_MASK);
|
|
}
|
|
DBGRV();
|
|
}
|
|
|
|
static void pcm_copy_in(vwsnd_port_t *rport, int swidx, int hwidx, int nb)
|
|
{
|
|
char *src = rport->hwbuf + hwidx;
|
|
char *dst = rport->swbuf + swidx;
|
|
int fmt = rport->sw_samplefmt;
|
|
|
|
DBGPV("swidx = %d, hwidx = %d\n", swidx, hwidx);
|
|
ASSERT(rport->hwbuf != NULL);
|
|
ASSERT(rport->swbuf != NULL);
|
|
ASSERT(nb > 0 && (nb % 32) == 0);
|
|
ASSERT(swidx % 32 == 0 && hwidx % 32 == 0);
|
|
ASSERT(swidx >= 0 && swidx + nb <= rport->swbuf_size);
|
|
ASSERT(hwidx >= 0 && hwidx + nb <= rport->hwbuf_size);
|
|
|
|
if (fmt == AFMT_MU_LAW || fmt == AFMT_A_LAW || fmt == AFMT_S8) {
|
|
|
|
/* See Sample Format Notes above. */
|
|
|
|
char *end = src + nb;
|
|
while (src < end)
|
|
*dst++ = *src++ ^ 0x80;
|
|
} else
|
|
memcpy(dst, src, nb);
|
|
}
|
|
|
|
static void pcm_copy_out(vwsnd_port_t *wport, int swidx, int hwidx, int nb)
|
|
{
|
|
char *src = wport->swbuf + swidx;
|
|
char *dst = wport->hwbuf + hwidx;
|
|
int fmt = wport->sw_samplefmt;
|
|
|
|
ASSERT(nb > 0 && (nb % 32) == 0);
|
|
ASSERT(wport->hwbuf != NULL);
|
|
ASSERT(wport->swbuf != NULL);
|
|
ASSERT(swidx % 32 == 0 && hwidx % 32 == 0);
|
|
ASSERT(swidx >= 0 && swidx + nb <= wport->swbuf_size);
|
|
ASSERT(hwidx >= 0 && hwidx + nb <= wport->hwbuf_size);
|
|
if (fmt == AFMT_MU_LAW || fmt == AFMT_A_LAW || fmt == AFMT_S8) {
|
|
|
|
/* See Sample Format Notes above. */
|
|
|
|
char *end = src + nb;
|
|
while (src < end)
|
|
*dst++ = *src++ ^ 0x80;
|
|
} else
|
|
memcpy(dst, src, nb);
|
|
}
|
|
|
|
/*
|
|
* pcm_output() is called both from baselevel and from interrupt level.
|
|
* This is where audio frames are copied into the hardware-accessible
|
|
* ring buffer.
|
|
*
|
|
* Locking note: The part of this routine that figures out what to do
|
|
* holds wport->lock. The longer part releases wport->lock, but sets
|
|
* wport->flags & HW_BUSY. Afterward, it reacquires wport->lock, and
|
|
* checks for more work to do.
|
|
*
|
|
* If another thread calls pcm_output() while HW_BUSY is set, it
|
|
* returns immediately, knowing that the thread that set HW_BUSY will
|
|
* look for more work to do before returning.
|
|
*
|
|
* This has the advantage that port->lock is held for several short
|
|
* periods instead of one long period. Also, when pcm_output is
|
|
* called from base level, it reenables interrupts.
|
|
*/
|
|
|
|
static void pcm_output(vwsnd_dev_t *devc, int erflown, int nb)
|
|
{
|
|
vwsnd_port_t *wport = &devc->wport;
|
|
const int hwmax = wport->hwbuf_max;
|
|
const int hwsize = wport->hwbuf_size;
|
|
const int swsize = wport->swbuf_size;
|
|
const int fragsize = wport->hw_fragsize;
|
|
unsigned long iflags;
|
|
|
|
DBGEV("(devc=0x%p, erflown=%d, nb=%d)\n", devc, erflown, nb);
|
|
spin_lock_irqsave(&wport->lock, iflags);
|
|
if (erflown)
|
|
wport->flags |= ERFLOWN;
|
|
(void) __swb_inc_u(wport, nb);
|
|
if (wport->flags & HW_BUSY) {
|
|
spin_unlock_irqrestore(&wport->lock, iflags);
|
|
DBGPV("returning: HW BUSY\n");
|
|
return;
|
|
}
|
|
if (wport->flags & DISABLED) {
|
|
spin_unlock_irqrestore(&wport->lock, iflags);
|
|
DBGPV("returning: DISABLED\n");
|
|
return;
|
|
}
|
|
wport->flags |= HW_BUSY;
|
|
while (1) {
|
|
int swptr, hwptr, hw_avail, sw_avail, swidx;
|
|
vwsnd_port_hwstate_t hwstate = wport->hwstate;
|
|
vwsnd_port_swstate_t swstate = wport->swstate;
|
|
int hw_unavail;
|
|
ustmsc_t ustmsc;
|
|
|
|
hwptr = li_read_hwptr(&wport->chan);
|
|
swptr = li_read_swptr(&wport->chan);
|
|
hw_unavail = (swptr - hwptr + hwsize) % hwsize;
|
|
hw_avail = (hwmax - hw_unavail) & -fragsize;
|
|
sw_avail = wport->swb_i_avail & -fragsize;
|
|
if (sw_avail && swstate == SW_RUN) {
|
|
if (wport->flags & ERFLOWN) {
|
|
wport->flags &= ~ERFLOWN;
|
|
}
|
|
} else if (swstate == SW_INITIAL ||
|
|
swstate == SW_OFF ||
|
|
(swstate == SW_DRAIN &&
|
|
!sw_avail &&
|
|
(wport->flags & ERFLOWN))) {
|
|
DBGP("stopping. hwstate = %d\n", hwstate);
|
|
if (hwstate != HW_STOPPED) {
|
|
li_deactivate_dma(&wport->chan);
|
|
wport->hwstate = HW_STOPPED;
|
|
}
|
|
wake_up(&wport->queue);
|
|
break;
|
|
}
|
|
if (!sw_avail || !hw_avail)
|
|
break;
|
|
spin_unlock_irqrestore(&wport->lock, iflags);
|
|
|
|
/*
|
|
* We gave up the port lock, but we have the HW_BUSY flag.
|
|
* Proceed without accessing any nonlocal state.
|
|
* Do not exit the loop -- must check for more work.
|
|
*/
|
|
|
|
swidx = wport->swb_i_idx;
|
|
nb = hw_avail;
|
|
if (nb > sw_avail)
|
|
nb = sw_avail;
|
|
if (nb > hwsize - swptr)
|
|
nb = hwsize - swptr; /* don't overflow hwbuf */
|
|
if (nb > swsize - swidx)
|
|
nb = swsize - swidx; /* don't overflow swbuf */
|
|
ASSERT(nb > 0);
|
|
if (nb % fragsize) {
|
|
DBGP("nb = %d, fragsize = %d\n", nb, fragsize);
|
|
DBGP("hw_avail = %d\n", hw_avail);
|
|
DBGP("sw_avail = %d\n", sw_avail);
|
|
DBGP("hwsize = %d, swptr = %d\n", hwsize, swptr);
|
|
DBGP("swsize = %d, swidx = %d\n", swsize, swidx);
|
|
}
|
|
ASSERT(!(nb % fragsize));
|
|
DBGPV("copying swb[%d..%d] to hwb[%d..%d]\n",
|
|
swidx, swidx + nb, swptr, swptr + nb);
|
|
pcm_copy_out(wport, swidx, swptr, nb);
|
|
li_write_swptr(&wport->chan, (swptr + nb) % hwsize);
|
|
spin_lock_irqsave(&wport->lock, iflags);
|
|
if (hwstate == HW_STOPPED) {
|
|
DBGPV("starting\n");
|
|
li_activate_dma(&wport->chan);
|
|
wport->hwstate = HW_RUNNING;
|
|
li_read_USTMSC(&wport->chan, &ustmsc);
|
|
ASSERT(wport->byte_count % wport->frame_size == 0);
|
|
wport->MSC_offset = ustmsc.msc - wport->byte_count / wport->frame_size;
|
|
}
|
|
__swb_inc_i(wport, nb);
|
|
wport->byte_count += nb;
|
|
wport->frag_count += nb / fragsize;
|
|
ASSERT(nb % fragsize == 0);
|
|
wake_up(&wport->queue);
|
|
}
|
|
wport->flags &= ~HW_BUSY;
|
|
spin_unlock_irqrestore(&wport->lock, iflags);
|
|
DBGRV();
|
|
}
|
|
|
|
/*
|
|
* pcm_input() is called both from baselevel and from interrupt level.
|
|
* This is where audio frames are copied out of the hardware-accessible
|
|
* ring buffer.
|
|
*
|
|
* Locking note: The part of this routine that figures out what to do
|
|
* holds rport->lock. The longer part releases rport->lock, but sets
|
|
* rport->flags & HW_BUSY. Afterward, it reacquires rport->lock, and
|
|
* checks for more work to do.
|
|
*
|
|
* If another thread calls pcm_input() while HW_BUSY is set, it
|
|
* returns immediately, knowing that the thread that set HW_BUSY will
|
|
* look for more work to do before returning.
|
|
*
|
|
* This has the advantage that port->lock is held for several short
|
|
* periods instead of one long period. Also, when pcm_input is
|
|
* called from base level, it reenables interrupts.
|
|
*/
|
|
|
|
static void pcm_input(vwsnd_dev_t *devc, int erflown, int nb)
|
|
{
|
|
vwsnd_port_t *rport = &devc->rport;
|
|
const int hwmax = rport->hwbuf_max;
|
|
const int hwsize = rport->hwbuf_size;
|
|
const int swsize = rport->swbuf_size;
|
|
const int fragsize = rport->hw_fragsize;
|
|
unsigned long iflags;
|
|
|
|
DBGEV("(devc=0x%p, erflown=%d, nb=%d)\n", devc, erflown, nb);
|
|
|
|
spin_lock_irqsave(&rport->lock, iflags);
|
|
if (erflown)
|
|
rport->flags |= ERFLOWN;
|
|
(void) __swb_inc_u(rport, nb);
|
|
if (rport->flags & HW_BUSY || !rport->swbuf) {
|
|
spin_unlock_irqrestore(&rport->lock, iflags);
|
|
DBGPV("returning: HW BUSY or !swbuf\n");
|
|
return;
|
|
}
|
|
if (rport->flags & DISABLED) {
|
|
spin_unlock_irqrestore(&rport->lock, iflags);
|
|
DBGPV("returning: DISABLED\n");
|
|
return;
|
|
}
|
|
rport->flags |= HW_BUSY;
|
|
while (1) {
|
|
int swptr, hwptr, hw_avail, sw_avail, swidx;
|
|
vwsnd_port_hwstate_t hwstate = rport->hwstate;
|
|
vwsnd_port_swstate_t swstate = rport->swstate;
|
|
|
|
hwptr = li_read_hwptr(&rport->chan);
|
|
swptr = li_read_swptr(&rport->chan);
|
|
hw_avail = (hwptr - swptr + hwsize) % hwsize & -fragsize;
|
|
if (hw_avail > hwmax)
|
|
hw_avail = hwmax;
|
|
sw_avail = rport->swb_i_avail & -fragsize;
|
|
if (swstate != SW_RUN) {
|
|
DBGP("stopping. hwstate = %d\n", hwstate);
|
|
if (hwstate != HW_STOPPED) {
|
|
li_deactivate_dma(&rport->chan);
|
|
rport->hwstate = HW_STOPPED;
|
|
}
|
|
wake_up(&rport->queue);
|
|
break;
|
|
}
|
|
if (!sw_avail || !hw_avail)
|
|
break;
|
|
spin_unlock_irqrestore(&rport->lock, iflags);
|
|
|
|
/*
|
|
* We gave up the port lock, but we have the HW_BUSY flag.
|
|
* Proceed without accessing any nonlocal state.
|
|
* Do not exit the loop -- must check for more work.
|
|
*/
|
|
|
|
swidx = rport->swb_i_idx;
|
|
nb = hw_avail;
|
|
if (nb > sw_avail)
|
|
nb = sw_avail;
|
|
if (nb > hwsize - swptr)
|
|
nb = hwsize - swptr; /* don't overflow hwbuf */
|
|
if (nb > swsize - swidx)
|
|
nb = swsize - swidx; /* don't overflow swbuf */
|
|
ASSERT(nb > 0);
|
|
if (nb % fragsize) {
|
|
DBGP("nb = %d, fragsize = %d\n", nb, fragsize);
|
|
DBGP("hw_avail = %d\n", hw_avail);
|
|
DBGP("sw_avail = %d\n", sw_avail);
|
|
DBGP("hwsize = %d, swptr = %d\n", hwsize, swptr);
|
|
DBGP("swsize = %d, swidx = %d\n", swsize, swidx);
|
|
}
|
|
ASSERT(!(nb % fragsize));
|
|
DBGPV("copying hwb[%d..%d] to swb[%d..%d]\n",
|
|
swptr, swptr + nb, swidx, swidx + nb);
|
|
pcm_copy_in(rport, swidx, swptr, nb);
|
|
li_write_swptr(&rport->chan, (swptr + nb) % hwsize);
|
|
spin_lock_irqsave(&rport->lock, iflags);
|
|
__swb_inc_i(rport, nb);
|
|
rport->byte_count += nb;
|
|
rport->frag_count += nb / fragsize;
|
|
ASSERT(nb % fragsize == 0);
|
|
wake_up(&rport->queue);
|
|
}
|
|
rport->flags &= ~HW_BUSY;
|
|
spin_unlock_irqrestore(&rport->lock, iflags);
|
|
DBGRV();
|
|
}
|
|
|
|
/*
|
|
* pcm_flush_frag() writes zero samples to fill the current fragment,
|
|
* then flushes it to the hardware.
|
|
*
|
|
* It is only meaningful to flush output, not input.
|
|
*/
|
|
|
|
static void pcm_flush_frag(vwsnd_dev_t *devc)
|
|
{
|
|
vwsnd_port_t *wport = &devc->wport;
|
|
|
|
DBGPV("swstate = %d\n", wport->swstate);
|
|
if (wport->swstate == SW_RUN) {
|
|
int idx = wport->swb_u_idx;
|
|
int end = (idx + wport->hw_fragsize - 1)
|
|
>> wport->hw_fragshift
|
|
<< wport->hw_fragshift;
|
|
int nb = end - idx;
|
|
DBGPV("clearing %d bytes\n", nb);
|
|
if (nb)
|
|
memset(wport->swbuf + idx,
|
|
(char) wport->zero_word,
|
|
nb);
|
|
wport->swstate = SW_DRAIN;
|
|
pcm_output(devc, 0, nb);
|
|
}
|
|
DBGRV();
|
|
}
|
|
|
|
/*
|
|
* Wait for output to drain. This sleeps uninterruptibly because
|
|
* there is nothing intelligent we can do if interrupted. This
|
|
* means the process will be delayed in responding to the signal.
|
|
*/
|
|
|
|
static void pcm_write_sync(vwsnd_dev_t *devc)
|
|
{
|
|
vwsnd_port_t *wport = &devc->wport;
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
unsigned long flags;
|
|
vwsnd_port_hwstate_t hwstate;
|
|
|
|
DBGEV("(devc=0x%p)\n", devc);
|
|
add_wait_queue(&wport->queue, &wait);
|
|
while (1) {
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
spin_lock_irqsave(&wport->lock, flags);
|
|
{
|
|
hwstate = wport->hwstate;
|
|
}
|
|
spin_unlock_irqrestore(&wport->lock, flags);
|
|
if (hwstate == HW_STOPPED)
|
|
break;
|
|
schedule();
|
|
}
|
|
current->state = TASK_RUNNING;
|
|
remove_wait_queue(&wport->queue, &wait);
|
|
DBGPV("swstate = %d, hwstate = %d\n", wport->swstate, wport->hwstate);
|
|
DBGRV();
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* audio driver */
|
|
|
|
/*
|
|
* seek on an audio device always fails.
|
|
*/
|
|
|
|
static void vwsnd_audio_read_intr(vwsnd_dev_t *devc, unsigned int status)
|
|
{
|
|
int overflown = status & LI_INTR_COMM1_OVERFLOW;
|
|
|
|
if (status & READ_INTR_MASK)
|
|
pcm_input(devc, overflown, 0);
|
|
}
|
|
|
|
static void vwsnd_audio_write_intr(vwsnd_dev_t *devc, unsigned int status)
|
|
{
|
|
int underflown = status & LI_INTR_COMM2_UNDERFLOW;
|
|
|
|
if (status & WRITE_INTR_MASK)
|
|
pcm_output(devc, underflown, 0);
|
|
}
|
|
|
|
static irqreturn_t vwsnd_audio_intr(int irq, void *dev_id)
|
|
{
|
|
vwsnd_dev_t *devc = dev_id;
|
|
unsigned int status;
|
|
|
|
DBGEV("(irq=%d, dev_id=0x%p)\n", irq, dev_id);
|
|
|
|
status = li_get_clear_intr_status(&devc->lith);
|
|
vwsnd_audio_read_intr(devc, status);
|
|
vwsnd_audio_write_intr(devc, status);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static ssize_t vwsnd_audio_do_read(struct file *file,
|
|
char *buffer,
|
|
size_t count,
|
|
loff_t *ppos)
|
|
{
|
|
vwsnd_dev_t *devc = file->private_data;
|
|
vwsnd_port_t *rport = ((file->f_mode & FMODE_READ) ?
|
|
&devc->rport : NULL);
|
|
int ret, nb;
|
|
|
|
DBGEV("(file=0x%p, buffer=0x%p, count=%d, ppos=0x%p)\n",
|
|
file, buffer, count, ppos);
|
|
|
|
if (!rport)
|
|
return -EINVAL;
|
|
|
|
if (rport->swbuf == NULL) {
|
|
vwsnd_port_t *wport = (file->f_mode & FMODE_WRITE) ?
|
|
&devc->wport : NULL;
|
|
ret = pcm_setup(devc, rport, wport);
|
|
if (ret < 0)
|
|
return ret;
|
|
}
|
|
|
|
if (!access_ok(VERIFY_READ, buffer, count))
|
|
return -EFAULT;
|
|
ret = 0;
|
|
while (count) {
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
add_wait_queue(&rport->queue, &wait);
|
|
while ((nb = swb_inc_u(rport, 0)) == 0) {
|
|
DBGPV("blocking\n");
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
if (rport->flags & DISABLED ||
|
|
file->f_flags & O_NONBLOCK) {
|
|
current->state = TASK_RUNNING;
|
|
remove_wait_queue(&rport->queue, &wait);
|
|
return ret ? ret : -EAGAIN;
|
|
}
|
|
schedule();
|
|
if (signal_pending(current)) {
|
|
current->state = TASK_RUNNING;
|
|
remove_wait_queue(&rport->queue, &wait);
|
|
return ret ? ret : -ERESTARTSYS;
|
|
}
|
|
}
|
|
current->state = TASK_RUNNING;
|
|
remove_wait_queue(&rport->queue, &wait);
|
|
pcm_input(devc, 0, 0);
|
|
/* nb bytes are available in userbuf. */
|
|
if (nb > count)
|
|
nb = count;
|
|
DBGPV("nb = %d\n", nb);
|
|
if (copy_to_user(buffer, rport->swbuf + rport->swb_u_idx, nb))
|
|
return -EFAULT;
|
|
(void) swb_inc_u(rport, nb);
|
|
buffer += nb;
|
|
count -= nb;
|
|
ret += nb;
|
|
}
|
|
DBGPV("returning %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t vwsnd_audio_read(struct file *file,
|
|
char *buffer,
|
|
size_t count,
|
|
loff_t *ppos)
|
|
{
|
|
vwsnd_dev_t *devc = file->private_data;
|
|
ssize_t ret;
|
|
|
|
mutex_lock(&devc->io_mutex);
|
|
ret = vwsnd_audio_do_read(file, buffer, count, ppos);
|
|
mutex_unlock(&devc->io_mutex);
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t vwsnd_audio_do_write(struct file *file,
|
|
const char *buffer,
|
|
size_t count,
|
|
loff_t *ppos)
|
|
{
|
|
vwsnd_dev_t *devc = file->private_data;
|
|
vwsnd_port_t *wport = ((file->f_mode & FMODE_WRITE) ?
|
|
&devc->wport : NULL);
|
|
int ret, nb;
|
|
|
|
DBGEV("(file=0x%p, buffer=0x%p, count=%d, ppos=0x%p)\n",
|
|
file, buffer, count, ppos);
|
|
|
|
if (!wport)
|
|
return -EINVAL;
|
|
|
|
if (wport->swbuf == NULL) {
|
|
vwsnd_port_t *rport = (file->f_mode & FMODE_READ) ?
|
|
&devc->rport : NULL;
|
|
ret = pcm_setup(devc, rport, wport);
|
|
if (ret < 0)
|
|
return ret;
|
|
}
|
|
if (!access_ok(VERIFY_WRITE, buffer, count))
|
|
return -EFAULT;
|
|
ret = 0;
|
|
while (count) {
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
add_wait_queue(&wport->queue, &wait);
|
|
while ((nb = swb_inc_u(wport, 0)) == 0) {
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
if (wport->flags & DISABLED ||
|
|
file->f_flags & O_NONBLOCK) {
|
|
current->state = TASK_RUNNING;
|
|
remove_wait_queue(&wport->queue, &wait);
|
|
return ret ? ret : -EAGAIN;
|
|
}
|
|
schedule();
|
|
if (signal_pending(current)) {
|
|
current->state = TASK_RUNNING;
|
|
remove_wait_queue(&wport->queue, &wait);
|
|
return ret ? ret : -ERESTARTSYS;
|
|
}
|
|
}
|
|
current->state = TASK_RUNNING;
|
|
remove_wait_queue(&wport->queue, &wait);
|
|
/* nb bytes are available in userbuf. */
|
|
if (nb > count)
|
|
nb = count;
|
|
DBGPV("nb = %d\n", nb);
|
|
if (copy_from_user(wport->swbuf + wport->swb_u_idx, buffer, nb))
|
|
return -EFAULT;
|
|
pcm_output(devc, 0, nb);
|
|
buffer += nb;
|
|
count -= nb;
|
|
ret += nb;
|
|
}
|
|
DBGPV("returning %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t vwsnd_audio_write(struct file *file,
|
|
const char *buffer,
|
|
size_t count,
|
|
loff_t *ppos)
|
|
{
|
|
vwsnd_dev_t *devc = file->private_data;
|
|
ssize_t ret;
|
|
|
|
mutex_lock(&devc->io_mutex);
|
|
ret = vwsnd_audio_do_write(file, buffer, count, ppos);
|
|
mutex_unlock(&devc->io_mutex);
|
|
return ret;
|
|
}
|
|
|
|
/* No kernel lock - fine */
|
|
static unsigned int vwsnd_audio_poll(struct file *file,
|
|
struct poll_table_struct *wait)
|
|
{
|
|
vwsnd_dev_t *devc = (vwsnd_dev_t *) file->private_data;
|
|
vwsnd_port_t *rport = (file->f_mode & FMODE_READ) ?
|
|
&devc->rport : NULL;
|
|
vwsnd_port_t *wport = (file->f_mode & FMODE_WRITE) ?
|
|
&devc->wport : NULL;
|
|
unsigned int mask = 0;
|
|
|
|
DBGEV("(file=0x%p, wait=0x%p)\n", file, wait);
|
|
|
|
ASSERT(rport || wport);
|
|
if (rport) {
|
|
poll_wait(file, &rport->queue, wait);
|
|
if (swb_inc_u(rport, 0))
|
|
mask |= (POLLIN | POLLRDNORM);
|
|
}
|
|
if (wport) {
|
|
poll_wait(file, &wport->queue, wait);
|
|
if (wport->swbuf == NULL || swb_inc_u(wport, 0))
|
|
mask |= (POLLOUT | POLLWRNORM);
|
|
}
|
|
|
|
DBGPV("returning 0x%x\n", mask);
|
|
return mask;
|
|
}
|
|
|
|
static int vwsnd_audio_do_ioctl(struct inode *inode,
|
|
struct file *file,
|
|
unsigned int cmd,
|
|
unsigned long arg)
|
|
{
|
|
vwsnd_dev_t *devc = (vwsnd_dev_t *) file->private_data;
|
|
vwsnd_port_t *rport = (file->f_mode & FMODE_READ) ?
|
|
&devc->rport : NULL;
|
|
vwsnd_port_t *wport = (file->f_mode & FMODE_WRITE) ?
|
|
&devc->wport : NULL;
|
|
vwsnd_port_t *aport = rport ? rport : wport;
|
|
struct audio_buf_info buf_info;
|
|
struct count_info info;
|
|
unsigned long flags;
|
|
int ival;
|
|
|
|
|
|
DBGEV("(inode=0x%p, file=0x%p, cmd=0x%x, arg=0x%lx)\n",
|
|
inode, file, cmd, arg);
|
|
switch (cmd) {
|
|
case OSS_GETVERSION: /* _SIOR ('M', 118, int) */
|
|
DBGX("OSS_GETVERSION\n");
|
|
ival = SOUND_VERSION;
|
|
return put_user(ival, (int *) arg);
|
|
|
|
case SNDCTL_DSP_GETCAPS: /* _SIOR ('P',15, int) */
|
|
DBGX("SNDCTL_DSP_GETCAPS\n");
|
|
ival = DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER;
|
|
return put_user(ival, (int *) arg);
|
|
|
|
case SNDCTL_DSP_GETFMTS: /* _SIOR ('P',11, int) */
|
|
DBGX("SNDCTL_DSP_GETFMTS\n");
|
|
ival = (AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW |
|
|
AFMT_U8 | AFMT_S8);
|
|
return put_user(ival, (int *) arg);
|
|
break;
|
|
|
|
case SOUND_PCM_READ_RATE: /* _SIOR ('P', 2, int) */
|
|
DBGX("SOUND_PCM_READ_RATE\n");
|
|
ival = aport->sw_framerate;
|
|
return put_user(ival, (int *) arg);
|
|
|
|
case SOUND_PCM_READ_CHANNELS: /* _SIOR ('P', 6, int) */
|
|
DBGX("SOUND_PCM_READ_CHANNELS\n");
|
|
ival = aport->sw_channels;
|
|
return put_user(ival, (int *) arg);
|
|
|
|
case SNDCTL_DSP_SPEED: /* _SIOWR('P', 2, int) */
|
|
if (get_user(ival, (int *) arg))
|
|
return -EFAULT;
|
|
DBGX("SNDCTL_DSP_SPEED %d\n", ival);
|
|
if (ival) {
|
|
if (aport->swstate != SW_INITIAL) {
|
|
DBGX("SNDCTL_DSP_SPEED failed: swstate = %d\n",
|
|
aport->swstate);
|
|
return -EINVAL;
|
|
}
|
|
if (ival < MIN_SPEED)
|
|
ival = MIN_SPEED;
|
|
if (ival > MAX_SPEED)
|
|
ival = MAX_SPEED;
|
|
if (rport)
|
|
rport->sw_framerate = ival;
|
|
if (wport)
|
|
wport->sw_framerate = ival;
|
|
} else
|
|
ival = aport->sw_framerate;
|
|
return put_user(ival, (int *) arg);
|
|
|
|
case SNDCTL_DSP_STEREO: /* _SIOWR('P', 3, int) */
|
|
if (get_user(ival, (int *) arg))
|
|
return -EFAULT;
|
|
DBGX("SNDCTL_DSP_STEREO %d\n", ival);
|
|
if (ival != 0 && ival != 1)
|
|
return -EINVAL;
|
|
if (aport->swstate != SW_INITIAL)
|
|
return -EINVAL;
|
|
if (rport)
|
|
rport->sw_channels = ival + 1;
|
|
if (wport)
|
|
wport->sw_channels = ival + 1;
|
|
return put_user(ival, (int *) arg);
|
|
|
|
case SNDCTL_DSP_CHANNELS: /* _SIOWR('P', 6, int) */
|
|
if (get_user(ival, (int *) arg))
|
|
return -EFAULT;
|
|
DBGX("SNDCTL_DSP_CHANNELS %d\n", ival);
|
|
if (ival != 1 && ival != 2)
|
|
return -EINVAL;
|
|
if (aport->swstate != SW_INITIAL)
|
|
return -EINVAL;
|
|
if (rport)
|
|
rport->sw_channels = ival;
|
|
if (wport)
|
|
wport->sw_channels = ival;
|
|
return put_user(ival, (int *) arg);
|
|
|
|
case SNDCTL_DSP_GETBLKSIZE: /* _SIOWR('P', 4, int) */
|
|
ival = pcm_setup(devc, rport, wport);
|
|
if (ival < 0) {
|
|
DBGX("SNDCTL_DSP_GETBLKSIZE failed, errno %d\n", ival);
|
|
return ival;
|
|
}
|
|
ival = 1 << aport->sw_fragshift;
|
|
DBGX("SNDCTL_DSP_GETBLKSIZE returning %d\n", ival);
|
|
return put_user(ival, (int *) arg);
|
|
|
|
case SNDCTL_DSP_SETFRAGMENT: /* _SIOWR('P',10, int) */
|
|
if (get_user(ival, (int *) arg))
|
|
return -EFAULT;
|
|
DBGX("SNDCTL_DSP_SETFRAGMENT %d:%d\n",
|
|
ival >> 16, ival & 0xFFFF);
|
|
if (aport->swstate != SW_INITIAL)
|
|
return -EINVAL;
|
|
{
|
|
int sw_fragshift = ival & 0xFFFF;
|
|
int sw_subdivshift = aport->sw_subdivshift;
|
|
int hw_fragshift = sw_fragshift - sw_subdivshift;
|
|
int sw_fragcount = (ival >> 16) & 0xFFFF;
|
|
int hw_fragsize;
|
|
if (hw_fragshift < MIN_FRAGSHIFT)
|
|
hw_fragshift = MIN_FRAGSHIFT;
|
|
if (hw_fragshift > MAX_FRAGSHIFT)
|
|
hw_fragshift = MAX_FRAGSHIFT;
|
|
sw_fragshift = hw_fragshift + aport->sw_subdivshift;
|
|
hw_fragsize = 1 << hw_fragshift;
|
|
if (sw_fragcount < MIN_FRAGCOUNT(hw_fragsize))
|
|
sw_fragcount = MIN_FRAGCOUNT(hw_fragsize);
|
|
if (sw_fragcount > MAX_FRAGCOUNT(hw_fragsize))
|
|
sw_fragcount = MAX_FRAGCOUNT(hw_fragsize);
|
|
DBGPV("sw_fragshift = %d\n", sw_fragshift);
|
|
DBGPV("rport = 0x%p, wport = 0x%p\n", rport, wport);
|
|
if (rport) {
|
|
rport->sw_fragshift = sw_fragshift;
|
|
rport->sw_fragcount = sw_fragcount;
|
|
}
|
|
if (wport) {
|
|
wport->sw_fragshift = sw_fragshift;
|
|
wport->sw_fragcount = sw_fragcount;
|
|
}
|
|
ival = sw_fragcount << 16 | sw_fragshift;
|
|
}
|
|
DBGX("SNDCTL_DSP_SETFRAGMENT returns %d:%d\n",
|
|
ival >> 16, ival & 0xFFFF);
|
|
return put_user(ival, (int *) arg);
|
|
|
|
case SNDCTL_DSP_SUBDIVIDE: /* _SIOWR('P', 9, int) */
|
|
if (get_user(ival, (int *) arg))
|
|
return -EFAULT;
|
|
DBGX("SNDCTL_DSP_SUBDIVIDE %d\n", ival);
|
|
if (aport->swstate != SW_INITIAL)
|
|
return -EINVAL;
|
|
{
|
|
int subdivshift;
|
|
int hw_fragshift, hw_fragsize, hw_fragcount;
|
|
switch (ival) {
|
|
case 1: subdivshift = 0; break;
|
|
case 2: subdivshift = 1; break;
|
|
case 4: subdivshift = 2; break;
|
|
default: return -EINVAL;
|
|
}
|
|
hw_fragshift = aport->sw_fragshift - subdivshift;
|
|
if (hw_fragshift < MIN_FRAGSHIFT ||
|
|
hw_fragshift > MAX_FRAGSHIFT)
|
|
return -EINVAL;
|
|
hw_fragsize = 1 << hw_fragshift;
|
|
hw_fragcount = aport->sw_fragcount >> subdivshift;
|
|
if (hw_fragcount < MIN_FRAGCOUNT(hw_fragsize) ||
|
|
hw_fragcount > MAX_FRAGCOUNT(hw_fragsize))
|
|
return -EINVAL;
|
|
if (rport)
|
|
rport->sw_subdivshift = subdivshift;
|
|
if (wport)
|
|
wport->sw_subdivshift = subdivshift;
|
|
}
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_SETFMT: /* _SIOWR('P',5, int) */
|
|
if (get_user(ival, (int *) arg))
|
|
return -EFAULT;
|
|
DBGX("SNDCTL_DSP_SETFMT %d\n", ival);
|
|
if (ival != AFMT_QUERY) {
|
|
if (aport->swstate != SW_INITIAL) {
|
|
DBGP("SETFMT failed, swstate = %d\n",
|
|
aport->swstate);
|
|
return -EINVAL;
|
|
}
|
|
switch (ival) {
|
|
case AFMT_MU_LAW:
|
|
case AFMT_A_LAW:
|
|
case AFMT_U8:
|
|
case AFMT_S8:
|
|
case AFMT_S16_LE:
|
|
if (rport)
|
|
rport->sw_samplefmt = ival;
|
|
if (wport)
|
|
wport->sw_samplefmt = ival;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
ival = aport->sw_samplefmt;
|
|
return put_user(ival, (int *) arg);
|
|
|
|
case SNDCTL_DSP_GETOSPACE: /* _SIOR ('P',12, audio_buf_info) */
|
|
DBGXV("SNDCTL_DSP_GETOSPACE\n");
|
|
if (!wport)
|
|
return -EINVAL;
|
|
ival = pcm_setup(devc, rport, wport);
|
|
if (ival < 0)
|
|
return ival;
|
|
ival = swb_inc_u(wport, 0);
|
|
buf_info.fragments = ival >> wport->sw_fragshift;
|
|
buf_info.fragstotal = wport->sw_fragcount;
|
|
buf_info.fragsize = 1 << wport->sw_fragshift;
|
|
buf_info.bytes = ival;
|
|
DBGXV("SNDCTL_DSP_GETOSPACE returns { %d %d %d %d }\n",
|
|
buf_info.fragments, buf_info.fragstotal,
|
|
buf_info.fragsize, buf_info.bytes);
|
|
if (copy_to_user((void *) arg, &buf_info, sizeof buf_info))
|
|
return -EFAULT;
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_GETISPACE: /* _SIOR ('P',13, audio_buf_info) */
|
|
DBGX("SNDCTL_DSP_GETISPACE\n");
|
|
if (!rport)
|
|
return -EINVAL;
|
|
ival = pcm_setup(devc, rport, wport);
|
|
if (ival < 0)
|
|
return ival;
|
|
ival = swb_inc_u(rport, 0);
|
|
buf_info.fragments = ival >> rport->sw_fragshift;
|
|
buf_info.fragstotal = rport->sw_fragcount;
|
|
buf_info.fragsize = 1 << rport->sw_fragshift;
|
|
buf_info.bytes = ival;
|
|
DBGX("SNDCTL_DSP_GETISPACE returns { %d %d %d %d }\n",
|
|
buf_info.fragments, buf_info.fragstotal,
|
|
buf_info.fragsize, buf_info.bytes);
|
|
if (copy_to_user((void *) arg, &buf_info, sizeof buf_info))
|
|
return -EFAULT;
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_NONBLOCK: /* _SIO ('P',14) */
|
|
DBGX("SNDCTL_DSP_NONBLOCK\n");
|
|
file->f_flags |= O_NONBLOCK;
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_RESET: /* _SIO ('P', 0) */
|
|
DBGX("SNDCTL_DSP_RESET\n");
|
|
/*
|
|
* Nothing special needs to be done for input. Input
|
|
* samples sit in swbuf, but it will be reinitialized
|
|
* to empty when pcm_setup() is called.
|
|
*/
|
|
if (wport && wport->swbuf) {
|
|
wport->swstate = SW_INITIAL;
|
|
pcm_output(devc, 0, 0);
|
|
pcm_write_sync(devc);
|
|
}
|
|
pcm_shutdown(devc, rport, wport);
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_SYNC: /* _SIO ('P', 1) */
|
|
DBGX("SNDCTL_DSP_SYNC\n");
|
|
if (wport) {
|
|
pcm_flush_frag(devc);
|
|
pcm_write_sync(devc);
|
|
}
|
|
pcm_shutdown(devc, rport, wport);
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_POST: /* _SIO ('P', 8) */
|
|
DBGX("SNDCTL_DSP_POST\n");
|
|
if (!wport)
|
|
return -EINVAL;
|
|
pcm_flush_frag(devc);
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_GETIPTR: /* _SIOR ('P', 17, count_info) */
|
|
DBGX("SNDCTL_DSP_GETIPTR\n");
|
|
if (!rport)
|
|
return -EINVAL;
|
|
spin_lock_irqsave(&rport->lock, flags);
|
|
{
|
|
ustmsc_t ustmsc;
|
|
if (rport->hwstate == HW_RUNNING) {
|
|
ASSERT(rport->swstate == SW_RUN);
|
|
li_read_USTMSC(&rport->chan, &ustmsc);
|
|
info.bytes = ustmsc.msc - rport->MSC_offset;
|
|
info.bytes *= rport->frame_size;
|
|
} else {
|
|
info.bytes = rport->byte_count;
|
|
}
|
|
info.blocks = rport->frag_count;
|
|
info.ptr = 0; /* not implemented */
|
|
rport->frag_count = 0;
|
|
}
|
|
spin_unlock_irqrestore(&rport->lock, flags);
|
|
if (copy_to_user((void *) arg, &info, sizeof info))
|
|
return -EFAULT;
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_GETOPTR: /* _SIOR ('P',18, count_info) */
|
|
DBGX("SNDCTL_DSP_GETOPTR\n");
|
|
if (!wport)
|
|
return -EINVAL;
|
|
spin_lock_irqsave(&wport->lock, flags);
|
|
{
|
|
ustmsc_t ustmsc;
|
|
if (wport->hwstate == HW_RUNNING) {
|
|
ASSERT(wport->swstate == SW_RUN);
|
|
li_read_USTMSC(&wport->chan, &ustmsc);
|
|
info.bytes = ustmsc.msc - wport->MSC_offset;
|
|
info.bytes *= wport->frame_size;
|
|
} else {
|
|
info.bytes = wport->byte_count;
|
|
}
|
|
info.blocks = wport->frag_count;
|
|
info.ptr = 0; /* not implemented */
|
|
wport->frag_count = 0;
|
|
}
|
|
spin_unlock_irqrestore(&wport->lock, flags);
|
|
if (copy_to_user((void *) arg, &info, sizeof info))
|
|
return -EFAULT;
|
|
return 0;
|
|
|
|
case SNDCTL_DSP_GETODELAY: /* _SIOR ('P', 23, int) */
|
|
DBGX("SNDCTL_DSP_GETODELAY\n");
|
|
if (!wport)
|
|
return -EINVAL;
|
|
spin_lock_irqsave(&wport->lock, flags);
|
|
{
|
|
int fsize = wport->frame_size;
|
|
ival = wport->swb_i_avail / fsize;
|
|
if (wport->hwstate == HW_RUNNING) {
|
|
int swptr, hwptr, hwframes, hwbytes, hwsize;
|
|
int totalhwbytes;
|
|
ustmsc_t ustmsc;
|
|
|
|
hwsize = wport->hwbuf_size;
|
|
swptr = li_read_swptr(&wport->chan);
|
|
li_read_USTMSC(&wport->chan, &ustmsc);
|
|
hwframes = ustmsc.msc - wport->MSC_offset;
|
|
totalhwbytes = hwframes * fsize;
|
|
hwptr = totalhwbytes % hwsize;
|
|
hwbytes = (swptr - hwptr + hwsize) % hwsize;
|
|
ival += hwbytes / fsize;
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&wport->lock, flags);
|
|
return put_user(ival, (int *) arg);
|
|
|
|
case SNDCTL_DSP_PROFILE: /* _SIOW ('P', 23, int) */
|
|
DBGX("SNDCTL_DSP_PROFILE\n");
|
|
|
|
/*
|
|
* Thomas Sailer explains SNDCTL_DSP_PROFILE
|
|
* (private email, March 24, 1999):
|
|
*
|
|
* This gives the sound driver a hint on what it
|
|
* should do with partial fragments
|
|
* (i.e. fragments partially filled with write).
|
|
* This can direct the driver to zero them or
|
|
* leave them alone. But don't ask me what this
|
|
* is good for, my driver just zeroes the last
|
|
* fragment before the receiver stops, no idea
|
|
* what good for any other behaviour could
|
|
* be. Implementing it as NOP seems safe.
|
|
*/
|
|
|
|
break;
|
|
|
|
case SNDCTL_DSP_GETTRIGGER: /* _SIOR ('P',16, int) */
|
|
DBGX("SNDCTL_DSP_GETTRIGGER\n");
|
|
ival = 0;
|
|
if (rport) {
|
|
spin_lock_irqsave(&rport->lock, flags);
|
|
{
|
|
if (!(rport->flags & DISABLED))
|
|
ival |= PCM_ENABLE_INPUT;
|
|
}
|
|
spin_unlock_irqrestore(&rport->lock, flags);
|
|
}
|
|
if (wport) {
|
|
spin_lock_irqsave(&wport->lock, flags);
|
|
{
|
|
if (!(wport->flags & DISABLED))
|
|
ival |= PCM_ENABLE_OUTPUT;
|
|
}
|
|
spin_unlock_irqrestore(&wport->lock, flags);
|
|
}
|
|
return put_user(ival, (int *) arg);
|
|
|
|
case SNDCTL_DSP_SETTRIGGER: /* _SIOW ('P',16, int) */
|
|
if (get_user(ival, (int *) arg))
|
|
return -EFAULT;
|
|
DBGX("SNDCTL_DSP_SETTRIGGER %d\n", ival);
|
|
|
|
/*
|
|
* If user is disabling I/O and port is not in initial
|
|
* state, fail with EINVAL.
|
|
*/
|
|
|
|
if (((rport && !(ival & PCM_ENABLE_INPUT)) ||
|
|
(wport && !(ival & PCM_ENABLE_OUTPUT))) &&
|
|
aport->swstate != SW_INITIAL)
|
|
return -EINVAL;
|
|
|
|
if (rport) {
|
|
vwsnd_port_hwstate_t hwstate;
|
|
spin_lock_irqsave(&rport->lock, flags);
|
|
{
|
|
hwstate = rport->hwstate;
|
|
if (ival & PCM_ENABLE_INPUT)
|
|
rport->flags &= ~DISABLED;
|
|
else
|
|
rport->flags |= DISABLED;
|
|
}
|
|
spin_unlock_irqrestore(&rport->lock, flags);
|
|
if (hwstate != HW_RUNNING && ival & PCM_ENABLE_INPUT) {
|
|
|
|
if (rport->swstate == SW_INITIAL)
|
|
pcm_setup(devc, rport, wport);
|
|
else
|
|
li_activate_dma(&rport->chan);
|
|
}
|
|
}
|
|
if (wport) {
|
|
vwsnd_port_flags_t pflags;
|
|
spin_lock_irqsave(&wport->lock, flags);
|
|
{
|
|
pflags = wport->flags;
|
|
if (ival & PCM_ENABLE_OUTPUT)
|
|
wport->flags &= ~DISABLED;
|
|
else
|
|
wport->flags |= DISABLED;
|
|
}
|
|
spin_unlock_irqrestore(&wport->lock, flags);
|
|
if (pflags & DISABLED && ival & PCM_ENABLE_OUTPUT) {
|
|
if (wport->swstate == SW_RUN)
|
|
pcm_output(devc, 0, 0);
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
default:
|
|
DBGP("unknown ioctl 0x%x\n", cmd);
|
|
return -EINVAL;
|
|
}
|
|
DBGP("unimplemented ioctl 0x%x\n", cmd);
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int vwsnd_audio_ioctl(struct inode *inode,
|
|
struct file *file,
|
|
unsigned int cmd,
|
|
unsigned long arg)
|
|
{
|
|
vwsnd_dev_t *devc = (vwsnd_dev_t *) file->private_data;
|
|
int ret;
|
|
|
|
mutex_lock(&devc->io_mutex);
|
|
ret = vwsnd_audio_do_ioctl(inode, file, cmd, arg);
|
|
mutex_unlock(&devc->io_mutex);
|
|
return ret;
|
|
}
|
|
|
|
/* No mmap. */
|
|
|
|
static int vwsnd_audio_mmap(struct file *file, struct vm_area_struct *vma)
|
|
{
|
|
DBGE("(file=0x%p, vma=0x%p)\n", file, vma);
|
|
return -ENODEV;
|
|
}
|
|
|
|
/*
|
|
* Open the audio device for read and/or write.
|
|
*
|
|
* Returns 0 on success, -errno on failure.
|
|
*/
|
|
|
|
static int vwsnd_audio_open(struct inode *inode, struct file *file)
|
|
{
|
|
vwsnd_dev_t *devc;
|
|
int minor = iminor(inode);
|
|
int sw_samplefmt;
|
|
|
|
DBGE("(inode=0x%p, file=0x%p)\n", inode, file);
|
|
|
|
INC_USE_COUNT;
|
|
for (devc = vwsnd_dev_list; devc; devc = devc->next_dev)
|
|
if ((devc->audio_minor & ~0x0F) == (minor & ~0x0F))
|
|
break;
|
|
|
|
if (devc == NULL) {
|
|
DEC_USE_COUNT;
|
|
return -ENODEV;
|
|
}
|
|
|
|
mutex_lock(&devc->open_mutex);
|
|
while (devc->open_mode & file->f_mode) {
|
|
mutex_unlock(&devc->open_mutex);
|
|
if (file->f_flags & O_NONBLOCK) {
|
|
DEC_USE_COUNT;
|
|
return -EBUSY;
|
|
}
|
|
interruptible_sleep_on(&devc->open_wait);
|
|
if (signal_pending(current)) {
|
|
DEC_USE_COUNT;
|
|
return -ERESTARTSYS;
|
|
}
|
|
mutex_lock(&devc->open_mutex);
|
|
}
|
|
devc->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
|
|
mutex_unlock(&devc->open_mutex);
|
|
|
|
/* get default sample format from minor number. */
|
|
|
|
sw_samplefmt = 0;
|
|
if ((minor & 0xF) == SND_DEV_DSP)
|
|
sw_samplefmt = AFMT_U8;
|
|
else if ((minor & 0xF) == SND_DEV_AUDIO)
|
|
sw_samplefmt = AFMT_MU_LAW;
|
|
else if ((minor & 0xF) == SND_DEV_DSP16)
|
|
sw_samplefmt = AFMT_S16_LE;
|
|
else
|
|
ASSERT(0);
|
|
|
|
/* Initialize vwsnd_ports. */
|
|
|
|
mutex_lock(&devc->io_mutex);
|
|
{
|
|
if (file->f_mode & FMODE_READ) {
|
|
devc->rport.swstate = SW_INITIAL;
|
|
devc->rport.flags = 0;
|
|
devc->rport.sw_channels = 1;
|
|
devc->rport.sw_samplefmt = sw_samplefmt;
|
|
devc->rport.sw_framerate = 8000;
|
|
devc->rport.sw_fragshift = DEFAULT_FRAGSHIFT;
|
|
devc->rport.sw_fragcount = DEFAULT_FRAGCOUNT;
|
|
devc->rport.sw_subdivshift = DEFAULT_SUBDIVSHIFT;
|
|
devc->rport.byte_count = 0;
|
|
devc->rport.frag_count = 0;
|
|
}
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
devc->wport.swstate = SW_INITIAL;
|
|
devc->wport.flags = 0;
|
|
devc->wport.sw_channels = 1;
|
|
devc->wport.sw_samplefmt = sw_samplefmt;
|
|
devc->wport.sw_framerate = 8000;
|
|
devc->wport.sw_fragshift = DEFAULT_FRAGSHIFT;
|
|
devc->wport.sw_fragcount = DEFAULT_FRAGCOUNT;
|
|
devc->wport.sw_subdivshift = DEFAULT_SUBDIVSHIFT;
|
|
devc->wport.byte_count = 0;
|
|
devc->wport.frag_count = 0;
|
|
}
|
|
}
|
|
mutex_unlock(&devc->io_mutex);
|
|
|
|
file->private_data = devc;
|
|
DBGRV();
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Release (close) the audio device.
|
|
*/
|
|
|
|
static int vwsnd_audio_release(struct inode *inode, struct file *file)
|
|
{
|
|
vwsnd_dev_t *devc = (vwsnd_dev_t *) file->private_data;
|
|
vwsnd_port_t *wport = NULL, *rport = NULL;
|
|
int err = 0;
|
|
|
|
lock_kernel();
|
|
mutex_lock(&devc->io_mutex);
|
|
{
|
|
DBGEV("(inode=0x%p, file=0x%p)\n", inode, file);
|
|
|
|
if (file->f_mode & FMODE_READ)
|
|
rport = &devc->rport;
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
wport = &devc->wport;
|
|
pcm_flush_frag(devc);
|
|
pcm_write_sync(devc);
|
|
}
|
|
pcm_shutdown(devc, rport, wport);
|
|
if (rport)
|
|
rport->swstate = SW_OFF;
|
|
if (wport)
|
|
wport->swstate = SW_OFF;
|
|
}
|
|
mutex_unlock(&devc->io_mutex);
|
|
|
|
mutex_lock(&devc->open_mutex);
|
|
{
|
|
devc->open_mode &= ~file->f_mode;
|
|
}
|
|
mutex_unlock(&devc->open_mutex);
|
|
wake_up(&devc->open_wait);
|
|
DEC_USE_COUNT;
|
|
DBGR();
|
|
unlock_kernel();
|
|
return err;
|
|
}
|
|
|
|
static const struct file_operations vwsnd_audio_fops = {
|
|
.owner = THIS_MODULE,
|
|
.llseek = no_llseek,
|
|
.read = vwsnd_audio_read,
|
|
.write = vwsnd_audio_write,
|
|
.poll = vwsnd_audio_poll,
|
|
.ioctl = vwsnd_audio_ioctl,
|
|
.mmap = vwsnd_audio_mmap,
|
|
.open = vwsnd_audio_open,
|
|
.release = vwsnd_audio_release,
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
/* mixer driver */
|
|
|
|
/* open the mixer device. */
|
|
|
|
static int vwsnd_mixer_open(struct inode *inode, struct file *file)
|
|
{
|
|
vwsnd_dev_t *devc;
|
|
|
|
DBGEV("(inode=0x%p, file=0x%p)\n", inode, file);
|
|
|
|
INC_USE_COUNT;
|
|
for (devc = vwsnd_dev_list; devc; devc = devc->next_dev)
|
|
if (devc->mixer_minor == iminor(inode))
|
|
break;
|
|
|
|
if (devc == NULL) {
|
|
DEC_USE_COUNT;
|
|
return -ENODEV;
|
|
}
|
|
file->private_data = devc;
|
|
return 0;
|
|
}
|
|
|
|
/* release (close) the mixer device. */
|
|
|
|
static int vwsnd_mixer_release(struct inode *inode, struct file *file)
|
|
{
|
|
DBGEV("(inode=0x%p, file=0x%p)\n", inode, file);
|
|
DEC_USE_COUNT;
|
|
return 0;
|
|
}
|
|
|
|
/* mixer_read_ioctl handles all read ioctls on the mixer device. */
|
|
|
|
static int mixer_read_ioctl(vwsnd_dev_t *devc, unsigned int nr, void __user *arg)
|
|
{
|
|
int val = -1;
|
|
|
|
DBGEV("(devc=0x%p, nr=0x%x, arg=0x%p)\n", devc, nr, arg);
|
|
|
|
switch (nr) {
|
|
case SOUND_MIXER_CAPS:
|
|
val = SOUND_CAP_EXCL_INPUT;
|
|
break;
|
|
|
|
case SOUND_MIXER_DEVMASK:
|
|
val = (SOUND_MASK_PCM | SOUND_MASK_LINE |
|
|
SOUND_MASK_MIC | SOUND_MASK_CD | SOUND_MASK_RECLEV);
|
|
break;
|
|
|
|
case SOUND_MIXER_STEREODEVS:
|
|
val = (SOUND_MASK_PCM | SOUND_MASK_LINE |
|
|
SOUND_MASK_MIC | SOUND_MASK_CD | SOUND_MASK_RECLEV);
|
|
break;
|
|
|
|
case SOUND_MIXER_OUTMASK:
|
|
val = (SOUND_MASK_PCM | SOUND_MASK_LINE |
|
|
SOUND_MASK_MIC | SOUND_MASK_CD);
|
|
break;
|
|
|
|
case SOUND_MIXER_RECMASK:
|
|
val = (SOUND_MASK_PCM | SOUND_MASK_LINE |
|
|
SOUND_MASK_MIC | SOUND_MASK_CD);
|
|
break;
|
|
|
|
case SOUND_MIXER_PCM:
|
|
val = ad1843_get_gain(&devc->lith, &ad1843_gain_PCM);
|
|
break;
|
|
|
|
case SOUND_MIXER_LINE:
|
|
val = ad1843_get_gain(&devc->lith, &ad1843_gain_LINE);
|
|
break;
|
|
|
|
case SOUND_MIXER_MIC:
|
|
val = ad1843_get_gain(&devc->lith, &ad1843_gain_MIC);
|
|
break;
|
|
|
|
case SOUND_MIXER_CD:
|
|
val = ad1843_get_gain(&devc->lith, &ad1843_gain_CD);
|
|
break;
|
|
|
|
case SOUND_MIXER_RECLEV:
|
|
val = ad1843_get_gain(&devc->lith, &ad1843_gain_RECLEV);
|
|
break;
|
|
|
|
case SOUND_MIXER_RECSRC:
|
|
val = ad1843_get_recsrc(&devc->lith);
|
|
break;
|
|
|
|
case SOUND_MIXER_OUTSRC:
|
|
val = ad1843_get_outsrc(&devc->lith);
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
return put_user(val, (int __user *) arg);
|
|
}
|
|
|
|
/* mixer_write_ioctl handles all write ioctls on the mixer device. */
|
|
|
|
static int mixer_write_ioctl(vwsnd_dev_t *devc, unsigned int nr, void __user *arg)
|
|
{
|
|
int val;
|
|
int err;
|
|
|
|
DBGEV("(devc=0x%p, nr=0x%x, arg=0x%p)\n", devc, nr, arg);
|
|
|
|
err = get_user(val, (int __user *) arg);
|
|
if (err)
|
|
return -EFAULT;
|
|
switch (nr) {
|
|
case SOUND_MIXER_PCM:
|
|
val = ad1843_set_gain(&devc->lith, &ad1843_gain_PCM, val);
|
|
break;
|
|
|
|
case SOUND_MIXER_LINE:
|
|
val = ad1843_set_gain(&devc->lith, &ad1843_gain_LINE, val);
|
|
break;
|
|
|
|
case SOUND_MIXER_MIC:
|
|
val = ad1843_set_gain(&devc->lith, &ad1843_gain_MIC, val);
|
|
break;
|
|
|
|
case SOUND_MIXER_CD:
|
|
val = ad1843_set_gain(&devc->lith, &ad1843_gain_CD, val);
|
|
break;
|
|
|
|
case SOUND_MIXER_RECLEV:
|
|
val = ad1843_set_gain(&devc->lith, &ad1843_gain_RECLEV, val);
|
|
break;
|
|
|
|
case SOUND_MIXER_RECSRC:
|
|
if (devc->rport.swbuf || devc->wport.swbuf)
|
|
return -EBUSY; /* can't change recsrc while running */
|
|
val = ad1843_set_recsrc(&devc->lith, val);
|
|
break;
|
|
|
|
case SOUND_MIXER_OUTSRC:
|
|
val = ad1843_set_outsrc(&devc->lith, val);
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
if (val < 0)
|
|
return val;
|
|
return put_user(val, (int __user *) arg);
|
|
}
|
|
|
|
/* This is the ioctl entry to the mixer driver. */
|
|
|
|
static int vwsnd_mixer_ioctl(struct inode *ioctl,
|
|
struct file *file,
|
|
unsigned int cmd,
|
|
unsigned long arg)
|
|
{
|
|
vwsnd_dev_t *devc = (vwsnd_dev_t *) file->private_data;
|
|
const unsigned int nrmask = _IOC_NRMASK << _IOC_NRSHIFT;
|
|
const unsigned int nr = (cmd & nrmask) >> _IOC_NRSHIFT;
|
|
int retval;
|
|
|
|
DBGEV("(devc=0x%p, cmd=0x%x, arg=0x%lx)\n", devc, cmd, arg);
|
|
|
|
mutex_lock(&devc->mix_mutex);
|
|
{
|
|
if ((cmd & ~nrmask) == MIXER_READ(0))
|
|
retval = mixer_read_ioctl(devc, nr, (void __user *) arg);
|
|
else if ((cmd & ~nrmask) == MIXER_WRITE(0))
|
|
retval = mixer_write_ioctl(devc, nr, (void __user *) arg);
|
|
else
|
|
retval = -EINVAL;
|
|
}
|
|
mutex_unlock(&devc->mix_mutex);
|
|
return retval;
|
|
}
|
|
|
|
static const struct file_operations vwsnd_mixer_fops = {
|
|
.owner = THIS_MODULE,
|
|
.llseek = no_llseek,
|
|
.ioctl = vwsnd_mixer_ioctl,
|
|
.open = vwsnd_mixer_open,
|
|
.release = vwsnd_mixer_release,
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
/* probe/attach/unload */
|
|
|
|
/* driver probe routine. Return nonzero if hardware is found. */
|
|
|
|
static int __init probe_vwsnd(struct address_info *hw_config)
|
|
{
|
|
lithium_t lith;
|
|
int w;
|
|
unsigned long later;
|
|
|
|
DBGEV("(hw_config=0x%p)\n", hw_config);
|
|
|
|
/* XXX verify lithium present (to prevent crash on non-vw) */
|
|
|
|
if (li_create(&lith, hw_config->io_base) != 0) {
|
|
printk(KERN_WARNING "probe_vwsnd: can't map lithium\n");
|
|
return 0;
|
|
}
|
|
later = jiffies + 2;
|
|
li_writel(&lith, LI_HOST_CONTROLLER, LI_HC_LINK_ENABLE);
|
|
do {
|
|
w = li_readl(&lith, LI_HOST_CONTROLLER);
|
|
} while (w == LI_HC_LINK_ENABLE && time_before(jiffies, later));
|
|
|
|
li_destroy(&lith);
|
|
|
|
DBGPV("HC = 0x%04x\n", w);
|
|
|
|
if ((w == LI_HC_LINK_ENABLE) || (w & LI_HC_LINK_CODEC)) {
|
|
|
|
/* This may indicate a beta machine with no audio,
|
|
* or a future machine with different audio.
|
|
* On beta-release 320 w/ no audio, HC == 0x4000 */
|
|
|
|
printk(KERN_WARNING "probe_vwsnd: audio codec not found\n");
|
|
return 0;
|
|
}
|
|
|
|
if (w & LI_HC_LINK_FAILURE) {
|
|
printk(KERN_WARNING "probe_vwsnd: can't init audio codec\n");
|
|
return 0;
|
|
}
|
|
|
|
printk(KERN_INFO "vwsnd: lithium audio at mmio %#x irq %d\n",
|
|
hw_config->io_base, hw_config->irq);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* driver attach routine. Initialize driver data structures and
|
|
* initialize hardware. A new vwsnd_dev_t is allocated and put
|
|
* onto the global list, vwsnd_dev_list.
|
|
*
|
|
* Return +minor_dev on success, -errno on failure.
|
|
*/
|
|
|
|
static int __init attach_vwsnd(struct address_info *hw_config)
|
|
{
|
|
vwsnd_dev_t *devc = NULL;
|
|
int err = -ENOMEM;
|
|
|
|
DBGEV("(hw_config=0x%p)\n", hw_config);
|
|
|
|
devc = kmalloc(sizeof (vwsnd_dev_t), GFP_KERNEL);
|
|
if (devc == NULL)
|
|
goto fail0;
|
|
|
|
err = li_create(&devc->lith, hw_config->io_base);
|
|
if (err)
|
|
goto fail1;
|
|
|
|
init_waitqueue_head(&devc->open_wait);
|
|
|
|
devc->rport.hwbuf_size = HWBUF_SIZE;
|
|
devc->rport.hwbuf_vaddr = __get_free_pages(GFP_KERNEL, HWBUF_ORDER);
|
|
if (!devc->rport.hwbuf_vaddr)
|
|
goto fail2;
|
|
devc->rport.hwbuf = (void *) devc->rport.hwbuf_vaddr;
|
|
devc->rport.hwbuf_paddr = virt_to_phys(devc->rport.hwbuf);
|
|
|
|
/*
|
|
* Quote from the NT driver:
|
|
*
|
|
* // WARNING!!! HACK to setup output dma!!!
|
|
* // This is required because even on output there is some data
|
|
* // trickling into the input DMA channel. This is a bug in the
|
|
* // Lithium microcode.
|
|
* // --sde
|
|
*
|
|
* We set the input side's DMA base address here. It will remain
|
|
* valid until the driver is unloaded.
|
|
*/
|
|
|
|
li_writel(&devc->lith, LI_COMM1_BASE,
|
|
devc->rport.hwbuf_paddr >> 8 | 1 << (37 - 8));
|
|
|
|
devc->wport.hwbuf_size = HWBUF_SIZE;
|
|
devc->wport.hwbuf_vaddr = __get_free_pages(GFP_KERNEL, HWBUF_ORDER);
|
|
if (!devc->wport.hwbuf_vaddr)
|
|
goto fail3;
|
|
devc->wport.hwbuf = (void *) devc->wport.hwbuf_vaddr;
|
|
devc->wport.hwbuf_paddr = virt_to_phys(devc->wport.hwbuf);
|
|
DBGP("wport hwbuf = 0x%p\n", devc->wport.hwbuf);
|
|
|
|
DBGDO(shut_up++);
|
|
err = ad1843_init(&devc->lith);
|
|
DBGDO(shut_up--);
|
|
if (err)
|
|
goto fail4;
|
|
|
|
/* install interrupt handler */
|
|
|
|
err = request_irq(hw_config->irq, vwsnd_audio_intr, 0, "vwsnd", devc);
|
|
if (err)
|
|
goto fail5;
|
|
|
|
/* register this device's drivers. */
|
|
|
|
devc->audio_minor = register_sound_dsp(&vwsnd_audio_fops, -1);
|
|
if ((err = devc->audio_minor) < 0) {
|
|
DBGDO(printk(KERN_WARNING
|
|
"attach_vwsnd: register_sound_dsp error %d\n",
|
|
err));
|
|
goto fail6;
|
|
}
|
|
devc->mixer_minor = register_sound_mixer(&vwsnd_mixer_fops,
|
|
devc->audio_minor >> 4);
|
|
if ((err = devc->mixer_minor) < 0) {
|
|
DBGDO(printk(KERN_WARNING
|
|
"attach_vwsnd: register_sound_mixer error %d\n",
|
|
err));
|
|
goto fail7;
|
|
}
|
|
|
|
/* Squirrel away device indices for unload routine. */
|
|
|
|
hw_config->slots[0] = devc->audio_minor;
|
|
|
|
/* Initialize as much of *devc as possible */
|
|
|
|
mutex_init(&devc->open_mutex);
|
|
mutex_init(&devc->io_mutex);
|
|
mutex_init(&devc->mix_mutex);
|
|
devc->open_mode = 0;
|
|
spin_lock_init(&devc->rport.lock);
|
|
init_waitqueue_head(&devc->rport.queue);
|
|
devc->rport.swstate = SW_OFF;
|
|
devc->rport.hwstate = HW_STOPPED;
|
|
devc->rport.flags = 0;
|
|
devc->rport.swbuf = NULL;
|
|
spin_lock_init(&devc->wport.lock);
|
|
init_waitqueue_head(&devc->wport.queue);
|
|
devc->wport.swstate = SW_OFF;
|
|
devc->wport.hwstate = HW_STOPPED;
|
|
devc->wport.flags = 0;
|
|
devc->wport.swbuf = NULL;
|
|
|
|
/* Success. Link us onto the local device list. */
|
|
|
|
devc->next_dev = vwsnd_dev_list;
|
|
vwsnd_dev_list = devc;
|
|
return devc->audio_minor;
|
|
|
|
/* So many ways to fail. Undo what we did. */
|
|
|
|
fail7:
|
|
unregister_sound_dsp(devc->audio_minor);
|
|
fail6:
|
|
free_irq(hw_config->irq, devc);
|
|
fail5:
|
|
fail4:
|
|
free_pages(devc->wport.hwbuf_vaddr, HWBUF_ORDER);
|
|
fail3:
|
|
free_pages(devc->rport.hwbuf_vaddr, HWBUF_ORDER);
|
|
fail2:
|
|
li_destroy(&devc->lith);
|
|
fail1:
|
|
kfree(devc);
|
|
fail0:
|
|
return err;
|
|
}
|
|
|
|
static int __exit unload_vwsnd(struct address_info *hw_config)
|
|
{
|
|
vwsnd_dev_t *devc, **devcp;
|
|
|
|
DBGE("()\n");
|
|
|
|
devcp = &vwsnd_dev_list;
|
|
while ((devc = *devcp)) {
|
|
if (devc->audio_minor == hw_config->slots[0]) {
|
|
*devcp = devc->next_dev;
|
|
break;
|
|
}
|
|
devcp = &devc->next_dev;
|
|
}
|
|
|
|
if (!devc)
|
|
return -ENODEV;
|
|
|
|
unregister_sound_mixer(devc->mixer_minor);
|
|
unregister_sound_dsp(devc->audio_minor);
|
|
free_irq(hw_config->irq, devc);
|
|
free_pages(devc->wport.hwbuf_vaddr, HWBUF_ORDER);
|
|
free_pages(devc->rport.hwbuf_vaddr, HWBUF_ORDER);
|
|
li_destroy(&devc->lith);
|
|
kfree(devc);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* initialization and loadable kernel module interface */
|
|
|
|
static struct address_info the_hw_config = {
|
|
0xFF001000, /* lithium phys addr */
|
|
CO_IRQ(CO_APIC_LI_AUDIO) /* irq */
|
|
};
|
|
|
|
MODULE_DESCRIPTION("SGI Visual Workstation sound module");
|
|
MODULE_AUTHOR("Bob Miller <kbob@sgi.com>");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
static int __init init_vwsnd(void)
|
|
{
|
|
int err;
|
|
|
|
DBGXV("\n");
|
|
DBGXV("sound::vwsnd::init_module()\n");
|
|
|
|
if (!probe_vwsnd(&the_hw_config))
|
|
return -ENODEV;
|
|
|
|
err = attach_vwsnd(&the_hw_config);
|
|
if (err < 0)
|
|
return err;
|
|
return 0;
|
|
}
|
|
|
|
static void __exit cleanup_vwsnd(void)
|
|
{
|
|
DBGX("sound::vwsnd::cleanup_module()\n");
|
|
|
|
unload_vwsnd(&the_hw_config);
|
|
}
|
|
|
|
module_init(init_vwsnd);
|
|
module_exit(cleanup_vwsnd);
|